gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -18,13 +18,15 @@ import { randomUUID } from "node:crypto";
 import {
   appendFileSync,
   existsSync,
+  lstatSync,
+  rmSync,
   writeFileSync,
   readFileSync,
   mkdirSync,
   renameSync,
   unlinkSync,
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
@@ -105,6 +107,37 @@ export function _buildSliceWorkerEnvForTest(
   };
 }
 
+function isValidSliceWorktreePath(basePath: string, wtPath: string): boolean {
+  if (!existsSync(wtPath)) return false;
+  const gitPath = join(wtPath, ".git");
+  if (!existsSync(gitPath)) return false;
+  try {
+    if (!lstatSync(gitPath).isFile()) return false;
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) return false;
+    const rawGitdir = content.slice("gitdir: ".length).trim();
+    if (!rawGitdir) return false;
+    const resolvedGitdir = isAbsolute(rawGitdir) ? rawGitdir : resolve(wtPath, rawGitdir);
+    const expectedPrefix = join(basePath, ".git", "worktrees").replaceAll("\\", "/");
+    const normalized = resolvedGitdir.replaceAll("\\", "/");
+    return normalized === expectedPrefix || normalized.startsWith(`${expectedPrefix}/`);
+  } catch {
+    return false;
+  }
+}
+
+function isWorkerPidAlive(pid: number): boolean {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException)?.code;
+    if (code === "ESRCH") return false;
+    return true;
+  }
+}
+
 interface PersistedSliceWorker {
   milestoneId: string;
   sliceId: string;
@@ -334,7 +367,24 @@ export function restoreSliceState(basePath: string): PersistedSliceState | null
  * crash followed by a fresh process is detectable. (Issue #4980 HIGH-8)
  */
 export function isSliceParallelActive(basePath?: string): boolean {
-  if (sliceState?.active === true) return true;
+  const hasRunningWorkers = (): boolean => {
+    if (!sliceState) return false;
+    for (const worker of sliceState.workers.values()) {
+      if (worker.state === "running") {
+        if (worker.process) return true;
+        if (isRecoveredSliceWorkerAlive(worker)) return true;
+      }
+    }
+    return false;
+  };
+
+  if (sliceState?.active === true) {
+    if (hasRunningWorkers()) return true;
+    sliceState.active = false;
+    removeSliceStateFile(sliceState.basePath);
+    return false;
+  }
+
   if (!basePath) return false;
   const restored = restoreSliceState(basePath);
   if (!restored || restored.workers.length === 0) return false;
@@ -365,7 +415,11 @@ export function isSliceParallelActive(basePath?: string): boolean {
       cost: w.cost,
     });
   }
-  return true;
+
+  if (hasRunningWorkers()) return true;
+  sliceState.active = false;
+  removeSliceStateFile(sliceState.basePath);
+  return false;
 }
 
 /**
@@ -427,6 +481,9 @@ export async function startSliceParallel(
       const wtName = `${milestoneId}-${slice.id}`;
       const wtPath = worktreePath(basePath, wtName);
 
+      if (existsSync(wtPath) && !isValidSliceWorktreePath(basePath, wtPath)) {
+        rmSync(wtPath, { recursive: true, force: true });
+      }
       if (!existsSync(wtPath)) {
         createWorktree(basePath, wtName, { branch: wtBranch });
       }
@@ -470,6 +527,21 @@ export async function startSliceParallel(
     }
   }
 
+  // Guard: if workers died immediately, treat as failed start so callers
+  // don't exit auto-mode and re-dispatch in a rapid loop.
+  for (let i = started.length - 1; i >= 0; i--) {
+    const sid = started[i];
+    const worker = sliceState.workers.get(sid);
+    if (worker && isWorkerPidAlive(worker.pid)) continue;
+    started.splice(i, 1);
+    errors.push({ sid, error: "Worker exited immediately after spawn" });
+    sliceState.workers.delete(sid);
+    const wtName = `${milestoneId}-${sid}`;
+    try {
+      removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
+    } catch { /* ignore cleanup failures */ }
+  }
+
   // If nothing started, deactivate
   if (started.length === 0) {
     sliceState.active = false;

package/src/resources/extensions/gsd/smart-entry-routing.ts

@@ -0,0 +1,77 @@
+// GSD-2 — Smart entry routing decisions.
+// Pure route selection for /gsd guided wizard choices.
+
+export type SmartEntryIsolationMode = "worktree" | "branch" | "none";
+
+export type ActiveTaskChoice =
+  | "execute"
+  | "auto"
+  | "status"
+  | "milestone_actions";
+
+export type ActiveTaskRoute =
+  | {
+      kind: "auto-bootstrap";
+      verboseMode: false;
+      options?: {
+        step?: true;
+        milestoneLock?: string;
+      };
+    }
+  | {
+      kind: "guided-dispatch";
+      unitType: "execute-task";
+    }
+  | {
+      kind: "status";
+    }
+  | {
+      kind: "milestone-actions";
+    };
+
+export function resolveGuidedExecuteLaunchMode(
+  isolationMode: SmartEntryIsolationMode,
+): "auto-step" | "guided-dispatch" {
+  return isolationMode === "worktree" ? "auto-step" : "guided-dispatch";
+}
+
+export function resolveActiveTaskChoiceRoute(input: {
+  choice: ActiveTaskChoice;
+  isolationMode: SmartEntryIsolationMode;
+  milestoneId: string;
+}): ActiveTaskRoute {
+  if (input.choice === "auto") {
+    return {
+      kind: "auto-bootstrap",
+      verboseMode: false,
+    };
+  }
+
+  if (input.choice === "execute") {
+    if (resolveGuidedExecuteLaunchMode(input.isolationMode) === "auto-step") {
+      return {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+        options: {
+          step: true,
+          milestoneLock: input.milestoneId,
+        },
+      };
+    }
+
+    return {
+      kind: "guided-dispatch",
+      unitType: "execute-task",
+    };
+  }
+
+  if (input.choice === "status") {
+    return { kind: "status" };
+  }
+
+  if (input.choice === "milestone_actions") {
+    return { kind: "milestone-actions" };
+  }
+
+  throw new Error(`Invalid ActiveTaskChoice: ${input.choice}`);
+}

package/src/resources/extensions/gsd/state-reconciliation/drift/merge-state.ts

@@ -23,6 +23,7 @@ import {
 } from "../../native-git-bridge.js";
 import type { GSDState } from "../../types.js";
 import { logError, logWarning } from "../../workflow-logger.js";
+import { isGsdWorktreePath } from "../../worktree-root.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
 export type MergeReconcileResult = "clean" | "reconciled" | "blocked";
@@ -46,7 +47,13 @@ function resolveGitDir(basePath: string): string {
       return isAbsolute(gitDir) ? gitDir : resolve(basePath, gitDir);
     }
   } catch (err) {
-    logWarning("recovery", `gitdir resolution failed: ${getErrorMessage(err)}`);
+    const message = getErrorMessage(err);
+    logWarning("recovery", `gitdir resolution failed: ${message}`);
+    if (isGsdWorktreePath(basePath)) {
+      throw new Error(
+        `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${message.split("\n")[0]}). Repair or recreate the worktree before retrying.`,
+      );
+    }
   }
 
   return join(basePath, ".git");

package/src/resources/extensions/gsd/state-reconciliation/drift/project-md.ts

@@ -1,14 +1,13 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 unregistered-milestone drift handler. Detects
 // milestones whose on-disk directory has meaningful content (ROADMAP/
-// CONTEXT/SUMMARY) but no DB row, then runs the markdown importer to
-// reconcile. PROJECT.md is the human-facing index — the importer's source
-// of truth is the .gsd/milestones/ directory tree.
+// CONTEXT/SUMMARY) but no DB row, then fails closed with an explicit recovery
+// instruction. Markdown hierarchy import is reserved for operator-controlled
+// migration/recovery commands, not automatic runtime reconciliation.
 
 import { existsSync } from "node:fs";
 
 import { getMilestone, isDbAvailable } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { resolveMilestoneFile } from "../../paths.js";
 import type { GSDState } from "../../types.js";
@@ -46,20 +45,18 @@ export function detectUnregisteredMilestoneDrift(
 }
 
 /**
- * Repair: invoke the markdown importer. migrateHierarchyToDb walks the same
- * findMilestoneIds list the detector uses and INSERTs OR IGNOREs every
- * missing milestone (and its slices/tasks) — idempotent under cap=2 retry.
- *
- * Note: even though we receive one record at a time, the importer is a
- * project-wide operation. Repeated invocation across multiple drift records
- * in the same pass is wasteful but safe; a future optimization could
- * coalesce by checking whether the importer has already run this pass.
+ * Repair intentionally fails closed. The project-root DB is authoritative at
+ * runtime; markdown-only milestones must be imported through an explicit
+ * migration/recovery command so operators opt into changing canonical state.
  */
 export function repairUnregisteredMilestone(
-  _record: UnregisteredMilestoneDrift,
-  ctx: DriftContext,
+  record: UnregisteredMilestoneDrift,
+  _ctx: DriftContext,
 ): void {
-  migrateHierarchyToDb(ctx.basePath);
+  throw new Error(
+    `Milestone ${record.milestoneId} exists only as markdown projection. ` +
+      "Runtime reconciliation will not import markdown into the authoritative DB; run explicit GSD recovery/migration if this markdown should repopulate the database.",
+  );
 }
 
 export const unregisteredMilestoneHandler: DriftHandler<UnregisteredMilestoneDrift> = {

package/src/resources/extensions/gsd/state-reconciliation/drift/roadmap.ts

@@ -1,8 +1,8 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 roadmap-divergence drift handler. Detects mismatches
-// between ROADMAP.md (parsed slice sequence + depends declarations) and the
-// DB slice rows for that milestone, then reconciles via the markdown
-// importer plus an explicit junction-table sync.
+// between ROADMAP.md (parsed slice sequence, depends declarations, and
+// checkboxes) and the DB slice rows for that milestone, then re-renders the
+// ROADMAP projection from the authoritative DB rows.
 
 import { existsSync, readFileSync } from "node:fs";
 
@@ -10,12 +10,12 @@ import {
   getMilestone,
   getMilestoneSlices,
   isDbAvailable,
-  syncSliceDependencies,
 } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
+import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
+import { isClosedStatus } from "../../status-guards.js";
 import type { GSDState } from "../../types.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
@@ -46,14 +46,20 @@ function milestoneHasDivergence(
 
   const dbSlices = getMilestoneSlices(milestoneId);
   const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+  const roadmapSliceIds = new Set<string>();
 
   for (let i = 0; i < roadmap.slices.length; i++) {
     const roadmapSlice = roadmap.slices[i]!;
+    roadmapSliceIds.add(roadmapSlice.id);
     const expectedSequence = i + 1;
     const dbSlice = dbSliceMap.get(roadmapSlice.id);
     if (!dbSlice) return true; // Roadmap has a slice the DB doesn't.
     if (dbSlice.sequence !== expectedSequence) return true;
     if (!arraysEqual(dbSlice.depends, roadmapSlice.depends)) return true;
+    if (isClosedStatus(dbSlice.status) !== roadmapSlice.done) return true;
+  }
+  for (const dbSlice of dbSlices) {
+    if (!roadmapSliceIds.has(dbSlice.id)) return true;
   }
   return false;
 }
@@ -77,29 +83,15 @@ export function detectRoadmapDivergenceDrift(
 }
 
 /**
- * Repair a milestone's roadmap divergence:
- *   1. migrateHierarchyToDb upserts slice rows (sequence + depends JSON
- *      update via ON CONFLICT DO UPDATE).
- *   2. syncSliceDependencies updates the junction table per slice — the
- *      importer only writes the JSON column, not the relational view.
+ * Repair a milestone's roadmap divergence by regenerating the projection from
+ * DB rows. ROADMAP.md is a projection; runtime reconciliation must not import
+ * slice presence, sequence, dependencies, or checkbox state from markdown.
  */
-export function repairRoadmapDivergence(
+export async function repairRoadmapDivergence(
   record: RoadmapDivergenceDrift,
   ctx: DriftContext,
-): void {
-  migrateHierarchyToDb(ctx.basePath);
-
-  const roadmapPath = resolveMilestoneFile(ctx.basePath, record.milestoneId, "ROADMAP");
-  if (!roadmapPath || !existsSync(roadmapPath)) return;
-
-  try {
-    const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
-    for (const slice of roadmap.slices) {
-      syncSliceDependencies(record.milestoneId, slice.id, slice.depends);
-    }
-  } catch {
-    /* parse failure: detector will fire again next pass */
-  }
+): Promise<void> {
+  await renderRoadmapFromDb(ctx.basePath, record.milestoneId);
 }
 
 export const roadmapDivergenceHandler: DriftHandler<RoadmapDivergenceDrift> = {

package/src/resources/extensions/gsd/state.ts

@@ -40,6 +40,7 @@ import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
 import { isClosedStatus, isDeferredStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
+import { autoHealSketchFlags } from './state-reconciliation/drift/sketch-flag.js';
 
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
@@ -324,7 +325,7 @@ export async function deriveState(
   // from ROADMAP.md, PLAN.md, SUMMARY.md, REQUIREMENTS.md, or flag files.
   if (isDbAvailable()) {
     const stopDbTimer = debugTime("derive-state-db");
-    result = await deriveStateFromDb(basePath);
+    result = await deriveStateFromDb(basePath, opts?.projectRootForReads ?? basePath);
     stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
     _telemetry.dbDeriveCount++;
   } else if (process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK === "1") {
@@ -463,6 +464,13 @@ async function buildRegistryAndFindActive(
       }
 
       if (allSlicesDone) {
+        const validation = getLatestAssessmentByScope(m.id, "milestone-validation");
+        const verdict = typeof validation?.status === "string" ? validation.status : undefined;
+        if (verdict === "needs-attention") {
+          registry.push({ id: m.id, title, status: "parked", ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+          continue;
+        }
+
         activeMilestone = { id: m.id, title };
         activeMilestoneSlices = slices;
         activeMilestoneFound = true;
@@ -591,7 +599,7 @@ async function handleAllSlicesDone(
       recentDecisions: [],
       blockers: [
         `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-          `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+          `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
       ],
       nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
       registry, requirements,
@@ -651,7 +659,10 @@ function checkReplanTrigger(basePath: string, milestoneId: string, sliceId: stri
   return !!sliceRow?.replan_triggered_at;
 }
 
-export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
+export async function deriveStateFromDb(
+  basePath: string,
+  artifactReadRoot: string = basePath,
+): Promise<GSDState> {
   const requirements = getRequirementCounts();
 
   const allMilestones = getAllMilestones();
@@ -729,7 +740,18 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       progress: { milestones: milestoneProgress, slices: sliceProgress },
     };
   }
-  const { activeSlice, activeSliceRow } = activeSliceContext;
+  const { activeSlice } = activeSliceContext;
+  let activeSliceRow = activeSliceContext.activeSliceRow;
+
+  // Heal stale sketch flags before honoring the DB-authoritative sketch gate.
+  // This recovers if PLAN.md exists but is_sketch was never flipped to 0.
+  if (activeMilestone?.id) {
+    autoHealSketchFlags(activeMilestone.id, (sid) => {
+      const planPath = resolveSliceFile(artifactReadRoot, activeMilestone.id, sid, "PLAN");
+      return planPath !== null && existsSync(planPath);
+    });
+    activeSliceRow = getSlice(activeMilestone.id, activeSlice.id);
+  }
 
   // ADR-011: DB slice metadata is authoritative for sketch refinement.
   // PLAN.md and preference flags are projections/configuration and are
@@ -1074,6 +1096,10 @@ export async function _deriveStateImpl(
       const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
       const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
       const verdict = validationContent ? extractVerdict(validationContent) : undefined;
+      if (verdict === "needs-attention") {
+        registry.push({ id: mid, title, status: "parked" });
+        continue;
+      }
       // needs-remediation is terminal but requires re-validation (#3596)
       const needsRevalidation = !validationTerminal || verdict === 'needs-remediation';
 
@@ -1091,7 +1117,7 @@ export async function _deriveStateImpl(
         // Needs (re-)validation, but another milestone is already active
         registry.push({ id: mid, title, status: 'pending' });
       } else if (!activeMilestoneFound) {
-        // Terminal validation (pass/needs-attention) but no summary → completing-milestone
+        // Terminal passing validation but no summary → completing-milestone
         activeMilestone = { id: mid, title };
         activeRoadmap = roadmap;
         activeMilestoneFound = true;
@@ -1314,7 +1340,7 @@ export async function _deriveStateImpl(
         recentDecisions: [],
         blockers: [
           `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-            `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+            `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
         ],
         nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
         registry,
@@ -1441,7 +1467,7 @@ export async function _deriveStateImpl(
     const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
     if (summaryPath && existsSync(summaryPath)) {
       t.done = true;
-      logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
+      logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
     }
   }
 

package/src/resources/extensions/gsd/status-guards.ts

@@ -2,7 +2,8 @@
  * Status predicates for GSD state-machine guards.
  *
  * The DB stores status as free-form strings. Three values indicate
- * "closed": "complete" (canonical), "done" (legacy / alias), and
+ * "closed": "complete" (canonical), "done" (legacy / alias),
+ * "closed" (legacy/imported), and
  * "skipped" (user-directed skip via rethink or backtrack).
  * Every inline `status === "complete" || status === "done"` should
  * use isClosedStatus() instead.
@@ -10,7 +11,7 @@
 
 /** Returns true when a milestone, slice, or task status indicates closure. */
 export function isClosedStatus(status: string): boolean {
-  return status === "complete" || status === "done" || status === "skipped";
+  return status === "complete" || status === "done" || status === "skipped" || status === "closed";
 }
 
 /** Returns true when a slice status indicates it was deferred by a decision. */
@@ -25,3 +26,16 @@ export function isDeferredStatus(status: string): boolean {
 export function isInactiveStatus(status: string): boolean {
   return isClosedStatus(status) || isDeferredStatus(status);
 }
+
+/** Returns true when a prior milestone should not block dispatch ordering. */
+export function isSkippedForDispatch(status: string): boolean {
+  return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
+}
+
+/**
+ * Returns true when a milestone is future/backlog work (not currently executing).
+ * Includes legacy/project-specific alias "planned" for compatibility.
+ */
+export function isFutureMilestoneStatus(status: string): boolean {
+  return status === "pending" || status === "queued" || status === "planned";
+}

package/src/resources/extensions/gsd/templates/PREFERENCES.md

@@ -69,6 +69,7 @@ parallel:
 verification_commands: []
 verification_auto_fix:
 verification_max_retries:
+per_unit_cost_cap_usd:
 notifications:
   enabled:
   on_complete:

package/src/resources/extensions/gsd/templates/plan.md

@@ -99,11 +99,11 @@
   - "Improve UI"
 
   Each task should usually include:
-  - Why: why this task exists / what part of the slice it closes
-  - Files: the main files likely touched
-  - Do: concrete implementation steps and important constraints
-  - Verify: the command, test, or runtime check that proves it worked
-  - Done when: a measurable acceptance condition
+  - description: why this task exists, concrete steps, and done-when acceptance
+  - files: JSON array of likely touched paths
+  - verify: the command, test, or runtime check that proves it worked
+  - inputs: JSON array of existing paths or prior task outputs this task consumes
+  - expectedOutput: JSON array of paths this task creates or overwrites
 
   Keep the checkbox line format exactly:
   - [ ] **T01: Title** `est:30m`
@@ -131,10 +131,14 @@
 
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
+  - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `python3 -m pytest tests/ -q --tb=short`
   - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
 
   Integration closure rule:

package/src/resources/extensions/gsd/templates/task-plan.md

@@ -57,6 +57,12 @@ skills_used:
 - {{howToVerifyThisTaskIsActuallyDone}}
 - {{commandToRun_OR_behaviorToCheck}}
 
+## Verify Rules
+
+- Use a real executable check, not prose.
+- If the check needs file-content assertions, write a `node:test` file and run it with `node --test` or a package test script.
+- Do not use inline `node -e` assertions for verification.
+
 ## Observability Impact
 
 <!-- OMIT THIS SECTION ENTIRELY for simple tasks that don't touch runtime boundaries,
@@ -72,7 +78,8 @@ skills_used:
 <!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
      derive task dependencies — vague descriptions without paths break dependency detection.
      For the first task in a slice with no prior task outputs, list the existing source files
-     this task reads or modifies. -->
+     this task reads or modifies.
+     Tool field: inputs must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
 
@@ -82,6 +89,7 @@ skills_used:
      or modifies. These paths are machine-parsed to derive task dependencies.
      This task should produce a real increment toward making the slice goal/demo true. A full
      slice plan should not be able to mark every task complete while the claimed slice behavior
-     still does not work at the stated proof level. -->
+     still does not work at the stated proof level.
+     Tool field: expectedOutput must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

package/src/resources/extensions/gsd/tests/artifact-retry-cap.test.ts

@@ -57,7 +57,7 @@ test("#2007 bug 2: recentUnits.push is unconditional — not gated on pendingVer
   ];
 
   assert.match(
-    detectStuck(window)?.reason ?? "",
+    detectStuck(window, { pendingRetry: true, retryAttempt: 2 })?.reason ?? "",
     /3 consecutive times|3 times in last 3 attempts/,
   );
 });

package/src/resources/extensions/gsd/tests/auto-abort-pause-regression.test.ts

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { _buildAbortedPauseContext, isUserInitiatedAbortMessage } from "../bootstrap/agent-end-recovery.js";
-import { _buildCancelledUnitStopReason } from "../auto/phases.js";
+import { _buildCancelledUnitStopReason, _isPauseOriginCancelledResult } from "../auto/phases.js";
 
 test("aborted agent_end maps errorMessage into structured aborted pause context", () => {
   const withMessage = _buildAbortedPauseContext({ errorMessage: "provider aborted request" });
@@ -36,3 +36,12 @@ test("provider user-abort errors are recognized as cancellations, not provider o
   assert.equal(isUserInitiatedAbortMessage("Request aborted by user"), true);
   assert.equal(isUserInitiatedAbortMessage("HTTP 503 Service Unavailable"), false);
 });
+
+test("cancelled-without-errorContext while paused is treated as pause-origin cancellation", () => {
+  assert.equal(_isPauseOriginCancelledResult(true, undefined), true);
+  assert.equal(_isPauseOriginCancelledResult(false, undefined), false);
+  assert.equal(
+    _isPauseOriginCancelledResult(true, { category: "aborted", message: "Operation aborted" }),
+    false,
+  );
+});