gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -2,10 +2,10 @@
 // File Purpose: Git service integration and commit-message tests.
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 
 import {
   inferCommitType,
@@ -371,6 +371,18 @@ describe('git-service', async () => {
     return dir;
   }
 
+  function gitRun(args: string[], cwd: string): string {
+    return execFileSync("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        GIT_ALLOW_PROTOCOL: "file",
+      },
+    }).trim();
+  }
+
   // ─── GitServiceImpl: smart staging ─────────────────────────────────────
 
   test('GitServiceImpl: smart staging', () => {
@@ -413,6 +425,96 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: task autoCommit skips keyFiles inside submodules', () => {
+    const repo = initTempRepo();
+    const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-submodule-src-"));
+
+    try {
+      gitRun(["init", "-b", "main"], subSrc);
+      gitRun(["config", "user.name", "Pi Test"], subSrc);
+      gitRun(["config", "user.email", "pi@example.com"], subSrc);
+      createFile(subSrc, "tracked.txt", "initial\n");
+      gitRun(["add", "-A"], subSrc);
+      gitRun(["commit", "-m", "init submodule"], subSrc);
+
+      gitRun(["-c", "protocol.file.allow=always", "submodule", "add", `file://${subSrc}`, "sub"], repo);
+      gitRun(["commit", "-m", "add submodule"], repo);
+
+      createFile(repo, "sub/copied.txt", "copied from source\n");
+      createFile(repo, "src/feature.ts", "export const feature = true;\n");
+      createFile(repo, "src/unrelated.ts", "export const unrelated = true;\n");
+
+      const svc = new GitServiceImpl(repo);
+      const taskContext: TaskCommitContext = {
+        taskId: "S01/T01",
+        taskDisplayId: "T01",
+        taskTitle: "fix submodule staging",
+        milestoneId: "M001",
+        milestoneTitle: "Submodule auto commit",
+        sliceId: "S01",
+        sliceTitle: "Commit scoped files",
+        oneLiner: "Fixed auto commit when key files include submodule paths",
+        keyFiles: ["sub/copied.txt", "src/feature.ts"],
+      };
+
+      const result = svc.autoCommit("execute-task", "M001/S01/T01", [], taskContext);
+
+      assert.ok(result !== null, "autoCommit should commit non-submodule changes");
+      const committed = gitRun(["show", "--name-only", "--format=", "HEAD"], repo);
+      assert.ok(committed.includes("src/feature.ts"), "non-submodule keyFile is committed");
+      assert.ok(!committed.includes("sub/copied.txt"), "submodule inner keyFile is not pathspec-staged");
+      assert.ok(!committed.includes("src/unrelated.ts"), "scoped staging does not fall back to smartStage");
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(subSrc, { recursive: true, force: true });
+    }
+  });
+
+  test('GitServiceImpl: all keyFiles inside submodules falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-all-submodule-src-"));
+
+    try {
+      gitRun(["init", "-b", "main"], subSrc);
+      gitRun(["config", "user.name", "Pi Test"], subSrc);
+      gitRun(["config", "user.email", "pi@example.com"], subSrc);
+      createFile(subSrc, "tracked.txt", "initial\n");
+      gitRun(["add", "-A"], subSrc);
+      gitRun(["commit", "-m", "init submodule"], subSrc);
+
+      gitRun(["-c", "protocol.file.allow=always", "submodule", "add", `file://${subSrc}`, "sub"], repo);
+      gitRun(["commit", "-m", "add submodule"], repo);
+
+      createFile(repo, "sub/file1.txt", "inside submodule\n");
+      createFile(repo, "sub/file2.txt", "also inside\n");
+      createFile(repo, "src/real.ts", "export const real = true;\n");
+
+      const svc = new GitServiceImpl(repo);
+      const taskContext: TaskCommitContext = {
+        taskId: "S01/T02",
+        taskDisplayId: "T02",
+        taskTitle: "all keyFiles inside submodule",
+        milestoneId: "M001",
+        milestoneTitle: "Submodule auto commit",
+        sliceId: "S01",
+        sliceTitle: "Commit scoped files",
+        oneLiner: "Fell back when all key files are inside submodules",
+        keyFiles: ["sub", "sub/file1.txt", "sub/file2.txt"],
+      };
+
+      const result = svc.autoCommit("execute-task", "M001/S01/T02", [], taskContext);
+
+      assert.ok(result !== null, "autoCommit falls back to smartStage when all keyFiles are filtered");
+      const committed = gitRun(["show", "--name-only", "--format=", "HEAD"], repo);
+      assert.ok(!committed.includes("sub/file1.txt"), "submodule keyFile is not committed");
+      assert.ok(!committed.includes("sub/file2.txt"), "submodule keyFile is not committed");
+      assert.ok(committed.includes("src/real.ts"), "smartStage fallback commits other dirty files");
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(subSrc, { recursive: true, force: true });
+    }
+  });
+
   // ─── GitServiceImpl: smart staging excludes tracked runtime files ──────
 
   test('GitServiceImpl: smart staging excludes tracked runtime files', () => {
@@ -529,6 +631,92 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: autoCommit retries once when pre-commit rewrites files', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    const hookPath = join(repo, ".git", "hooks", "pre-commit");
+    const countFile = join(repo, ".git", "pre-commit-count");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        `count_file="${countFile}"`,
+        "count=0",
+        "[ -f \"$count_file\" ] && count=$(cat \"$count_file\")",
+        "count=$((count + 1))",
+        "echo \"$count\" > \"$count_file\"",
+        "if [ \"$count\" -eq 1 ]; then",
+        "  printf 'export const fixed = true;\\n' > src/fix-me.ts",
+        "  exit 1",
+        "fi",
+        "exit 0",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    chmodSync(hookPath, 0o755);
+
+    createFile(repo, "src/fix-me.ts", "export const fixed = false;\n");
+    const msg = svc.autoCommit("execute-task", "M001/S01/T04");
+
+    assert.ok(msg !== null, "autoCommit succeeds after one retry for hook rewrites");
+    assert.equal(run("git rev-list --count HEAD", repo), "2", "exactly one new commit created");
+    assert.equal(readFileSync(join(repo, "src/fix-me.ts"), "utf-8"), "export const fixed = true;\n"); // allow-source-grep: verifies pre-commit output inside the temp repo fixture, not product source.
+    assert.equal(readFileSync(countFile, "utf-8").trim(), "2", "pre-commit hook ran twice");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test('GitServiceImpl: autoCommit retry preserves task-scoped staging', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    const hookPath = join(repo, ".git", "hooks", "pre-commit");
+    const countFile = join(repo, ".git", "pre-commit-count");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        `count_file="${countFile}"`,
+        "count=0",
+        "[ -f \"$count_file\" ] && count=$(cat \"$count_file\")",
+        "count=$((count + 1))",
+        "echo \"$count\" > \"$count_file\"",
+        "if [ \"$count\" -eq 1 ]; then",
+        "  printf 'export const fixed = true;\\n' > src/task.ts",
+        "  exit 1",
+        "fi",
+        "exit 0",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    chmodSync(hookPath, 0o755);
+
+    createFile(repo, "src/task.ts", "export const fixed = false;\n");
+    createFile(repo, "src/unrelated.ts", "export const unrelated = true;\n");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T05", [], {
+      taskId: "S01/T05",
+      taskTitle: "update task file",
+      oneLiner: "Updated task file after hook rewrite",
+      keyFiles: ["src/task.ts"],
+    });
+
+    assert.ok(msg !== null, "autoCommit succeeds after retry with task-scoped staging");
+    assert.equal(readFileSync(countFile, "utf-8").trim(), "2", "pre-commit hook ran twice");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/task.ts"), "task file is committed after retry");
+    assert.ok(!committed.includes("src/unrelated.ts"), "retry does not widen staging to unrelated dirty files");
+
+    const status = run("git status --porcelain", repo);
+    assert.ok(status.includes("src/unrelated.ts"), "unrelated dirty file remains in working tree");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   test('GitServiceImpl: task context keyFiles scope autoCommit staging', () => {
     const repo = initTempRepo();
     const svc = new GitServiceImpl(repo);
@@ -608,6 +796,33 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // Regression: #5529. Some executors emit keyFiles relative to a monorepo
+  // subproject root (e.g. `src/...`) instead of the repo root
+  // (`frontend/src/...`). When none of those keyFiles exist at repo root,
+  // scoped staging must fall back to smartStage instead of failing the turn.
+  test('GitServiceImpl: repo-relative keyFiles mismatch falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "frontend/src/lib/onboarding-contract.ts", "export const contract = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T04", [], {
+      taskId: "S01/T04",
+      taskTitle: "fix scoped keyFiles path handling",
+      oneLiner: "Handled repo-relative keyFiles mismatch",
+      keyFiles: ["src/lib/onboarding-contract.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit falls back to smartStage when scoped keyFiles are invalid at repo root");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(
+      committed.includes("frontend/src/lib/onboarding-contract.ts"),
+      "smartStage fallback stages real dirty files when keyFiles are scoped to a subproject root",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   test('GitServiceImpl: task context keyFiles ignores gitignored build outputs', () => {
     const repo = initTempRepo();
     const svc = new GitServiceImpl(repo);
@@ -1066,6 +1281,15 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: rejects milestone branches', () => {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "milestone/M001");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "milestone branches are not recorded as integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: still records legitimate branches ────────
 
   test('Integration branch: records non-ephemeral gsd branches', () => {

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -883,7 +883,7 @@ describe("dispatch failure modes", () => {
     assert.ok(runUatIdx < uatGateIdx, "run-uat should precede uat-verdict-gate");
   });
 
-  test("UAT verdict gate: ASSESSMENT FAIL blocks closed slice progression", async () => {
+  test("UAT verdict gate: ASSESSMENT FAIL does not hard-stop progression", async () => {
     base = createFullFixture();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -908,11 +908,7 @@ describe("dispatch failure modes", () => {
     ctx.prefs = { uat_dispatch: true } as any;
 
     const result = await getUatVerdictGate().match(ctx);
-    assert.equal(result?.action, "stop", "ASSESSMENT FAIL should block progression");
-    assert.ok(
-      (result as any).reason?.includes('UAT verdict for S01 is "fail"'),
-      "stop reason should report normalized ASSESSMENT verdict",
-    );
+    assert.equal(result, null, "ASSESSMENT FAIL should not hard-stop progression");
   });
 
   test("UAT verdict gate: ROADMAP fallback gates done slices when DB is unavailable", async () => {
@@ -964,15 +960,11 @@ describe("dispatch failure modes", () => {
     ctx.prefs = { uat_dispatch: true } as any;
 
     const result = await getUatVerdictGate().match(ctx);
-    assert.equal(result?.action, "stop", "ROADMAP done slices should be gated without DB");
-    assert.ok(
-      (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
-      "stop reason should report normalized ASSESSMENT verdict from disk fallback",
-    );
+    assert.equal(result, null, "ROADMAP done slices should not hard-stop progression without DB");
   });
 
   for (const status of ["done", "skipped"]) {
-    test(`UAT verdict gate: legacy closed status "${status}" is gated`, async () => {
+    test(`UAT verdict gate: legacy closed status "${status}" does not hard-stop progression`, async () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -997,15 +989,7 @@ describe("dispatch failure modes", () => {
       ctx.prefs = { uat_dispatch: true } as any;
 
       const result = await getUatVerdictGate().match(ctx);
-      assert.equal(
-        result?.action,
-        "stop",
-        `${status} slices should be treated as closed for UAT verdict gating`,
-      );
-      assert.ok(
-        (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
-        "stop reason should report normalized ASSESSMENT verdict",
-      );
+      assert.equal(result, null, `${status} slices should not hard-stop progression`);
     });
   }
 });

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -31,6 +31,7 @@ import {
   openDatabase,
   closeDatabase,
   insertMilestone,
+  insertAssessment,
   insertSlice,
   insertTask,
   getTask,
@@ -280,6 +281,16 @@ function makeMilestoneParams(milestoneId: string): Record<string, unknown> {
   };
 }
 
+function insertPassingMilestoneValidation(milestoneId: string): void {
+  insertAssessment({
+    path: `.gsd/milestones/${milestoneId}/${milestoneId}-VALIDATION.md`,
+    milestoneId,
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "# Validation\n\nverdict: PASS",
+  });
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Suite
 // ═══════════════════════════════════════════════════════════════════════════
@@ -424,6 +435,7 @@ describe("state-machine-live-validation", () => {
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Impl", status: "complete" });
       insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Test", status: "complete" });
       insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Impl", status: "complete" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok(!("error" in result), `expected success, got: ${JSON.stringify(result)}`);
@@ -528,6 +540,7 @@ describe("state-machine-live-validation", () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);
@@ -542,6 +555,7 @@ describe("state-machine-live-validation", () => {
       insertSlice({ id: "S02", milestoneId: "M001", status: "in_progress" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "complete" });
       insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", status: "pending" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);
@@ -555,6 +569,7 @@ describe("state-machine-live-validation", () => {
       // Slice marked complete but task is still pending — simulates inconsistent state
       insertSlice({ id: "S01", milestoneId: "M001", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "pending" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -195,6 +195,11 @@ describe("infrastructure error detection", () => {
     assert.equal(isInfrastructureError(err), "EAGAIN");
   });
 
+  test("ENOBUFS (no buffer space available) is detected", () => {
+    const err = Object.assign(new Error("spawnSync git ENOBUFS"), { code: "ENOBUFS" });
+    assert.equal(isInfrastructureError(err), "ENOBUFS");
+  });
+
   test("SQLite WAL corruption is detected via message scan", () => {
     const err = new Error("database disk image is malformed");
     assert.equal(isInfrastructureError(err), "SQLITE_CORRUPT");
@@ -223,7 +228,7 @@ describe("infrastructure error detection", () => {
   test("all INFRA_ERROR_CODES are covered", () => {
     const expectedCodes = [
       "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE",
-      "ENFILE", "EAGAIN", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+      "ENFILE", "EAGAIN", "ENOBUFS", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
     ];
     for (const code of expectedCodes) {
       assert.ok(INFRA_ERROR_CODES.has(code), `${code} should be in INFRA_ERROR_CODES`);

package/src/resources/extensions/gsd/tests/interrupted-session-auto.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
+import { _handlePausedSessionResumeRecoveryForTest } from "../auto.ts";
 import { assessInterruptedSession } from "../interrupted-session.ts";
 import {
   openDatabase,
@@ -186,6 +187,45 @@ test("direct /gsd auto source only resumes paused-session metadata for recoverab
   assert.ok(source.includes('|| !!freshStartAssessment.lock'));
 });
 
+test("direct /gsd auto skips paused-session replay when recovered unit already completed", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      [
+        "# S01: Test Slice",
+        "",
+        "## Tasks",
+        "",
+        "- [ ] **T01: First task** `est:1h`",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.\n", "utf-8");
+
+    const state = {
+      pausedSessionFile: join(base, ".gsd", "activity", "paused-session.jsonl"),
+      currentUnit: null,
+      pausedUnitType: "plan-slice",
+      pausedUnitId: "M001/S01",
+      pendingCrashRecovery: "stale-recovery-prompt",
+    };
+
+    const result = _handlePausedSessionResumeRecoveryForTest(base, state);
+    assert.equal(result.skippedReplay, true);
+    assert.equal(state.pausedSessionFile, null);
+    assert.equal(state.pendingCrashRecovery, null);
+    assert.equal(state.pausedUnitType, null);
+    assert.equal(state.pausedUnitId, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("auto module imports successfully after interrupted-session changes", async () => {
   const mod = await import(`../auto.ts?ts=${Date.now()}-${Math.random()}`);
   assert.equal(typeof mod.startAuto, "function");

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -22,6 +22,7 @@ import type { IterationContext, LoopState, PreDispatchData, IterationData } from
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
+import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
   closeDatabase,
   insertMilestone,
@@ -160,6 +161,8 @@ function makeIC(
     pi: {
       sendMessage: () => {},
       setModel: async () => true,
+      getThinkingLevel: () => "off",
+      setThinkingLevel: () => {},
     } as any,
     s: makeSession(),
     deps,
@@ -633,7 +636,7 @@ test("runDispatch clears execute-task stuck state when artifacts and DB status a
   assert.equal(stopCalls, 0, "closed DB task should not hard-stop the loop");
   assert.equal(invalidateCalls, 1, "closed DB task recovery should invalidate caches once");
   assert.deepEqual(loopState.recentUnits, [], "closed DB task recovery should clear the stuck window");
-  assert.equal(loopState.stuckRecoveryAttempts, 0, "closed DB task recovery should reset the recovery counter");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "closed DB task recovery should preserve the recovery counter");
 });
 
 test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
@@ -700,7 +703,7 @@ test("runDispatch clears stuck state after Level 1 artifact recovery", async (t)
   assert.equal(invalidateCalls, 1, "Level 1 artifact recovery should invalidate caches");
   assert.equal(stopCalls, 0, "Level 1 artifact recovery should not hard-stop");
   assert.deepEqual(loopState.recentUnits, [], "Level 1 artifact recovery should clear the stuck window");
-  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 1 artifact recovery should reset the recovery counter");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 1 artifact recovery should preserve the recovery counter");
 });
 
 test("runDispatch escapes Level 2 stuck stop when artifact verifies after cache invalidation", async (t) => {
@@ -825,7 +828,7 @@ test("runUnitPhase emits unit-start and unit-end with causedBy reference", async
   assert.equal(endEvents[0].flowId, ic.flowId);
   assert.equal((endEvents[0].data as any).unitType, "execute-task");
   assert.equal((endEvents[0].data as any).unitId, "M001/S01/T01");
-  assert.equal((endEvents[0].data as any).status, "completed");
+  assert.equal((endEvents[0].data as any).status, "no-artifact");
 
   // Verify causedBy: unit-end references unit-start's seq
   assert.ok(endEvents[0].causedBy, "unit-end must have a causedBy reference");
@@ -868,6 +871,49 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
   assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01"), 2);
 });
 
+test("runUnitPhase pre-dispatch model validation failures do not emit unit-start or dispatch runtime state", async (t) => {
+  const capture = createEventCapture();
+  const base = mkdtempSync(join(tmpdir(), `gsd-pre-dispatch-block-${randomUUID()}`));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const deps = makeMockDeps(capture, {
+    selectAndApplyModel: async () => {
+      throw new ModelPolicyDispatchBlockedError("execute-task", "M001/S01/T01", []);
+    },
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+    } as any,
+  });
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    prompt: "do stuff",
+    finalPrompt: "do stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+
+  const startEvents = capture.events.filter(e => e.eventType === "unit-start");
+  assert.equal(startEvents.length, 0, "pre-dispatch validation failures must not emit unit-start");
+  assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01") ?? 0, 0, "dispatch count must not increment on pre-dispatch validation failure");
+  assert.equal(
+    readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01"),
+    null,
+    "pre-dispatch validation failures must not persist a dispatched runtime record",
+  );
+});
+
 test("all events from a mock iteration have monotonically increasing seq and same flowId", async () => {
   const capture = createEventCapture();
   const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");

package/src/resources/extensions/gsd/tests/journal.test.ts

@@ -206,6 +206,38 @@ describe("queryJournal", () => {
     assert.ok(results.every(e => e.eventType === "dispatch-match"));
   });
 
+  test("keeps auto-orchestrator events separate from auto-loop events", () => {
+    emitJournalEvent(base, makeEntry({ eventType: "iteration-start", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ eventType: "dispatch-match", seq: 1 }));
+    emitJournalEvent(
+      base,
+      makeEntry({
+        eventType: "orchestrator-iteration-start",
+        seq: 2,
+        data: { source: "auto-orchestrator", name: "start" },
+      }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({
+        eventType: "orchestrator-dispatch-match",
+        seq: 3,
+        data: { source: "auto-orchestrator", name: "advance" },
+      }),
+    );
+
+    const loopMatches = queryJournal(base, { eventType: "dispatch-match" });
+    const orchestratorMatches = queryJournal(base, { eventType: "orchestrator-dispatch-match" });
+
+    assert.equal(loopMatches.length, 1, "loop dispatch telemetry should not include orchestrator advances");
+    assert.equal(orchestratorMatches.length, 1, "forensics needs orchestrator advances under their own type");
+    assert.equal(orchestratorMatches[0].seq, 3);
+    assert.deepEqual(orchestratorMatches[0].data, {
+      source: "auto-orchestrator",
+      name: "advance",
+    });
+  });
+
   test("filters by unitId (from data.unitId)", () => {
     emitJournalEvent(
       base,