@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/decisions-projection-from-memories.test.ts

@@ -142,6 +142,57 @@ test("backfill is idempotent — re-running over migrated rows is a no-op", () =
   }
 });
 
+test("backfill skips a decision whose memory insert throws and continues later rows", () => {
+  const base = makeTmpBase();
+  try {
+    seedRawDecision({
+      id: "D001",
+      when_context: "M001",
+      scope: "M001",
+      decision: "before poison",
+      choice: "A",
+      rationale: "first row",
+    });
+    seedRawDecision({
+      id: "D002",
+      when_context: "M001",
+      scope: "M001",
+      decision: "poison",
+      choice: "B",
+      rationale: "this insert throws",
+    });
+    seedRawDecision({
+      id: "D003",
+      when_context: "M001",
+      scope: "M001",
+      decision: "after poison",
+      choice: "C",
+      rationale: "tail row",
+    });
+
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    adapter.exec(`
+      CREATE TRIGGER fail_d002_memory_insert
+      BEFORE INSERT ON memories
+      WHEN json_extract(NEW.structured_fields, '$.sourceDecisionId') = 'D002'
+      BEGIN
+        SELECT RAISE(ABORT, 'poison decision D002');
+      END
+    `);
+
+    const written = backfillDecisionsToMemories();
+    assert.equal(written, 2, "one poisoned row should not abort the batch");
+    assert.deepEqual(
+      getAllDecisionsFromMemories().map((d) => d.id),
+      ["D001", "D003"],
+      "rows after the poisoned decision should still be migrated",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Drift auto-heal ───────────────────────────────────────────────────────
 
 test("backfill auto-heals when a source decision's superseded_by changes after migration", () => {

package/src/resources/extensions/gsd/tests/destructive-guard.test.ts

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyCommand } from "../safety/destructive-guard.ts";
+
+test("destructive guard ignores rm -rf text inside quoted literals and comments", () => {
+  const readOnlyCommands = [
+    'grep -rn "rm -rf" .',
+    'echo "rm -rf /tmp/x"',
+    'git commit -m "remove stray rm -rf usage"',
+    "cat notes.md  # remove stray rm -rf usage",
+    'printf "rm -rf /tmp/x\\n"',
+  ];
+
+  for (const command of readOnlyCommands) {
+    assert.deepEqual(classifyCommand(command), { destructive: false, labels: [] }, command);
+  }
+});
+
+test("destructive guard still detects direct and wrapper-prefixed recursive deletes", () => {
+  const destructiveCommands = [
+    "rm -rf build",
+    "rm build -rf",
+    "sudo rm -rf /",
+    "doas rm -rf /",
+    "sudo -u bob rm -rf /x",
+    "timeout 5 rm -rf /x",
+    "time rm -rf build",
+    "find . -exec rm -rf {} \\;",
+    "cat doomed.txt | xargs rm -rf /tmp/x",
+    'rm -rf "/tmp/my build"',
+  ];
+
+  for (const command of destructiveCommands) {
+    assert.deepEqual(classifyCommand(command), {
+      destructive: true,
+      labels: ["recursive delete"],
+    }, command);
+  }
+});
+
+test("destructive guard treats quoted interpreter payloads as literals", () => {
+  assert.deepEqual(classifyCommand('bash -c "rm -rf /"'), { destructive: false, labels: [] });
+});

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -96,6 +96,40 @@ function scaffoldMilestoneContext(basePath: string, mid: string): void {
   ].join("\n"));
 }
 
+function scaffoldLegacyMilestoneContext(basePath: string, mid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), [
+    `# ${mid}: Test Milestone`,
+    "",
+    "Context for legacy dispatch recovery tests.",
+    "",
+  ].join("\n"));
+}
+
+function scaffoldLegacySlicePlan(basePath: string, mid: string, sid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(join(dir, "tasks"), { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), [
+    `# ${sid}: Legacy Slice`,
+    "",
+    "## Tasks",
+    "- T01: Do something",
+    "",
+  ].join("\n"));
+}
+
+function scaffoldLegacyTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${tid}-PLAN.md`), [
+    `# ${tid}: First Task`,
+    "",
+    "Implement the task.",
+    "",
+  ].join("\n"));
+}
+
 function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
   // Flat-phase: no per-task plan files. This is a no-op — tasks live as
   // checkboxes inside the slice plan. Kept for backward-compat with tests
@@ -167,6 +201,115 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
     `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: missing legacy task plan recovery increments a per-slice retry counter", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-retry-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>(),
+  };
+  const result = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
+    `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
+    `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.get("M002/S03"), 1);
+});
+
+test("dispatch: missing legacy task plan recovery stops when retry counter is exhausted", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-stop-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>([["M002/S03", 2]]),
+  };
+  const result = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "error");
+  assert.match(result.reason, /Missing task-plan recovery failed 2 times for M002\/S03/);
+  assert.match(result.reason, /manual intervention required/);
+  assert.equal(session.missingTaskPlanRetryCount.has("M002/S03"), false);
+});
+
+test("dispatch: present legacy task plan clears missing-plan recovery retry counter", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-clear-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+  scaffoldLegacyTaskPlan(tmp, "M002", "S03", "T01");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>([["M002/S03", 1]]),
+    preExecRetryCount: new Map<string, number>([["M002/S03", 2]]),
+  };
+  const result = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.has("M002/S03"), false);
+  assert.equal(session.preExecRetryCount.get("M002/S03"), 2,
+    "pre-exec retry counter must not be cleared when task plan is present");
+});
+
+test("dispatch: missing-task-plan recovery loop terminates even when the shared pre-exec key is reset between rounds (#1087)", async (t) => {
+  // The recovery rule re-dispatches plan-slice with unitId "${mid}/${sid}".
+  // That regenerated plan-slice carries the same currentUnit.id, and on a
+  // pre-execution pass the post-unit hook deletes that key from
+  // preExecRetryCount (auto-post-unit.ts). Missing per-task PLAN projection
+  // files do not fail pre-exec checks, so the regenerated plan-slice typically
+  // passes and that delete fires every cycle. If recovery shared
+  // preExecRetryCount, its counter would be wiped to 0 each round and the loop
+  // would never reach the cap. Here we simulate that reset between rounds and
+  // assert the dedicated counter still climbs to MAX and stops.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-loop-term-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>(),
+    preExecRetryCount: new Map<string, number>(),
+  };
+
+  // Round 1: missing task plan → recover (counter 0 → 1).
+  const r1 = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+  assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice",
+    `round 1 should re-dispatch plan-slice, got: ${r1.action === "dispatch" ? r1.unitType : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.get("M002/S03"), 1);
+
+  // The regenerated plan-slice passes its post-unit pre-exec check, deleting
+  // the shared "${mid}/${sid}" key from preExecRetryCount.
+  session.preExecRetryCount.delete("M002/S03");
+
+  // Round 2: still missing → recover (counter 1 → 2), unaffected by the reset.
+  const r2 = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+  assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
+    `round 2 should re-dispatch plan-slice, got: ${r2.action === "dispatch" ? r2.unitType : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.get("M002/S03"), 2);
+
+  session.preExecRetryCount.delete("M002/S03");
+
+  // Round 3: cap reached → stop. The loop terminates despite the resets.
+  const r3 = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+  assert.equal(r3.action, "stop");
+  assert.ok(r3.action === "stop" && r3.level === "error");
+  assert.match(r3.reason, /Missing task-plan recovery failed 2 times for M002\/S03/);
+  assert.equal(session.missingTaskPlanRetryCount.has("M002/S03"), false);
+});
+
 test("dispatch: session milestone mismatch stops before missing-task-plan recovery", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-session-milestone-mismatch-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -1014,6 +1014,143 @@ test("runProviderChecks detects claude.exe in PATH on Windows (#4548)", { skip:
   });
 });
 
+
+test("runProviderChecks reports error for required cursor-agent when binary is missing", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: composer-2.5",
+      "    provider: cursor-agent",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-home-")));
+
+  withEnv({
+    HOME: tmpHome,
+    PATH: tmpHome,
+    CURSOR_API_KEY: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const cursor = results.find(r => r.name === "cursor-agent");
+      assert.ok(cursor, "cursor-agent result should exist");
+      assert.equal(cursor!.status, "error", "cursor-agent should error when the CLI binary is missing");
+      assert.ok(cursor!.detail?.includes("Cursor Agent"), "should explain Cursor Agent must be installed");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks does not route OpenAI via unauthenticated cursor-agent binary in PATH", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-route-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: gpt-5.5",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-route-home-")));
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const fakeCursor = join(binDir, "cursor-agent");
+  writeFileSync(fakeCursor, [
+    "#!/bin/sh",
+    "if [ \"$1\" = \"status\" ]; then echo \"Not logged in\"; exit 0; fi",
+    "echo mock",
+    "",
+  ].join("\n"));
+  chmodSync(fakeCursor, 0o755);
+
+  withEnv({
+    HOME: tmpHome,
+    OPENAI_API_KEY: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ""}`,
+  }, () => {
+    try {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const openai = results.find(r => r.name === "openai");
+        assert.ok(openai, "openai result should exist");
+        assert.equal(openai!.status, "error", "binary-only cursor-agent must not satisfy OpenAI routing");
+        assert.ok(openai!.detail?.includes("OPENAI_API_KEY"), "should still tell the user how to configure OpenAI");
+      });
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks routes OpenAI via authenticated cursor-agent CLI", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-auth-route-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: gpt-5.5",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-auth-route-home-")));
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const fakeCursor = join(binDir, "cursor-agent");
+  writeFileSync(fakeCursor, [
+    "#!/bin/sh",
+    "if [ \"$1\" = \"--version\" ]; then echo cursor-agent 1.0; exit 0; fi",
+    "if [ \"$1\" = \"status\" ]; then echo \"Authenticated as user@example.com\"; exit 0; fi",
+    "echo mock",
+    "",
+  ].join("\n"));
+  chmodSync(fakeCursor, 0o755);
+
+  withEnv({
+    HOME: tmpHome,
+    OPENAI_API_KEY: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    CURSOR_API_KEY: undefined,
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ""}`,
+  }, () => {
+    try {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const openai = results.find(r => r.name === "openai");
+        assert.ok(openai, "openai result should exist");
+        assert.equal(openai!.status, "ok", "authenticated cursor-agent should satisfy OpenAI routing");
+        assert.ok(openai!.message.toLowerCase().includes("cursor"), "should mention cursor-agent as source");
+      });
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
 test("PROVIDER_ROUTES includes google-antigravity and google-gemini-cli as routes for google (#2922)", async () => {
   const { readFileSync: readFS } = await import("node:fs");
   const { dirname: dirn, join: joinPath } = await import("node:path");
@@ -1022,7 +1159,7 @@ test("PROVIDER_ROUTES includes google-antigravity and google-gemini-cli as route
   const src = readFS(joinPath(__dir, "..", "doctor-providers.ts"), "utf-8");
 
   assert.ok(
-    src.includes('google: ["google-antigravity", "google-gemini-cli"]'),
+    src.includes('google: ["google-antigravity", "google-gemini-cli", "cursor-agent"]'),
     'PROVIDER_ROUTES must prefer "google-antigravity" over "google-gemini-cli" for google (#2922)',
   );
 });