@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/workflow-manifest.ts

@@ -6,24 +6,70 @@ import {
   readTransaction,
   restoreManifest,
 } from "./gsd-db.js";
-import type { MilestoneRow } from "./db-milestone-artifact-rows.js";
+import type { ArtifactRow, MilestoneRow } from "./db-milestone-artifact-rows.js";
 import type { SliceRow, TaskRow } from "./db-task-slice-rows.js";
 import type { VerificationEvidenceRow } from "./db-verification-evidence-rows.js";
-import type { Decision } from "./types.js";
+import type { Decision, GateRow, Requirement } from "./types.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { getAllDecisionsFromMemories } from "./context-store.js";
+import { backfillDecisionsToMemories } from "./memory-backfill.js";
+import { invalidateAllCaches } from "./cache.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 
 // ─── Manifest Types ──────────────────────────────────────────────────────
 
+export interface ManifestArtifactRow extends ArtifactRow {
+  content_hash: string | null;
+}
+
+export interface ReplanHistoryManifestRow {
+  id: number;
+  milestone_id: string;
+  slice_id: string | null;
+  task_id: string | null;
+  summary: string;
+  previous_artifact_path: string | null;
+  replacement_artifact_path: string | null;
+  created_at: string;
+}
+
+export interface AssessmentManifestRow {
+  path: string;
+  milestone_id: string;
+  slice_id: string | null;
+  task_id: string | null;
+  status: string;
+  scope: string;
+  full_content: string;
+  created_at: string;
+}
+
+export interface MilestoneCommitAttributionManifestRow {
+  commit_sha: string;
+  milestone_id: string;
+  slice_id: string | null;
+  task_id: string | null;
+  source: string;
+  confidence: number;
+  files_json: string;
+  created_at: string;
+}
+
 export interface StateManifest {
   version: 1;
   exported_at: string; // ISO 8601
+  requirements?: Requirement[];
+  artifacts?: ManifestArtifactRow[];
   milestones: MilestoneRow[];
   slices: SliceRow[];
   tasks: TaskRow[];
   decisions: Decision[];
+  replan_history?: ReplanHistoryManifestRow[];
+  assessments?: AssessmentManifestRow[];
+  quality_gates?: GateRow[];
   verification_evidence: VerificationEvidenceRow[];
+  milestone_commit_attributions?: MilestoneCommitAttributionManifestRow[];
 }
 
 // ─── helpers ─────────────────────────────────────────────────────────────
@@ -51,11 +97,26 @@ export function toNumeric(value: unknown, fallback: number | null = null): numbe
   return fallback;
 }
 
+function mergeDecisionSurfaces(legacyDecisions: Decision[], memoryDecisions: Decision[]): Decision[] {
+  const byId = new Map<string, Decision>();
+  for (const decision of legacyDecisions) {
+    byId.set(decision.id, decision);
+  }
+  for (const decision of memoryDecisions) {
+    byId.set(decision.id, decision);
+  }
+  return Array.from(byId.values()).sort((a, b) => {
+    const seqDelta = (a.seq ?? 0) - (b.seq ?? 0);
+    return seqDelta === 0 ? a.id.localeCompare(b.id) : seqDelta;
+  });
+}
+
 // ─── snapshotState ───────────────────────────────────────────────────────
 
 /**
- * Capture complete DB state as a StateManifest.
- * Reads all rows from milestones, slices, tasks, decisions, verification_evidence.
+ * Capture DB-backed workflow state as a StateManifest.
+ * Runtime soft state and append-only audit streams stay outside this recovery
+ * substrate; correctness records and persisted evidence are included.
  *
  * Note: rows returned from raw queries are plain objects with TEXT columns for
  * JSON arrays. We parse them into typed Row objects using the same logic as
@@ -67,6 +128,34 @@ export function snapshotState(): StateManifest {
   // Wrap all reads in a deferred transaction so the snapshot is consistent
   // (all SELECTs see the same DB state even if a concurrent write lands between them).
   return readTransaction(() => {
+  const rawRequirements = db.prepare("SELECT * FROM requirements ORDER BY id").all() as Record<string, unknown>[];
+  const requirements: Requirement[] = rawRequirements.map((r) => ({
+    id: r["id"] as string,
+    class: (r["class"] as string) ?? "",
+    status: (r["status"] as string) ?? "",
+    description: (r["description"] as string) ?? "",
+    why: (r["why"] as string) ?? "",
+    source: (r["source"] as string) ?? "",
+    primary_owner: (r["primary_owner"] as string) ?? "",
+    supporting_slices: (r["supporting_slices"] as string) ?? "",
+    validation: (r["validation"] as string) ?? "",
+    notes: (r["notes"] as string) ?? "",
+    full_content: (r["full_content"] as string) ?? "",
+    superseded_by: (r["superseded_by"] as string) ?? null,
+  }));
+
+  const rawArtifacts = db.prepare("SELECT * FROM artifacts ORDER BY path").all() as Record<string, unknown>[];
+  const artifacts: ManifestArtifactRow[] = rawArtifacts.map((r) => ({
+    path: r["path"] as string,
+    artifact_type: (r["artifact_type"] as string) ?? "",
+    milestone_id: (r["milestone_id"] as string) ?? null,
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    full_content: (r["full_content"] as string) ?? "",
+    imported_at: (r["imported_at"] as string) ?? "",
+    content_hash: (r["content_hash"] as string) ?? null,
+  }));
+
   const rawMilestones = db.prepare(
     "SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id",
   ).all() as Record<string, unknown>[];
@@ -152,7 +241,7 @@ export function snapshotState(): StateManifest {
   }));
 
   const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all() as Record<string, unknown>[];
-  const decisions: Decision[] = rawDecisions.map((r) => ({
+  const legacyDecisions: Decision[] = rawDecisions.map((r) => ({
     seq: toNumeric(r["seq"], 0) as number,
     id: r["id"] as string,
     when_context: (r["when_context"] as string) ?? "",
@@ -165,6 +254,45 @@ export function snapshotState(): StateManifest {
     source: (r["source"] as string) ?? "discussion",
     superseded_by: (r["superseded_by"] as string) ?? null,
   }));
+  const decisions = mergeDecisionSurfaces(legacyDecisions, getAllDecisionsFromMemories());
+
+  const rawReplanHistory = db.prepare("SELECT * FROM replan_history ORDER BY id").all() as Record<string, unknown>[];
+  const replan_history: ReplanHistoryManifestRow[] = rawReplanHistory.map((r) => ({
+    id: toNumeric(r["id"], 0) as number,
+    milestone_id: (r["milestone_id"] as string) ?? "",
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    summary: (r["summary"] as string) ?? "",
+    previous_artifact_path: (r["previous_artifact_path"] as string) ?? null,
+    replacement_artifact_path: (r["replacement_artifact_path"] as string) ?? null,
+    created_at: (r["created_at"] as string) ?? "",
+  }));
+
+  const rawAssessments = db.prepare("SELECT * FROM assessments ORDER BY path").all() as Record<string, unknown>[];
+  const assessments: AssessmentManifestRow[] = rawAssessments.map((r) => ({
+    path: r["path"] as string,
+    milestone_id: (r["milestone_id"] as string) ?? "",
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    status: (r["status"] as string) ?? "",
+    scope: (r["scope"] as string) ?? "",
+    full_content: (r["full_content"] as string) ?? "",
+    created_at: (r["created_at"] as string) ?? "",
+  }));
+
+  const rawQualityGates = db.prepare("SELECT * FROM quality_gates ORDER BY milestone_id, slice_id, gate_id, task_id").all() as Record<string, unknown>[];
+  const quality_gates: GateRow[] = rawQualityGates.map((r) => ({
+    milestone_id: r["milestone_id"] as string,
+    slice_id: r["slice_id"] as string,
+    gate_id: r["gate_id"] as GateRow["gate_id"],
+    scope: r["scope"] as GateRow["scope"],
+    task_id: (r["task_id"] as string) ?? "",
+    status: r["status"] as GateRow["status"],
+    verdict: r["status"] === "pending" ? null : (r["verdict"] as GateRow["verdict"]),
+    rationale: (r["rationale"] as string) ?? "",
+    findings: (r["findings"] as string) ?? "",
+    evaluated_at: (r["evaluated_at"] as string) ?? null,
+  }));
 
   const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all() as Record<string, unknown>[];
   const verification_evidence: VerificationEvidenceRow[] = rawEvidence.map((r) => ({
@@ -179,14 +307,34 @@ export function snapshotState(): StateManifest {
     created_at: r["created_at"] as string,
   }));
 
+  const rawCommitAttributions = db.prepare(
+    "SELECT * FROM milestone_commit_attributions ORDER BY milestone_id, commit_sha",
+  ).all() as Record<string, unknown>[];
+  const milestone_commit_attributions: MilestoneCommitAttributionManifestRow[] = rawCommitAttributions.map((r) => ({
+    commit_sha: r["commit_sha"] as string,
+    milestone_id: r["milestone_id"] as string,
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    source: (r["source"] as string) ?? "recorded",
+    confidence: toNumeric(r["confidence"], 1) as number,
+    files_json: (r["files_json"] as string) ?? "[]",
+    created_at: (r["created_at"] as string) ?? "",
+  }));
+
   const result: StateManifest = {
     version: 1,
     exported_at: new Date().toISOString(),
+    requirements,
+    artifacts,
     milestones,
     slices,
     tasks,
     decisions,
+    replan_history,
+    assessments,
+    quality_gates,
     verification_evidence,
+    milestone_commit_attributions,
   };
 
   return result;
@@ -232,20 +380,55 @@ export function readManifest(basePath: string): StateManifest | null {
     throw new Error(`Unsupported manifest version: ${parsed.version}`);
   }
 
-  // Validate required fields to avoid cryptic errors during restore
+  // Validate required fields to avoid cryptic errors during restore.
   if (!Array.isArray(parsed.milestones) || !Array.isArray(parsed.slices) ||
       !Array.isArray(parsed.tasks) || !Array.isArray(parsed.decisions) ||
       !Array.isArray(parsed.verification_evidence)) {
     throw new Error("Malformed manifest: missing or invalid required arrays");
   }
 
+  for (const key of ["requirements", "artifacts", "replan_history", "assessments", "quality_gates", "milestone_commit_attributions"] as const) {
+    if (parsed[key] !== undefined && !Array.isArray(parsed[key])) {
+      throw new Error(`Malformed manifest: ${key} must be an array when present`);
+    }
+  }
+
   return parsed;
 }
 
+function stripGsdPrefix(path: string): string {
+  return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
+}
+
+function artifactProjectionPath(basePath: string, artifactPath: string): string {
+  const gsdDir = resolve(basePath, ".gsd");
+  const fullPath = resolve(gsdDir, stripGsdPrefix(artifactPath));
+  const rel = relative(gsdDir, fullPath);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`Malformed manifest: artifact path escapes .gsd: ${artifactPath}`);
+  }
+  return fullPath;
+}
+
+function restoreArtifactProjections(basePath: string, manifest: StateManifest): void {
+  if (manifest.artifacts === undefined) return;
+
+  for (const artifact of manifest.artifacts) {
+    atomicWriteSync(
+      artifactProjectionPath(basePath, artifact.path),
+      artifact.full_content ?? "",
+    );
+  }
+}
+
 // ─── bootstrapFromManifest ──────────────────────────────────────────────
 
 /**
  * Read state-manifest.json and restore DB state from it.
+ * Rehydrates artifact projection files for restored artifacts so file-based
+ * fallback paths see the same evidence as the DB.
+ * Re-mirrors restored legacy decisions into memories so the ADR-013
+ * memory-backed decision readers see bootstrapped decisions immediately.
  * Returns true if bootstrap succeeded, false if manifest file doesn't exist.
  */
 export function bootstrapFromManifest(basePath: string): boolean {
@@ -256,5 +439,8 @@ export function bootstrapFromManifest(basePath: string): boolean {
   }
 
   restoreManifest(manifest);
+  restoreArtifactProjections(basePath, manifest);
+  backfillDecisionsToMemories();
+  invalidateAllCaches();
   return true;
 }

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -546,6 +546,15 @@ export async function regenerateIfMissing(
     return false;
   }
 
+  // A sketch slice (or any slice not yet planned into tasks) legitimately has
+  // no PLAN.md to project. renderPlanFromDb throws on a zero-task slice, so
+  // skip cleanly here rather than logging a spurious failure. The PLAN.md will
+  // be created once the slice is refined and its first task is written through
+  // the single writer.
+  if (fileType === "PLAN" && getSliceTasks(milestoneId, sliceId).length === 0) {
+    return false;
+  }
+
   // Regenerate the missing file. Each renderer may swallow its own errors
   // (e.g. renderStateProjection), so confirm the file actually exists on
   // disk before reporting success — true must mean "file is there now".

package/src/resources/extensions/gsd/worktree-state-projection.ts

@@ -123,36 +123,29 @@ function forceOverwriteAssessmentsWithVerdict(
   }
 }
 
-function syncTopLevelMilestoneArtifacts(
+function syncOtherMilestoneArtifacts(
   srcMilestonesDir: string,
   dstMilestonesDir: string,
+  currentMilestoneId: string,
 ): void {
   if (!existsSync(srcMilestonesDir)) return;
 
   try {
     for (const milestoneEntry of readdirSync(srcMilestonesDir, { withFileTypes: true })) {
       if (!milestoneEntry.isDirectory()) continue;
+      // The current milestone is already fully projected by the caller's
+      // additive safeCopyRecursive; skip it here to avoid redundant work.
+      if (milestoneEntry.name === currentMilestoneId) continue;
       const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
       const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
 
-      try {
-        mkdirSync(dstMilestoneDir, { recursive: true });
-        for (const fileEntry of readdirSync(srcMilestoneDir, { withFileTypes: true })) {
-          if (!fileEntry.isFile()) continue;
-          if (!fileEntry.name.endsWith(".md") && !fileEntry.name.endsWith(".json")) continue;
-
-          safeCopy(
-            join(srcMilestoneDir, fileEntry.name),
-            join(dstMilestoneDir, fileEntry.name),
-            { force: false },
-          );
-        }
-      } catch (err) {
-        logWarning(
-          "worktree",
-          `milestone top-level artifact sync failed (${milestoneEntry.name}): ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
+      // Additively project the entire milestone subtree (force:false), not just
+      // top-level files. Prior completed milestones keep their per-slice and
+      // per-task SUMMARY.md / UAT.md on disk so the worktree's stale-render
+      // detector doesn't flag them as missing (DB has summary, disk doesn't).
+      // force:false preserves any worktree-local files (#1886 invariant) and
+      // only fills in files absent from the worktree projection.
+      safeCopyRecursive(srcMilestoneDir, dstMilestoneDir, { force: false });
     }
   } catch (err) {
     logWarning(
@@ -248,9 +241,16 @@ export function _projectRootToWorktreeImpl(
     { force: false },
   );
 
-  // Additively project missing top-level milestone files for all milestones
-  // so worktree-bound units can verify future-milestone context artifacts.
-  syncTopLevelMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"));
+  // Additively project the full subtree of every OTHER milestone so
+  // worktree-bound units can read prior-milestone context artifacts and so
+  // completed milestones retain their per-slice/per-task SUMMARY.md and
+  // UAT.md on the worktree filesystem (otherwise the stale-render detector
+  // flags them as "complete in DB but missing on disk").
+  syncOtherMilestoneArtifacts(
+    join(prGsd, "milestones"),
+    join(wtGsd, "milestones"),
+    milestoneId,
+  );
 
   // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
   // The additive-only copy above preserves worktree-local files, but

package/src/resources/extensions/shared/tests/format-utils.test.ts

@@ -11,6 +11,7 @@ import {
   centerLine,
   fitColumns,
 } from "../layout-utils.js";
+import { visibleWidth } from "@gsd/pi-tui";
 
 describe("formatDuration", () => {
   it("formats seconds", () => {
@@ -59,8 +60,10 @@ describe("joinColumns", () => {
 
   it("truncates when content overflows", () => {
     const result = joinColumns("a".repeat(20), "b".repeat(20), 30);
-    // Should be truncated to 30 chars
-    assert.ok(result.length <= 30);
+    // truncateToWidth is ANSI-aware and brackets the ellipsis with zero-width
+    // SGR resets, so the visible width — not the raw string length — is the
+    // invariant that must hold within the column budget.
+    assert.ok(visibleWidth(result) <= 30);
   });
 });
 
@@ -72,7 +75,9 @@ describe("centerLine", () => {
 
   it("truncates when content exceeds width", () => {
     const result = centerLine("abcdefgh", 4);
-    assert.ok(result.length <= 4);
+    // Visible width is the meaningful budget; the result may carry zero-width
+    // SGR reset codes around the ellipsis (see truncateToWidth).
+    assert.ok(visibleWidth(result) <= 4);
   });
 });
 

package/src/resources/extensions/subagent/agents.ts

@@ -15,6 +15,8 @@ export interface AgentConfig {
 	description: string;
 	tools?: string[];
 	model?: string;
+	/** Default reasoning effort for this agent, forwarded as `--thinking` (#508). */
+	thinking?: string;
 	conflictsWith?: string[];
 	systemPrompt: string;
 	source: "user" | "project";
@@ -31,6 +33,7 @@ interface AgentFrontmatter extends Record<string, unknown> {
 	description?: string;
 	tools?: string | string[];
 	model?: string;
+	thinking?: string;
 	conflicts_with?: string;
 }
 
@@ -100,6 +103,7 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			description: frontmatter.description,
 			tools: tools && tools.length > 0 ? tools : undefined,
 			model: frontmatter.model,
+			thinking: typeof frontmatter.thinking === "string" ? frontmatter.thinking : undefined,
 			conflictsWith,
 			systemPrompt: body,
 			source,

package/src/resources/extensions/subagent/index.ts

@@ -341,6 +341,7 @@ interface TaskParam {
 	task: string;
 	cwd?: string;
 	model?: string;
+	thinking?: string;
 	context?: SubagentContextMode;
 }
 
@@ -416,6 +417,9 @@ async function runSingleAgent(
 	parentSessionManager?: Parameters<typeof createSubagentLaunchPlan>[0]["parentSessionManager"],
 	sessionOverride?: SubagentSessionArgs,
 	trackingName?: string,
+	// Trailing param (kept after trackingName so existing positional call sites
+	// don't shift). Reasoning effort forwarded to the child (#508).
+	thinkingOverride?: string,
 ): Promise<SingleResult> {
 	const agent = agents.find((a) => a.name === agentName);
 
@@ -489,6 +493,7 @@ async function runSingleAgent(
 			task,
 			tmpPromptPath,
 			modelOverride,
+			thinkingOverride,
 			contextMode,
 			parentSessionManager,
 			session: sessionOverride,
@@ -581,10 +586,12 @@ async function runSingleAgentInCmuxSplit(
 	parentSessionManager?: Parameters<typeof createSubagentLaunchPlan>[0]["parentSessionManager"],
 	sessionOverride?: SubagentSessionArgs,
 	trackingName?: string,
+	// Trailing param (see runSingleAgent). Reasoning effort forwarded to the child (#508).
+	thinkingOverride?: string,
 ): Promise<SingleResult> {
 	const agent = agents.find((a) => a.name === agentName);
 	if (!agent) {
-		return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode, parentSessionManager, sessionOverride, trackingName);
+		return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode, parentSessionManager, sessionOverride, trackingName, thinkingOverride);
 	}
 
 	let tmpPromptDir: string | null = null;
@@ -631,7 +638,7 @@ async function runSingleAgentInCmuxSplit(
 			? await cmuxClient.createSplit(directionOrSurfaceId as "right" | "down" | "left" | "up")
 			: directionOrSurfaceId;
 		if (!cmuxSurfaceId) {
-			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode, parentSessionManager, sessionOverride, trackingName);
+			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode, parentSessionManager, sessionOverride, trackingName, thinkingOverride);
 		}
 
 		const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map((s) => s.trim()).filter(Boolean);
@@ -641,6 +648,7 @@ async function runSingleAgentInCmuxSplit(
 			task,
 			tmpPromptPath,
 			modelOverride,
+			thinkingOverride,
 			contextMode,
 			parentSessionManager,
 			session: sessionOverride,
@@ -665,7 +673,7 @@ async function runSingleAgentInCmuxSplit(
 
 		const sent = await cmuxClient.sendSurface(cmuxSurfaceId, `bash -lc ${shellEscape(innerScript)}`);
 		if (!sent) {
-			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode, parentSessionManager, sessionOverride, trackingName);
+			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode, parentSessionManager, sessionOverride, trackingName, thinkingOverride);
 		}
 
 		const finished = await waitForFile(exitPath, signal);
@@ -726,11 +734,18 @@ async function runSingleAgentInCmuxSplit(
 	}
 }
 
+const ThinkingLevelSchema = StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"] as const, {
+	description:
+		"Reasoning effort override for the subagent (forwarded as --thinking). " +
+		"Independent of model choice; unsupported levels are clamped to the model at dispatch.",
+});
+
 const TaskItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
 	task: Type.String({ description: "Task to delegate to the agent" }),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
 	model: Type.Optional(Type.String({ description: "Model override for this task (e.g. 'claude-sonnet-4-6')" })),
+	thinking: Type.Optional(ThinkingLevelSchema),
 	context: Type.Optional(StringEnum(["fresh", "fork"] as const, {
 		description: 'Context mode for this task (see context field on the top-level params).',
 		default: "fresh",
@@ -742,6 +757,7 @@ const ChainItem = Type.Object({
 	task: Type.String({ description: "Task with optional {previous} placeholder for prior step output" }),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
 	model: Type.Optional(Type.String({ description: "Model override for this step (e.g. 'claude-sonnet-4-6')" })),
+	thinking: Type.Optional(ThinkingLevelSchema),
 	context: Type.Optional(StringEnum(["fresh", "fork"] as const, {
 		description: 'Context mode for this step (see context field on the top-level params).',
 		default: "fresh",
@@ -779,6 +795,7 @@ const SubagentParams = Type.Object({
 	),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process (single mode)" })),
 	model: Type.Optional(Type.String({ description: "Model override for the subagent (e.g. 'claude-sonnet-4-6'). Takes precedence over the agent's frontmatter model." })),
+	thinking: Type.Optional(ThinkingLevelSchema),
 	isolated: Type.Optional(
 		Type.Boolean({
 			description:
@@ -930,6 +947,7 @@ export default function (pi: ExtensionAPI) {
 					ctx.sessionManager,
 					{ mode: "fork", sessionFile: selected.sessionFile, sessionDir: path.dirname(selected.sessionFile) },
 					selected.trackingName,
+					params.thinking,
 				);
 				return {
 					content: [{ type: "text", text: getFinalOutput(result.messages) || result.errorMessage || result.stderr || "(no output)" }],
@@ -1244,6 +1262,7 @@ export default function (pi: ExtensionAPI) {
 							ctx.sessionManager,
 							undefined,
 							dispatchTrackingNames[0],
+							params.thinking,
 						);
 						if (isolation && result.exitCode === 0) {
 							const patches = await isolation.captureDelta();
@@ -1317,6 +1336,7 @@ export default function (pi: ExtensionAPI) {
 						ctx.sessionManager,
 						undefined,
 						dispatchTrackingNames[i],
+						step.thinking || params.thinking,
 					);
 					results.push(result);
 					persistRunResults(results);
@@ -1397,6 +1417,7 @@ export default function (pi: ExtensionAPI) {
 				const results = await mapWithConcurrencyLimit(taskParams, MAX_CONCURRENCY, async (t, index) => {
 					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
 					const taskModel = t.model || params.model;
+						const taskThinking = t.thinking || params.thinking;
 					const updateParallelResult = (partial: AgentToolResult<SubagentDetails>) => {
 						if (partial.details?.results[0]) {
 							allResults[index] = partial.details.results[0];
@@ -1422,6 +1443,7 @@ export default function (pi: ExtensionAPI) {
 								ctx.sessionManager,
 								undefined,
 								dispatchTrackingNames[index],
+								taskThinking,
 							)
 						: runSingleAgent(
 								ctx.cwd,
@@ -1438,6 +1460,7 @@ export default function (pi: ExtensionAPI) {
 								ctx.sessionManager,
 								undefined,
 								dispatchTrackingNames[index],
+								taskThinking,
 							);
 					const runTask = async () => {
 						let isolation: IsolationEnvironment | null = null;
@@ -1536,6 +1559,7 @@ export default function (pi: ExtensionAPI) {
 							ctx.sessionManager,
 							undefined,
 							dispatchTrackingNames[0],
+							params.thinking,
 						)
 						: await runSingleAgent(
 							ctx.cwd,
@@ -1552,6 +1576,7 @@ export default function (pi: ExtensionAPI) {
 							ctx.sessionManager,
 							undefined,
 							dispatchTrackingNames[0],
+							params.thinking,
 						);
 					finalResults = [result];
 

package/src/resources/extensions/subagent/launch.ts

@@ -25,6 +25,8 @@ export interface SubagentLaunchInput {
 	task: string;
 	tmpPromptPath: string | null;
 	modelOverride?: string;
+	/** Reasoning effort override forwarded as `--thinking` (ADR-026 / #508). */
+	thinkingOverride?: string;
 	contextMode?: SubagentContextMode;
 	parentSessionManager?: SubagentParentSessionManager;
 	session?: SubagentSessionArgs;
@@ -60,6 +62,7 @@ export function buildSubagentProcessArgs(
 	task: string,
 	tmpPromptPath: string | null,
 	modelOverride?: string,
+	thinkingOverride?: string,
 	session: SubagentSessionArgs = { mode: "fresh" },
 ): string[] {
 	const args: string[] = ["--mode", "json", "-p"];
@@ -71,6 +74,10 @@ export function buildSubagentProcessArgs(
 	}
 	const effectiveModel = modelOverride ?? agent.model;
 	if (effectiveModel) args.push("--model", effectiveModel);
+	// Reasoning effort travels with the model (ADR-026 / #508). The child CLI
+	// validates `--thinking` and clamps to the resolved model at dispatch.
+	const effectiveThinking = thinkingOverride ?? agent.thinking;
+	if (effectiveThinking) args.push("--thinking", effectiveThinking);
 	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
 	if (tmpPromptPath) args.push("--append-system-prompt", tmpPromptPath);
 	args.push(`Task: ${task}`);
@@ -122,6 +129,7 @@ export function createSubagentLaunchPlan(input: SubagentLaunchInput): SubagentLa
 			input.task,
 			input.tmpPromptPath,
 			input.modelOverride,
+			input.thinkingOverride,
 			session,
 		),
 		env: buildSubagentProcessEnv(),

package/src/resources/extensions/subagent/tests/model-override.test.ts

@@ -53,3 +53,34 @@ describe("buildSubagentProcessArgs model override", () => {
 		assert.equal(args[modelIndex + 1], "model-override");
 	});
 });
+
+describe("buildSubagentProcessArgs thinking override (#508)", () => {
+	it("forwards thinkingOverride as --thinking", () => {
+		const args = buildSubagentProcessArgs(makeAgent(), "task", null, undefined, "low");
+		const idx = args.indexOf("--thinking");
+		assert.notEqual(idx, -1, "should include --thinking flag");
+		assert.equal(args[idx + 1], "low");
+	});
+
+	it("falls back to agent.thinking when no override provided", () => {
+		const args = buildSubagentProcessArgs(makeAgent({ thinking: "high" }), "task", null);
+		const idx = args.indexOf("--thinking");
+		assert.equal(args[idx + 1], "high");
+	});
+
+	it("override takes precedence over agent.thinking", () => {
+		const args = buildSubagentProcessArgs(makeAgent({ thinking: "high" }), "task", null, undefined, "minimal");
+		assert.equal(args[args.indexOf("--thinking") + 1], "minimal");
+	});
+
+	it("omits --thinking when neither override nor agent.thinking is set", () => {
+		const args = buildSubagentProcessArgs(makeAgent(), "task", null);
+		assert.equal(args.indexOf("--thinking"), -1, "should not include --thinking flag");
+	});
+
+	it("forwards both model and thinking together", () => {
+		const args = buildSubagentProcessArgs(makeAgent(), "task", null, "model-x", "xhigh");
+		assert.equal(args[args.indexOf("--model") + 1], "model-x");
+		assert.equal(args[args.indexOf("--thinking") + 1], "xhigh");
+	});
+});