fix(import): enforce Gemini Takeout field boundaries

Author: rodboev

cmd/agentsview/import.go

@@ -57,7 +57,11 @@ func runImport(cfg ImportConfig) {
 	}
 
 	if err != nil {
-		fmt.Fprintln(os.Stderr)
+		if summary := formatImportFailureSummary(stats); summary != "" {
+			fmt.Fprint(os.Stderr, summary)
+		} else {
+			fmt.Fprintln(os.Stderr)
+		}
 		log.Fatalf("Import failed: %v", err)
 	}
 
@@ -168,8 +172,13 @@ func runGeminiAppsImport(
 }
 
 func printImportSummary(stats importer.ImportStats) {
+	fmt.Fprint(os.Stderr, formatImportSummary(stats))
+}
+
+func formatImportSummary(stats importer.ImportStats) string {
+	var summary strings.Builder
 	total := stats.Imported + stats.Updated + stats.Skipped
-	fmt.Fprintf(os.Stderr, "\rDone: %d processed", total)
+	fmt.Fprintf(&summary, "\rDone: %d processed", total)
 	var parts []string
 	if stats.Imported > 0 {
 		parts = append(
@@ -187,14 +196,20 @@ func printImportSummary(stats importer.ImportStats) {
 		)
 	}
 	if len(parts) > 0 {
-		fmt.Fprintf(
-			os.Stderr, " (%s)", strings.Join(parts, ", "),
-		)
+		fmt.Fprintf(&summary, " (%s)", strings.Join(parts, ", "))
 	}
-	fmt.Fprintln(os.Stderr)
+	fmt.Fprintln(&summary)
 	if stats.Errors > 0 {
-		fmt.Fprintf(os.Stderr, "  %d errors\n", stats.Errors)
+		fmt.Fprintf(&summary, "  %d errors\n", stats.Errors)
+	}
+	return summary.String()
+}
+
+func formatImportFailureSummary(stats importer.ImportStats) string {
+	if stats.Imported+stats.Updated+stats.Skipped+stats.Errors == 0 {
+		return ""
 	}
+	return formatImportSummary(stats)
 }
 
 // resolveImportSource handles zip extraction. If the path is

cmd/agentsview/parse_diff_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.kenn.io/agentsview/internal/db"
 	"go.kenn.io/agentsview/internal/dbtest"
+	"go.kenn.io/agentsview/internal/importer"
 	"go.kenn.io/agentsview/internal/parser"
 	"go.kenn.io/agentsview/internal/sync"
 	"go.kenn.io/agentsview/internal/testjsonl"
@@ -63,6 +64,20 @@ func TestGeminiAppsImportDispatchesDirectAndZipSources(t *testing.T) {
 		filepath.Join(t.TempDir(), "missing.html"), t.TempDir(), "test-machine",
 	)
 	assert.ErrorContains(t, err, "stat import source")
+
+	nonPrompt := filepath.Join(t.TempDir(), "non-prompt.html")
+	require.NoError(t, os.WriteFile(
+		nonPrompt,
+		[]byte(strings.Replace(geminiAppsCLIHTML, "<p>Prompted</p>", "<p>Canvas</p>", 1)),
+		0o644,
+	))
+	stats, err = runImportDispatch(
+		context.Background(), database, "gemini-apps", nonPrompt, t.TempDir(), "test-machine",
+	)
+	assert.ErrorContains(t, err, "no admissible Prompted records")
+	assert.Equal(t, 1, stats.Skipped)
+	assert.Equal(t, "\rDone: 1 processed (1 skipped)\n", formatImportFailureSummary(stats))
+	assert.Empty(t, formatImportFailureSummary(importer.ImportStats{}))
 }
 
 // isolateParseDiffEnv points the data dir, HOME, and every per-agent

internal/parser/gemini_apps_takeout.go

@@ -325,29 +325,35 @@ func isGeminiAppsHeading(tag string) bool {
 
 func geminiAppsRecordKind(tokens []html.Token) string {
 	zones := geminiAppsZones(tokens)
-	var label string
 	for _, zone := range zones {
-		if zone.name == "header" {
-			label = strings.ToLower(renderGeminiAppsTokens(zone.tokens))
-			break
+		if zone.name != "header" {
+			continue
 		}
-	}
-	if label == "" {
-		label = strings.ToLower(renderGeminiAppsTokens(tokens))
-	}
-	label = strings.Join(strings.Fields(label), " ")
-	for _, candidate := range []struct{ label, kind string }{
-		{"prompted", "prompted"},
-		{"canvas", "canvas"},
-		{"feedback", "feedback"},
-	} {
-		if containsWord(label, candidate.label) {
-			return candidate.kind
+		for _, field := range geminiAppsTextFields(renderGeminiAppsTokens(zone.tokens)) {
+			switch field {
+			case "prompted":
+				return "prompted"
+			case "canvas":
+				return "canvas"
+			case "feedback":
+				return "feedback"
+			}
 		}
 	}
 	return "unknown"
 }
 
+func geminiAppsTextFields(value string) []string {
+	var fields []string
+	for _, line := range strings.Split(value, "\n") {
+		field := strings.ToLower(strings.Join(strings.Fields(line), " "))
+		if field != "" {
+			fields = append(fields, field)
+		}
+	}
+	return fields
+}
+
 func containsWord(text, word string) bool {
 	for _, field := range strings.FieldsFunc(text, func(r rune) bool {
 		return r < 'A' || (r > 'Z' && r < 'a') || r > 'z'
@@ -425,23 +431,26 @@ func hasHTMLClass(token html.Token, wanted string) bool {
 }
 
 func parseGeminiAppsCell(tokens []html.Token) (ParseResult, error) {
-	text := renderGeminiAppsTokens(tokens)
-	match := geminiAppsTimestampRE.FindStringSubmatch(text)
+	zones := geminiAppsZones(tokens)
+	var headerText string
+	var contentZones [][]html.Token
+	for _, zone := range zones {
+		switch zone.name {
+		case "header":
+			headerText = renderGeminiAppsTokens(zone.tokens)
+		case "content":
+			contentZones = append(contentZones, zone.tokens)
+		}
+	}
+	match := geminiAppsTimestampRE.FindStringSubmatch(headerText)
 	if len(match) != 2 {
-		return ParseResult{}, fmt.Errorf("activity record has no supported timestamp")
+		return ParseResult{}, fmt.Errorf("activity record has no supported header timestamp")
 	}
 	ts, err := parseGeminiAppsTimestamp(match[0], match[1])
 	if err != nil {
 		return ParseResult{}, err
 	}
 
-	zones := geminiAppsZones(tokens)
-	var contentZones [][]html.Token
-	for _, zone := range zones {
-		if zone.name == "content" {
-			contentZones = append(contentZones, zone.tokens)
-		}
-	}
 	if len(contentZones) == 0 {
 		return ParseResult{}, fmt.Errorf(
 			"Prompted activity record has no content cell",
@@ -505,27 +514,13 @@ func geminiAppsPromptAndResponse(zones [][]html.Token) (string, string) {
 	}
 
 	value := rendered[0]
-	for _, marker := range []string{"Response:", "Answer:"} {
-		if before, after, ok := cutFold(value, marker); ok {
-			return strings.TrimSpace(strings.TrimSuffix(before, "Prompt:")), strings.TrimSpace(after)
-		}
-	}
 	blocks := splitGeminiAppsBlocks(zones[0])
 	if len(blocks) > 1 {
 		return blocks[0], strings.TrimSpace(strings.Join(blocks[1:], "\n\n"))
 	}
 	return value, ""
 }
 
-func cutFold(value, marker string) (string, string, bool) {
-	lower := strings.ToLower(value)
-	index := strings.Index(lower, strings.ToLower(marker))
-	if index < 0 {
-		return "", "", false
-	}
-	return value[:index], value[index+len(marker):], true
-}
-
 func splitGeminiAppsBlocks(tokens []html.Token) []string {
 	var blocks []string
 	var block []html.Token

internal/parser/gemini_apps_takeout_test.go

@@ -72,6 +72,82 @@ func TestParseGeminiAppsExportRealOuterCellHeaderShape(t *testing.T) {
 	assert.Equal(t, firstID, repeated[0].Session.ID)
 }
 
+func TestParseGeminiAppsRejectsNotPromptedActivityLabel(t *testing.T) {
+	fixture := strings.ReplaceAll(
+		sanitizedGeminiAppsHTML,
+		"<p>Prompted<br></p>",
+		"<p>Not Prompted</p>",
+	)
+	path := filepath.Join(t.TempDir(), "not-prompted.html")
+	require.NoError(t, os.WriteFile(path, []byte(fixture), 0o644))
+
+	provider, ok := NewProvider(AgentGeminiApps, ProviderConfig{})
+	require.True(t, ok)
+	exporter := provider.(GeminiAppsExportParser)
+	var results []ParseResult
+	summary, err := exporter.ParseGeminiAppsExport(path, func(result ParseResult) error {
+		results = append(results, result)
+		return nil
+	})
+	assert.Empty(t, results)
+	assert.Equal(t, 5, summary.Skipped)
+	assert.ErrorContains(t, err, "no admissible Prompted records")
+}
+
+func TestParseGeminiAppsPreservesOrdinaryResponseAndAnswerText(t *testing.T) {
+	fixture := strings.Replace(
+		sanitizedGeminiAppsHTML,
+		`<div class="content-cell mdl-cell"><p>first prompt<br></p><p><strong>first</strong> answer &amp; detail</p><script>secret script</script><style>secret style</style><template>secret template</template><noscript>secret noscript</noscript></div>`,
+		`<div class="content-cell mdl-cell"><p>ordinary Response: and Answer: text</p></div>`,
+		1,
+	)
+	path := filepath.Join(t.TempDir(), "ordinary-markers.html")
+	require.NoError(t, os.WriteFile(path, []byte(fixture), 0o644))
+
+	provider, ok := NewProvider(AgentGeminiApps, ProviderConfig{})
+	require.True(t, ok)
+	exporter := provider.(GeminiAppsExportParser)
+	var results []ParseResult
+	_, err := exporter.ParseGeminiAppsExport(path, func(result ParseResult) error {
+		results = append(results, result)
+		return nil
+	})
+	require.NoError(t, err)
+	require.Len(t, results, 2)
+	require.Len(t, results[0].Messages, 1)
+	assert.Equal(t, "ordinary Response: and Answer: text", results[0].Messages[0].Content)
+}
+
+func TestParseGeminiAppsTimestampMustBeInHeader(t *testing.T) {
+	fixture := strings.Replace(
+		sanitizedGeminiAppsHTML,
+		"<p>Jan 2, 2025, 3:04:05 PM EDT</p>",
+		"<p>header timestamp missing</p>",
+		1,
+	)
+	fixture = strings.Replace(
+		fixture,
+		"<p>first prompt<br></p>",
+		"<p>Jan 2, 2025, 3:04:05 PM EDT</p><p>first prompt</p>",
+		1,
+	)
+	path := filepath.Join(t.TempDir(), "content-date.html")
+	require.NoError(t, os.WriteFile(path, []byte(fixture), 0o644))
+
+	provider, ok := NewProvider(AgentGeminiApps, ProviderConfig{})
+	require.True(t, ok)
+	exporter := provider.(GeminiAppsExportParser)
+	var results []ParseResult
+	summary, err := exporter.ParseGeminiAppsExport(path, func(result ParseResult) error {
+		results = append(results, result)
+		return nil
+	})
+	require.NoError(t, err)
+	assert.Len(t, results, 1)
+	assert.Equal(t, 1, summary.Errors)
+	assert.Equal(t, "second prompt", results[0].Messages[0].Content)
+}
+
 func TestParseGeminiAppsExportAdmitsDirectoryAndRejectsOtherHTML(t *testing.T) {
 	root := t.TempDir()
 	require.NoError(t, os.WriteFile(