fix(agent): address CodeRabbit comments on Gemini target

- Make MANAGED_SECTION_BEGIN target-neutral ('testsprite agent install')
  instead of 'testsprite agent install codex'; add MANAGED_SECTION_BEGIN_LEGACY
  for backward-compat recognition of existing AGENTS.md files
- classifySection now accepts both the new and legacy BEGIN sentinel
- Add exit-code and JSON output assertions to Gemini e2e install test
- Add managed-section user-content preservation test: pre-populates
  GEMINI.md, runs install twice, asserts prefix/suffix intact and
  section byte-identical across runs
- Clarify renderForTarget unit test: sentinel wrapping is an install-time
  concern, not a renderForTarget concern

Author: Tasfia-17

src/commands/agent.ts

@@ -22,6 +22,7 @@ import {
   renderForTarget,
   renderOwnFileWithMarker,
   MANAGED_SECTION_BEGIN,
+  MANAGED_SECTION_BEGIN_LEGACY,
   MANAGED_SECTION_END,
 } from '../lib/agent-targets.js';
 
@@ -206,7 +207,8 @@ function classifySection(existing: string, section: string): SectionState {
 
   for (let i = 0; i < lines.length; i++) {
     const stripped = (lines[i] ?? '').trimEnd();
-    if (stripped === MANAGED_SECTION_BEGIN) beginLines.push(i);
+    if (stripped === MANAGED_SECTION_BEGIN || stripped === MANAGED_SECTION_BEGIN_LEGACY)
+      beginLines.push(i);
     else if (stripped === MANAGED_SECTION_END) endLines.push(i);
   }
 

src/lib/agent-targets.test.ts

@@ -409,8 +409,13 @@ describe('renderForTarget("gemini")', () => {
 
   it('renders the verify body content (managed-section, compact codex body)', () => {
     // Uses real bodies: gemini uses the codex contribution body (compact).
+    // renderForTarget for managed-section returns the unwrapped body (no
+    // sentinels) — sentinel wrapping happens at install time via buildSection.
     const gemini = renderForTarget('gemini', 'testsprite-verify');
     expect(gemini.content).toContain('testsprite test run');
+    // Body must NOT be wrapped in sentinels at this layer
+    expect(gemini.content).not.toContain(MANAGED_SECTION_BEGIN);
+    expect(gemini.content).not.toContain(MANAGED_SECTION_END);
   });
 });
 

src/lib/agent-targets.ts

@@ -300,11 +300,20 @@ export const TARGETS: Record<AgentTarget, TargetSpec> = {
   },
 };
 
-/** Sentinel pair that bounds our managed section in AGENTS.md. */
+/** Sentinel pair that bounds our managed section in AGENTS.md / GEMINI.md. */
 export const MANAGED_SECTION_BEGIN =
-  '<!-- BEGIN TESTSPRITE AGENT SECTION (testsprite agent install codex) -->';
+  '<!-- BEGIN TESTSPRITE AGENT SECTION (testsprite agent install) -->';
 export const MANAGED_SECTION_END = '<!-- END TESTSPRITE AGENT SECTION -->';
 
+/**
+ * Legacy sentinel written by versions prior to this change.
+ * Kept for backward-compatibility: existing AGENTS.md files that contain
+ * the old Codex-labelled marker are still recognised as a valid managed
+ * section during classify / replace operations.
+ */
+export const MANAGED_SECTION_BEGIN_LEGACY =
+  '<!-- BEGIN TESTSPRITE AGENT SECTION (testsprite agent install codex) -->';
+
 // ---------------------------------------------------------------------------
 // Install marker (stale-skill detection, issue #123)
 // ---------------------------------------------------------------------------

test/e2e/agent-install.e2e.test.ts

@@ -274,7 +274,23 @@ describe('content integrity', () => {
 
   it('gemini GEMINI.md contains ONE managed section with verify and onboard content', () => {
     const tmpDir = freshTmpDir();
-    runCli(['agent', 'install', '--target=gemini', '--dir', tmpDir, '--output', 'json']);
+    const result = runCli(['agent', 'install', '--target=gemini', '--dir', tmpDir, '--output', 'json']);
+
+    // Exit code must be 0
+    expect(result.status, 'gemini install: exit code').toBe(0);
+
+    // stdout must be valid JSON with the expected entry
+    const parsed = JSON.parse(result.stdout) as Array<{
+      target: string;
+      path: string;
+      action: string;
+      skills: string[];
+    }>;
+    expect(Array.isArray(parsed), 'output should be a JSON array').toBe(true);
+    const entry = parsed.find(r => r.target === 'gemini');
+    expect(entry, 'gemini entry in JSON output').toBeDefined();
+    expect(entry!.action, 'gemini action').toBe('section-installed');
+    expect(entry!.path).toBe(TARGETS.gemini.path);
 
     const filePath = join(tmpDir, TARGETS.gemini.path);
     const content = readFileSync(filePath, 'utf8');
@@ -302,6 +318,57 @@ describe('content integrity', () => {
     // (d) No frontmatter fence -- GEMINI.md is plain prose
     expect(content.startsWith('---'), 'gemini: must NOT start with ---').toBe(false);
   });
+
+  it('gemini managed-section preserves user content outside sentinels across re-runs', () => {
+    const tmpDir = freshTmpDir();
+    const filePath = join(tmpDir, TARGETS.gemini.path);
+
+    // Pre-populate GEMINI.md with user content above and below where the
+    // managed section will land.
+    const userPrefix = '# My Project\n\nSome hand-written instructions.\n\n';
+    const userSuffix = '\n## Extra notes\n\nMore user content here.\n';
+    writeFileSync(filePath, userPrefix + userSuffix, 'utf8');
+
+    // First install: merges managed section into the file
+    const first = runCli(['agent', 'install', '--target=gemini', '--dir', tmpDir, '--output', 'json']);
+    expect(first.status, 'first install: exit code').toBe(0);
+
+    const afterFirst = readFileSync(filePath, 'utf8');
+    expect(afterFirst).toContain(userPrefix.trimEnd());
+    expect(afterFirst).toContain(userSuffix.trim());
+    expect(afterFirst).toContain(MANAGED_SECTION_BEGIN);
+    expect(afterFirst).toContain(MANAGED_SECTION_END);
+
+    // Capture the managed section content for comparison across runs
+    const sectionAfterFirst = afterFirst.slice(
+      afterFirst.indexOf(MANAGED_SECTION_BEGIN),
+      afterFirst.indexOf(MANAGED_SECTION_END) + MANAGED_SECTION_END.length,
+    );
+
+    // Second install (re-run): must be idempotent and preserve user content
+    const second = runCli(['agent', 'install', '--target=gemini', '--dir', tmpDir, '--output', 'json']);
+    expect(second.status, 'second install: exit code').toBe(0);
+
+    const afterSecond = readFileSync(filePath, 'utf8');
+
+    // User content outside sentinels must be intact
+    expect(afterSecond).toContain(userPrefix.trimEnd());
+    expect(afterSecond).toContain(userSuffix.trim());
+
+    // Exactly one pair of sentinels after re-run
+    const escRe2 = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const beginCount2 = (afterSecond.match(new RegExp(escRe2(MANAGED_SECTION_BEGIN), 'g')) ?? []).length;
+    const endCount2 = (afterSecond.match(new RegExp(escRe2(MANAGED_SECTION_END), 'g')) ?? []).length;
+    expect(beginCount2, 'exactly one BEGIN sentinel after re-run').toBe(1);
+    expect(endCount2, 'exactly one END sentinel after re-run').toBe(1);
+
+    // Managed section content must be byte-identical between runs
+    const sectionAfterSecond = afterSecond.slice(
+      afterSecond.indexOf(MANAGED_SECTION_BEGIN),
+      afterSecond.indexOf(MANAGED_SECTION_END) + MANAGED_SECTION_END.length,
+    );
+    expect(sectionAfterSecond).toBe(sectionAfterFirst);
+  });
 });
 // ---------------------------------------------------------------------------
 // 3. Idempotent re-run