gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/src/resources/extensions/gsd/prompts/refine-slice.md

@@ -0,0 +1,69 @@
+You are executing GSD auto-mode.
+
+## UNIT: Refine Slice {{sliceId}} ("{{sliceTitle}}") — Milestone {{milestoneId}}
+
+## Working Directory
+
+Your working directory is `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
+This unit **expands an approved sketch into a full plan**. It is not a blank-sheet planning pass — the sketch's scope is the authoritative boundary, and the prior slice's real outcomes are the authoritative context. Your job is to produce a detailed plan that fits inside the sketch while reflecting what actually shipped in earlier slices.
+
+All relevant context has been preloaded below — start working immediately without re-reading these files.
+
+{{inlinedContext}}
+
+### Dependency Slice Summaries
+
+Pay particular attention to **Forward Intelligence** sections — they contain hard-won knowledge about what's fragile, what assumptions changed, and what this slice should watch out for. These summaries are the single most important input to refinement: the sketch was written before these slices shipped, so your plan MUST reconcile against what they actually built.
+
+{{dependencySummaries}}
+
+## Your Role in the Pipeline
+
+### Respect the Sketch Scope
+
+The sketch scope inlined above is a **hard constraint**. Plan within it. If, after exploring the codebase, the scope is too narrow to deliver the goal, surface this as a deviation in the plan's narrative and still produce the plan — do not silently expand the scope.
+
+### Reconcile Against Reality
+
+Before decomposing:
+
+1. Read the prior slice SUMMARY files that were inlined above. Note any interface shifts, file-layout changes, or discovered constraints.
+2. Use `rg`, `find`, and targeted reads to confirm the current codebase state for files the sketch references. If an assumed module/type/API has moved or changed shape, your plan must reflect that.
+3. If prior slices flagged fragility or known issues relevant to this slice, fold them into task verification.
+
+### Source Files
+
+{{sourceFilePaths}}
+
+If slice research exists (inlined above), trust those findings and skip redundant exploration.
+
+After you finish, **executor agents** implement each task in isolated fresh context windows. They see only their task plan, the slice plan excerpt, and compressed summaries of prior tasks. Everything an executor needs must be in the task plan itself — file paths, specific steps, expected inputs and outputs.
+
+Narrate your decomposition reasoning in complete sentences. Explain what the sketch promised, what prior slices changed, and how those two inputs shape the decomposition. Keep narration proportional to the work.
+
+**Right-size the plan.** If the slice is simple enough to be 1 task, plan 1 task. Don't fill in sections with "None" — omit them entirely.
+
+{{executorContextConstraints}}
+
+Then:
+0. If `REQUIREMENTS.md` was preloaded above, identify which Active requirements the sketch says this slice owns or supports. Every owned requirement needs at least one task that directly advances it.
+1. Read the templates:
+   - `~/.gsd/agent/extensions/gsd/templates/plan.md`
+   - `~/.gsd/agent/extensions/gsd/templates/task-plan.md`
+2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
+3. Define slice-level verification — the objective stopping condition. Plan real test files with real assertions; for simple slices, executable commands are fine.
+4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
+5. Decompose the slice into tasks that fit one context window each. Every task must have Why / Files / Do / Verify / Done-when, plus a task plan with description, steps, must-haves, verification, inputs (backtick-wrapped paths), and expected output (backtick-wrapped paths).
+6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.
+7. **Self-audit the plan.** If every task were completed exactly as written, the slice goal/demo should actually be true. Every must-have maps to at least one task. Inputs and Expected Output are backtick-wrapped file paths.
+8. If refinement produced structural decisions that diverge from the sketch, append them to `.gsd/DECISIONS.md`.
+9. {{commitInstruction}}
+
+The slice directory and tasks/ subdirectory already exist. Do NOT mkdir.
+
+**Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. Document assumptions in the plan.
+
+**You MUST call `gsd_plan_slice` to persist the planning state before finishing.** After it returns successfully, the pipeline will automatically clear the sketch flag on the next state derivation (the on-disk PLAN file is the signal).
+
+When done, say: "Slice {{sliceId}} refined."

package/src/resources/extensions/gsd/prompts/scan.md

@@ -0,0 +1,79 @@
+You are performing a focused codebase scan.
+
+## Scan Parameters
+
+- **Focus:** {{focus}}
+- **Documents to produce:** {{documents}}
+- **Output directory:** `{{outputDir}}`
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Explore the codebase to understand its structure, technology choices, and patterns
+2. For each document listed above, produce a well-structured Markdown file in `{{outputDir}}/`
+3. Use the document schemas below as a guide for each output file
+
+For this scan, only these documents are relevant: **{{documents}}**. Refer only to those schemas below and ignore the rest.
+
+### Document Schemas
+
+**STACK.md** — Technology stack overview
+- Languages, runtimes, and versions
+- Key frameworks and libraries (with versions where visible)
+- Build tools and bundlers
+- Package manager
+
+**INTEGRATIONS.md** — External dependencies and integrations
+- Third-party APIs and services
+- Database systems
+- Authentication providers
+- Infrastructure and deployment platforms
+- Communication services (email, messaging, etc.)
+
+**ARCHITECTURE.md** — Architectural patterns and design decisions
+- Overall architecture style (monolith, microservices, monorepo, etc.)
+- Core data flow
+- Key design patterns in use
+- Module/package boundaries
+
+**STRUCTURE.md** — Directory and code organization
+- Top-level directory layout with purpose
+- Source code organization
+- Test organization
+- Configuration file locations
+
+**CONVENTIONS.md** — Coding conventions and standards
+- Naming conventions (files, functions, variables)
+- Code style and formatting rules
+- Import/export patterns
+- Error handling patterns
+- TypeScript/language-specific conventions
+
+**TESTING.md** — Testing patterns and practices
+- Test framework(s) in use
+- Test file naming and location conventions
+- Test helper and fixture patterns
+- Coverage requirements (if any)
+- How to run tests
+
+**CONCERNS.md** — Technical debt and risks
+- Known areas of technical debt
+- Fragile or high-risk code areas
+- Missing test coverage
+- Outdated dependencies
+- Performance bottlenecks
+- Security considerations
+
+## Rules
+
+- Write only the documents listed in **Documents to produce** — do not generate extra files
+- Each document must be a clean, standalone Markdown file starting with a `# Heading`
+- Be factual: report what you observe in the code, not what might be ideal
+- Keep each document focused and scannable — use headers, bullet points, and code snippets
+- Do NOT modify any source files
+- After writing all documents, summarize what was produced (file names and line counts)
+
+{{skillActivation}}

package/src/resources/extensions/gsd/prompts/workflow-oneshot.md

@@ -0,0 +1,26 @@
+# Oneshot Workflow: {{displayName}}
+
+You are running a **oneshot** workflow called `{{name}}`. Oneshot workflows are
+prompt-only — there is no STATE.json, no phase tracking, no artifact directory,
+and no resume mechanism. Just execute the instructions below and return.
+
+## User Arguments
+
+`{{userArgs}}`
+
+(If empty, use sensible defaults from the workflow body.)
+
+## Workflow Instructions
+
+{{body}}
+
+## Execution Rules
+
+1. **No scaffolding.** Do not create `.gsd/workflows/` directories, STATE.json
+   files, or run directories unless the instructions explicitly tell you to
+   write a specific artifact.
+2. **No branch switching.** Work on the current branch.
+3. **Be concise.** Oneshot workflows produce a single focused output (a report,
+   a summary, a code change, a PR comment) — finish in this turn.
+4. **Ask only when blocked.** If the instructions need information you can't
+   discover, ask one clear question. Otherwise proceed.

package/src/resources/extensions/gsd/run-manager.ts

@@ -16,8 +16,9 @@
 import { mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { stringify } from "yaml";
-import { loadDefinition, substituteParams } from "./definition-loader.js";
+import { loadDefinition, loadDefinitionFromFile, substituteParams } from "./definition-loader.js";
 import { initializeGraph, writeGraph, readGraph } from "./graph.js";
+import { resolvePlugin } from "./workflow-plugins.js";
 import type { WorkflowDefinition } from "./definition-loader.js";
 import type { WorkflowGraph } from "./graph.js";
 
@@ -67,48 +68,81 @@ function deriveStatus(graph: WorkflowGraph): "pending" | "running" | "complete"
 
 // ─── Public API ──────────────────────────────────────────────────────────
 
+/**
+ * Create a run directory from an explicit definition file path.
+ * Preferred over `createRun` when the caller has already resolved the file
+ * (e.g. via the plugin resolver).
+ */
+export function createRunFromDefinition(
+  basePath: string,
+  defName: string,
+  definitionFile: string,
+  overrides?: Record<string, string>,
+): string {
+  const rawDef = loadDefinitionFromFile(definitionFile);
+  const def: WorkflowDefinition = overrides
+    ? substituteParams(rawDef, overrides)
+    : substituteParams(rawDef);
+
+  const timestamp = makeTimestamp();
+  const runDir = join(basePath, ".gsd", RUNS_DIR, defName, timestamp);
+  mkdirSync(runDir, { recursive: true });
+
+  writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
+
+  const graph = initializeGraph(def);
+  writeGraph(runDir, graph);
+
+  if (overrides && Object.keys(overrides).length > 0) {
+    writeFileSync(
+      join(runDir, "PARAMS.json"),
+      JSON.stringify(overrides, null, 2),
+      "utf-8",
+    );
+  }
+
+  return runDir;
+}
+
 /**
  * Create a new isolated run directory for a workflow definition.
  *
- * 1. Loads the definition from `<basePath>/.gsd/workflow-defs/<defName>.yaml`
- * 2. Applies parameter substitution if overrides are provided
- * 3. Creates `<basePath>/.gsd/workflow-runs/<defName>/<timestamp>/`
- * 4. Writes frozen DEFINITION.yaml, initialized GRAPH.yaml, and optional PARAMS.json
+ * Resolution order:
+ *   1. Plugin resolver (project → global → bundled), YAML format only.
+ *   2. Legacy `.gsd/workflow-defs/<defName>.yaml`.
  *
- * @param basePath — project root directory
- * @param defName — definition filename (without .yaml extension)
- * @param overrides — optional parameter overrides (merged with definition defaults)
- * @returns Full path to the created run directory
- * @throws Error if the definition file doesn't exist or is invalid
+ * Creates `<basePath>/.gsd/workflow-runs/<defName>/<timestamp>/` containing
+ * DEFINITION.yaml (frozen), GRAPH.yaml (initialized), and optional PARAMS.json.
+ *
+ * @throws Error if no matching definition is found anywhere.
  */
 export function createRun(
   basePath: string,
   defName: string,
   overrides?: Record<string, string>,
 ): string {
-  const defsDir = join(basePath, ".gsd", DEFS_DIR);
+  // Try the unified plugin resolver first — honors project/global overrides.
+  const plugin = resolvePlugin(basePath, defName);
+  if (plugin && plugin.format === "yaml") {
+    return createRunFromDefinition(basePath, defName, plugin.path, overrides);
+  }
 
-  // Load and validate the definition
+  // Fall back to legacy `.gsd/workflow-defs/<defName>.yaml`.
+  const defsDir = join(basePath, ".gsd", DEFS_DIR);
   const rawDef = loadDefinition(defsDir, defName);
-
-  // Apply parameter substitution if overrides provided
   const def: WorkflowDefinition = overrides
     ? substituteParams(rawDef, overrides)
-    : substituteParams(rawDef); // still resolve default params if any
+    : substituteParams(rawDef);
 
-  // Create the run directory
   const timestamp = makeTimestamp();
   const runDir = join(basePath, ".gsd", RUNS_DIR, defName, timestamp);
   mkdirSync(runDir, { recursive: true });
 
-  // Freeze the definition as DEFINITION.yaml
   writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
 
-  // Initialize and write GRAPH.yaml
   const graph = initializeGraph(def);
   writeGraph(runDir, graph);
 
-  // Write PARAMS.json if overrides were provided
   if (overrides && Object.keys(overrides).length > 0) {
     writeFileSync(
       join(runDir, "PARAMS.json"),

package/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -68,11 +68,11 @@ export function getFilePaths(): string[] {
  * Record a tool call at dispatch time (before execution).
  * Exit codes and output are filled in by recordToolResult after execution.
  */
-export function recordToolCall(toolName: string, input: Record<string, unknown>): void {
+export function recordToolCall(toolCallId: string, toolName: string, input: Record<string, unknown>): void {
   if (toolName === "bash" || toolName === "Bash") {
     unitEvidence.push({
       kind: "bash",
-      toolCallId: "",
+      toolCallId,
       command: String(input.command ?? ""),
       exitCode: -1,
       outputSnippet: "",
@@ -81,14 +81,14 @@ export function recordToolCall(toolName: string, input: Record<string, unknown>)
   } else if (toolName === "write" || toolName === "Write") {
     unitEvidence.push({
       kind: "write",
-      toolCallId: "",
+      toolCallId,
       path: String(input.file_path ?? input.path ?? ""),
       timestamp: Date.now(),
     });
   } else if (toolName === "edit" || toolName === "Edit") {
     unitEvidence.push({
       kind: "edit",
-      toolCallId: "",
+      toolCallId,
       path: String(input.file_path ?? input.path ?? ""),
       timestamp: Date.now(),
     });
@@ -96,8 +96,9 @@ export function recordToolCall(toolName: string, input: Record<string, unknown>)
 }
 
 /**
- * Record a tool execution result. Matches the most recent unresolved entry
- * of the same kind and fills in the toolCallId, exit code, and output.
+ * Record a tool execution result. Matches the entry by toolCallId (assigned
+ * at dispatch time) and fills in exit code + output. Prior versions matched
+ * by `kind + empty-string` which corrupted parallel tool calls.
  */
 export function recordToolResult(
   toolCallId: string,
@@ -105,36 +106,19 @@ export function recordToolResult(
   result: unknown,
   isError: boolean,
 ): void {
-  const normalizedName = toolName.toLowerCase();
-
-  if (normalizedName === "bash") {
-    const entry = findLastUnresolved("bash") as BashEvidence | undefined;
-    if (entry) {
-      entry.toolCallId = toolCallId;
-      const text = extractResultText(result);
-      entry.outputSnippet = text.slice(0, 500);
-      const exitMatch = text.match(/Command exited with code (\d+)/);
-      entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
-    }
-  } else if (normalizedName === "write" || normalizedName === "edit") {
-    const entry = findLastUnresolved(normalizedName as "write" | "edit");
-    if (entry) {
-      entry.toolCallId = toolCallId;
-    }
+  const entry = unitEvidence.find(e => e.toolCallId === toolCallId);
+  if (!entry) return;
+
+  if (entry.kind === "bash") {
+    const text = extractResultText(result);
+    entry.outputSnippet = text.slice(0, 500);
+    const exitMatch = text.match(/Command exited with code (\d+)/);
+    entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
   }
 }
 
 // ─── Internals ──────────────────────────────────────────────────────────────
 
-function findLastUnresolved(kind: string): EvidenceEntry | undefined {
-  for (let i = unitEvidence.length - 1; i >= 0; i--) {
-    if (unitEvidence[i].kind === kind && unitEvidence[i].toolCallId === "") {
-      return unitEvidence[i];
-    }
-  }
-  return undefined;
-}
-
 function extractResultText(result: unknown): string {
   if (typeof result === "string") return result;
   if (result && typeof result === "object") {

package/src/resources/extensions/gsd/session-lock.ts

@@ -52,6 +52,18 @@ export interface SessionLockStatus {
   recovered?: boolean;
 }
 
+interface ProperLockfileApi {
+  lockSync(
+    path: string,
+    options?: {
+      realpath?: boolean;
+      stale?: number;
+      update?: number;
+      onCompromised?: () => void;
+    },
+  ): () => void;
+}
+
 // ─── Module State ───────────────────────────────────────────────────────────
 
 /** Release function from proper-lockfile — calling it releases the OS lock. */
@@ -277,9 +289,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     unitStartedAt: new Date().toISOString(),
   };
 
-  let lockfile: typeof import("proper-lockfile");
+  let lockfile: ProperLockfileApi;
   try {
-    lockfile = _require("proper-lockfile") as typeof import("proper-lockfile");
+    lockfile = _require("proper-lockfile") as ProperLockfileApi;
   } catch {
     // proper-lockfile not available — fall back to PID-based check
     return acquireFallbackLock(basePath, lp, lockData);

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

@@ -32,6 +32,7 @@ import {
 } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -61,6 +62,7 @@ export interface SliceOrchestratorState {
 export interface StartSliceParallelOpts {
   maxWorkers?: number;
   budgetCeiling?: number;
+  useExecutionGraph?: boolean;
 }
 
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -118,7 +120,12 @@ export async function startSliceParallel(
   const errors: Array<{ sid: string; error: string }> = [];
 
   // Filter out conflicting slices (conservative: check all pairs)
-  const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+  const safeSlices = filterConflictingSlices(
+    basePath,
+    milestoneId,
+    eligibleSlices,
+    opts.useExecutionGraph === true,
+  );
 
   // Limit to maxWorkers
   const toSpawn = safeSlices.slice(0, maxWorkers);
@@ -245,7 +252,19 @@ function filterConflictingSlices(
   basePath: string,
   milestoneId: string,
   slices: Array<{ id: string }>,
+  useExecutionGraph: boolean,
 ): Array<{ id: string }> {
+  if (useExecutionGraph) {
+    const selectedIds = selectConflictFreeBatch({
+      orderedIds: slices.map((slice) => slice.id),
+      maxParallel: slices.length,
+      hasConflict: (candidate, existing) =>
+        hasFileConflict(basePath, milestoneId, candidate, existing),
+    });
+    const selected = new Set(selectedIds);
+    return slices.filter((slice) => selected.has(slice.id));
+  }
+
   const safe: Array<{ id: string }> = [];
 
   for (const candidate of slices) {

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

@@ -44,6 +44,8 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
+import { loadEffectiveGSDPreferences } from './preferences.js';
+import { detectPendingEscalation } from './escalation.js';
 
 import {
   isDbAvailable,
@@ -60,6 +62,7 @@ import {
   updateSliceStatus,
   updateTaskStatus,
   getPendingGateCountForTurn,
+  autoHealSketchFlags,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -345,8 +348,15 @@ function reconcileDiskToDb(basePath: string): MilestoneRow[] {
     const dbSliceIds = new Set(dbSlices.map(s => s.id));
 
     let roadmapContent: string;
-    try { roadmapContent = readFileSync(roadmapPath, "utf-8"); }
-    catch { continue; }
+    try {
+      roadmapContent = readFileSync(roadmapPath, "utf-8");
+    } catch (err) {
+      logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+        mid,
+        error: (err as Error).message,
+      });
+      continue;
+    }
 
     const parsed = parseRoadmap(roadmapContent);
     for (const s of parsed.slices) {
@@ -842,7 +852,15 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     return handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress);
   }
 
-  const activeSliceContext = resolveSliceDependencies(activeMilestoneSlices);
+  // ADR-011 auto-heal: if a slice has a PLAN on disk but is still flagged is_sketch=1
+  // (e.g. a crash between plan-slice write and the sketch flip), reconcile before
+  // running phase derivation so the flag doesn't misroute state.
+  autoHealSketchFlags(activeMilestone.id, (sid) =>
+    !!resolveSliceFile(basePath, activeMilestone.id, sid, "PLAN"),
+  );
+  // Re-read slices after auto-heal so downstream reads see fresh is_sketch values.
+  const healedSlices = getMilestoneSlices(activeMilestone.id);
+  const activeSliceContext = resolveSliceDependencies(healedSlices);
   if (!activeSliceContext.activeSlice) {
     // If locked slice wasn't found, it returns null but logs warning, we need to return 'blocked'
     if (process.env.GSD_SLICE_LOCK) {
@@ -862,10 +880,24 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       progress: { milestones: milestoneProgress, slices: sliceProgress },
     };
   }
-  const { activeSlice } = activeSliceContext;
+  const { activeSlice, activeSliceRow } = activeSliceContext;
 
   const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
   if (!planFile) {
+    // ADR-011: sketch slices with progressive_planning enabled enter the
+    // `refining` phase — a refine-slice unit expands the sketch into a full plan
+    // before execution. When the flag is off, sketches are indistinguishable
+    // from a missing plan and fall through to the normal `planning` phase.
+    const progressive = loadEffectiveGSDPreferences()?.preferences?.phases?.progressive_planning === true;
+    if (progressive && activeSliceRow?.is_sketch === 1) {
+      return {
+        activeMilestone, activeSlice, activeTask: null,
+        phase: 'refining', recentDecisions: [], blockers: [],
+        nextAction: `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`,
+        registry, requirements,
+        progress: { milestones: milestoneProgress, slices: sliceProgress },
+      };
+    }
     return {
       activeMilestone, activeSlice, activeTask: null,
       phase: 'planning', recentDecisions: [], blockers: [],
@@ -958,6 +990,29 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     }
   }
 
+  // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
+  // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
+  // surfaced here — they let the loop continue.
+  //
+  // We do NOT gate this on `phases.mid_execution_escalation` — creation of
+  // new escalations is gated at the write site (tools/complete-task.ts:315),
+  // but any escalation_pending row already persisted in the DB must be
+  // honored even if the user later toggles the flag off. Otherwise those
+  // rows would silently orphan, the loop would advance past the paused task,
+  // and the user's prior resolution never lands.
+  const escalatingTaskId = detectPendingEscalation(tasks, basePath);
+  if (escalatingTaskId) {
+    return {
+      activeMilestone, activeSlice, activeTask,
+      phase: 'escalating-task', recentDecisions: [],
+      blockers: [`Task ${escalatingTaskId} requires a user decision before the loop can proceed`],
+      nextAction: `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`,
+      activeWorkspace: undefined,
+      registry, requirements,
+      progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+    };
+  }
+
   if (!blockerTaskId) {
     const isTriggered = checkReplanTrigger(basePath, activeMilestone.id, activeSlice.id);
     if (isTriggered) {

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

@@ -39,6 +39,24 @@ dynamic_routing:
   budget_pressure:
   cross_provider:
   hooks:
+uok:
+  enabled: true
+  legacy_fallback:
+    enabled: false
+  gates:
+    enabled: true
+  model_policy:
+    enabled: true
+  execution_graph:
+    enabled: true
+  gitops:
+    enabled: true
+    turn_action: commit
+    turn_push: false
+  audit_unified:
+    enabled: true
+  plan_v2:
+    enabled: true
 auto_visualize:
 auto_report:
 parallel:
@@ -71,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -2,8 +2,7 @@
  * agent-end-retry.test.ts — Regression checks for the agent_end model.
  *
  * The per-unit one-shot resolve function lives at module level in auto-loop.ts
- * (_currentResolve). handleAgentEnd is a thin compatibility wrapper around
- * resolveAgentEnd().
+ * (_currentResolve). agent_end is handled via resolveAgentEnd().
  */
 
 import test from "node:test";
@@ -62,38 +61,6 @@ test("legacy pendingAgentEndRetry state is gone", () => {
   );
 });
 
-test("handleAgentEnd is a thin compatibility wrapper", () => {
-  const source = getAutoTsSource();
-  const fnIdx = source.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
-  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── ", fnIdx + 100));
-
-  assert.ok(
-    fnBlock.includes("resolveAgentEnd("),
-    "handleAgentEnd must delegate to resolveAgentEnd",
-  );
-  assert.ok(
-    !fnBlock.includes("pendingAgentEndRetry"),
-    "handleAgentEnd must not use legacy retry state",
-  );
-  assert.ok(
-    !fnBlock.includes("dispatchNextUnit"),
-    "handleAgentEnd must not dispatch recursively",
-  );
-});
-
-test("handleAgentEnd early return calls resolveAgentEndCancelled", () => {
-  const source = getAutoTsSource();
-  const fnIdx = source.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
-  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── ", fnIdx + 100));
-
-  assert.ok(
-    fnBlock.includes("resolveAgentEndCancelled()"),
-    "handleAgentEnd must call resolveAgentEndCancelled on early return to prevent orphaned promises",
-  );
-});
-
 test("pauseAuto calls resolveAgentEndCancelled to unblock the loop", () => {
   const source = getAutoTsSource();
   const fnIdx = source.indexOf("export async function pauseAuto");

package/src/resources/extensions/gsd/tests/artifact-corruption-2630.test.ts

@@ -46,6 +46,8 @@ function makeSliceRow(overrides?: Partial<SliceRow>): SliceRow {
     observability_impact: '',
     sequence: 4,
     replan_triggered_at: null,
+    is_sketch: 0,
+    sketch_scope: '',
     ...overrides,
   };
 }
@@ -77,6 +79,11 @@ function makeTaskRow(overrides?: Partial<TaskRow>): TaskRow {
     expected_output: [],
     observability_impact: '',
     sequence: 0,
+    blocker_source: '',
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
     ...overrides,
   };
 }