@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -2,8 +2,11 @@
 // File Purpose: State manifest snapshot and restore orchestration for GSD workflow data.
 import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.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";
 // ─── helpers ─────────────────────────────────────────────────────────────
 function requireDb() {
     const db = _getAdapter();
@@ -30,10 +33,24 @@ export function toNumeric(value, fallback = null) {
     }
     return fallback;
 }
+function mergeDecisionSurfaces(legacyDecisions, memoryDecisions) {
+    const byId = new Map();
+    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
@@ -44,6 +61,32 @@ export function snapshotState() {
     // 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();
+        const requirements = rawRequirements.map((r) => ({
+            id: r["id"],
+            class: r["class"] ?? "",
+            status: r["status"] ?? "",
+            description: r["description"] ?? "",
+            why: r["why"] ?? "",
+            source: r["source"] ?? "",
+            primary_owner: r["primary_owner"] ?? "",
+            supporting_slices: r["supporting_slices"] ?? "",
+            validation: r["validation"] ?? "",
+            notes: r["notes"] ?? "",
+            full_content: r["full_content"] ?? "",
+            superseded_by: r["superseded_by"] ?? null,
+        }));
+        const rawArtifacts = db.prepare("SELECT * FROM artifacts ORDER BY path").all();
+        const artifacts = rawArtifacts.map((r) => ({
+            path: r["path"],
+            artifact_type: r["artifact_type"] ?? "",
+            milestone_id: r["milestone_id"] ?? null,
+            slice_id: r["slice_id"] ?? null,
+            task_id: r["task_id"] ?? null,
+            full_content: r["full_content"] ?? "",
+            imported_at: r["imported_at"] ?? "",
+            content_hash: r["content_hash"] ?? null,
+        }));
         const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id").all();
         const milestones = rawMilestones.map((r) => ({
             id: r["id"],
@@ -124,7 +167,7 @@ export function snapshotState() {
             escalation_override_applied_at: r["escalation_override_applied_at"] ?? null,
         }));
         const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
-        const decisions = rawDecisions.map((r) => ({
+        const legacyDecisions = rawDecisions.map((r) => ({
             seq: toNumeric(r["seq"], 0),
             id: r["id"],
             when_context: r["when_context"] ?? "",
@@ -137,6 +180,42 @@ export function snapshotState() {
             source: r["source"] ?? "discussion",
             superseded_by: r["superseded_by"] ?? null,
         }));
+        const decisions = mergeDecisionSurfaces(legacyDecisions, getAllDecisionsFromMemories());
+        const rawReplanHistory = db.prepare("SELECT * FROM replan_history ORDER BY id").all();
+        const replan_history = rawReplanHistory.map((r) => ({
+            id: toNumeric(r["id"], 0),
+            milestone_id: r["milestone_id"] ?? "",
+            slice_id: r["slice_id"] ?? null,
+            task_id: r["task_id"] ?? null,
+            summary: r["summary"] ?? "",
+            previous_artifact_path: r["previous_artifact_path"] ?? null,
+            replacement_artifact_path: r["replacement_artifact_path"] ?? null,
+            created_at: r["created_at"] ?? "",
+        }));
+        const rawAssessments = db.prepare("SELECT * FROM assessments ORDER BY path").all();
+        const assessments = rawAssessments.map((r) => ({
+            path: r["path"],
+            milestone_id: r["milestone_id"] ?? "",
+            slice_id: r["slice_id"] ?? null,
+            task_id: r["task_id"] ?? null,
+            status: r["status"] ?? "",
+            scope: r["scope"] ?? "",
+            full_content: r["full_content"] ?? "",
+            created_at: r["created_at"] ?? "",
+        }));
+        const rawQualityGates = db.prepare("SELECT * FROM quality_gates ORDER BY milestone_id, slice_id, gate_id, task_id").all();
+        const quality_gates = rawQualityGates.map((r) => ({
+            milestone_id: r["milestone_id"],
+            slice_id: r["slice_id"],
+            gate_id: r["gate_id"],
+            scope: r["scope"],
+            task_id: r["task_id"] ?? "",
+            status: r["status"],
+            verdict: r["status"] === "pending" ? null : r["verdict"],
+            rationale: r["rationale"] ?? "",
+            findings: r["findings"] ?? "",
+            evaluated_at: r["evaluated_at"] ?? null,
+        }));
         const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all();
         const verification_evidence = rawEvidence.map((r) => ({
             id: r["id"],
@@ -149,14 +228,31 @@ export function snapshotState() {
             duration_ms: toNumeric(r["duration_ms"]),
             created_at: r["created_at"],
         }));
+        const rawCommitAttributions = db.prepare("SELECT * FROM milestone_commit_attributions ORDER BY milestone_id, commit_sha").all();
+        const milestone_commit_attributions = rawCommitAttributions.map((r) => ({
+            commit_sha: r["commit_sha"],
+            milestone_id: r["milestone_id"],
+            slice_id: r["slice_id"] ?? null,
+            task_id: r["task_id"] ?? null,
+            source: r["source"] ?? "recorded",
+            confidence: toNumeric(r["confidence"], 1),
+            files_json: r["files_json"] ?? "[]",
+            created_at: r["created_at"] ?? "",
+        }));
         const result = {
             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;
     });
@@ -192,17 +288,45 @@ export function readManifest(basePath) {
     if (parsed.version !== 1) {
         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"]) {
+        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) {
+    return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
+}
+function artifactProjectionPath(basePath, artifactPath) {
+    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, manifest) {
+    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) {
@@ -211,5 +335,8 @@ export function bootstrapFromManifest(basePath) {
         return false;
     }
     restoreManifest(manifest);
+    restoreArtifactProjections(basePath, manifest);
+    backfillDecisionsToMemories();
+    invalidateAllCaches();
     return true;
 }

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -409,10 +409,9 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
         return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
     }
     const uniqueRequired = [...new Set(requiredTools)];
-    const piRuntimeRequired = uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     const missing = (options.activeTools && options.activeTools.length > 0)
-        ? piRuntimeRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools))
-        : piRuntimeRequired;
+        ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools))
+        : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     if (missing.length === 0)
         return null;
     if (options.activeTools && options.activeTools.length > 0) {

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -482,6 +482,14 @@ export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileTy
     if (existsSync(filePath)) {
         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/dist/resources/extensions/gsd/worktree-manager.js

@@ -185,6 +185,32 @@ export function resolveCanonicalMilestoneRoot(basePath, milestoneId) {
     }
     return wtPath;
 }
+/**
+ * Build human-facing guidance for manually validating a milestone's work.
+ *
+ * When a milestone runs in a git worktree, its checkout lives under the hidden
+ * `.gsd/worktrees/<MID>/` path that a human can't easily discover. The UAT
+ * pause/handoff and the saved assessment use this to tell the human exactly
+ * where to `cd` to run or inspect the app before signing off on NEEDS-HUMAN
+ * checks, rather than leaving them to hunt for a buried path.
+ *
+ * Returns null when no milestone id is available.
+ */
+export function buildManualValidationGuidance(basePath, milestoneId, opts = {}) {
+    if (!milestoneId)
+        return null;
+    const validationRoot = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+    const inWorktree = validationRoot.includes(`${sep}.gsd${sep}worktrees${sep}`);
+    const lines = [`Validate the work here: ${validationRoot}`];
+    if (inWorktree) {
+        lines.push("This milestone runs in a git worktree, so the code lives under the hidden " +
+            `\`.gsd/worktrees/\` path. Open it with: cd "${validationRoot}"`);
+    }
+    if (opts.uatPath) {
+        lines.push(`Follow the UAT checklist at: ${opts.uatPath}`);
+    }
+    return lines.join("\n");
+}
 // ─── Core Operations ───────────────────────────────────────────────────────
 /**
  * Create a new git worktree under .gsd/worktrees/<name>/ with branch worktree/<name>.

package/dist/resources/extensions/gsd/worktree-reentry.js

@@ -0,0 +1,96 @@
+// Project/App: gsd-pi
+// File Purpose: Deterministically re-enter the active milestone's worktree on a
+// cold start (after /quit + relaunch). Without this, Claude Code relaunches with
+// cwd at the project root, and a bare /gsd leaves the agent there — forcing it to
+// search the filesystem ("git worktree list", branch sniffing) to find its way
+// back into the worktree. The worktree path is fully derivable from state, so we
+// resolve and chdir into it directly instead.
+import { readdirSync } from "node:fs";
+import { enterAutoWorktree, getAutoWorktreePath } from "./auto-worktree.js";
+import { getIsolationMode } from "./preferences.js";
+import { worktreesDir } from "./worktree-manager.js";
+import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
+/**
+ * Enumerate the live (valid git) auto-worktrees under <projectRoot>/.gsd/worktrees/.
+ * Reuses getAutoWorktreePath's validation so stray directories are ignored.
+ */
+function liveMilestoneWorktrees(projectRoot) {
+    let names;
+    try {
+        names = readdirSync(worktreesDir(projectRoot));
+    }
+    catch {
+        return [];
+    }
+    const live = [];
+    for (const id of names) {
+        const path = getAutoWorktreePath(projectRoot, id);
+        if (path)
+            live.push({ id, path });
+    }
+    return live;
+}
+/**
+ * If we're sitting at the project root with worktree isolation enabled and the
+ * active milestone has a live worktree, chdir into it. No-op when already inside
+ * a worktree, when isolation is off, or when the target is ambiguous.
+ *
+ * Single live worktree → enter it (covers the common case without deriveState).
+ * Multiple live worktrees → disambiguate by the active milestone from state;
+ * if that can't be resolved unambiguously, do nothing.
+ *
+ * Best-effort: any failure resolves to a no-op so it can never block startup.
+ *
+ * @returns the worktree path entered, or null when nothing was done.
+ */
+export async function reenterActiveWorktreeIfNeeded(basePath, opts = {}) {
+    let projectRoot;
+    try {
+        projectRoot = resolveWorktreeProjectRoot(basePath);
+    }
+    catch {
+        return null;
+    }
+    // Only worktree-isolation projects have worktrees to re-enter.
+    if (getIsolationMode(projectRoot) !== "worktree")
+        return null;
+    // Already inside a worktree (warm session, or auto-mode already entered) —
+    // nothing to do.
+    let cwd;
+    try {
+        cwd = process.cwd();
+    }
+    catch {
+        return null;
+    }
+    if (isGsdWorktreePath(cwd))
+        return null;
+    const live = liveMilestoneWorktrees(projectRoot);
+    if (live.length === 0)
+        return null;
+    let target = live.length === 1 ? live[0] : null;
+    if (!target) {
+        // Multiple live worktrees — disambiguate by the active milestone.
+        try {
+            const { deriveState } = await import("./state.js");
+            const state = await deriveState(projectRoot);
+            const activeId = state.activeMilestone?.id;
+            target = activeId ? live.find((w) => w.id === activeId) ?? null : null;
+        }
+        catch {
+            target = null;
+        }
+    }
+    if (!target)
+        return null;
+    try {
+        const entered = enterAutoWorktree(projectRoot, target.id);
+        opts.notify?.(`Resumed in worktree for ${target.id}.`);
+        return entered;
+    }
+    catch {
+        // Worktree vanished or chdir failed — leave cwd as-is, caller falls back to
+        // the project root.
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -100,28 +100,26 @@ function forceOverwriteAssessmentsWithVerdict(srcMilestoneDir, dstMilestoneDir)
         logWarning("worktree", `assessment sync failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-function syncTopLevelMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir) {
+function syncOtherMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir, currentMilestoneId) {
     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) {
@@ -199,9 +197,12 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
     safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { 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
     // ASSESSMENT files are special: after run-uat writes a verdict and post-unit

package/dist/resources/extensions/shared/gsd-browser-cli.js

@@ -115,6 +115,10 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
         ? resolveBundledGsdBrowserCliPath(env)
         : null;
     const sessionName = options.sessionName?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot, options.sessionSuffix);
+    // Stable per-project identity key (no per-session suffix) so the browser
+    // profile/cookies persist across pi sessions for the same project. gsd-browser
+    // rejects --identity-scope unless --identity-key is also supplied.
+    const identityKey = env.GSD_BROWSER_IDENTITY_KEY?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot);
     const command = explicitCommand
         || explicitCliPath
         || (preferPathCli ? "gsd-browser" : undefined)
@@ -129,6 +133,8 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
             sessionName,
             "--identity-scope",
             "project",
+            "--identity-key",
+            identityKey,
             "--identity-project",
             resolvedProjectRoot,
         ];

package/dist/resources/extensions/subagent/agents.js

@@ -64,6 +64,7 @@ function loadAgentsFromDir(dir, source) {
             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/dist/resources/extensions/subagent/index.js

@@ -301,7 +301,10 @@ function formatRunRecord(record) {
         lines.push(`Failure: ${record.failure.message}`);
     return lines.join("\n");
 }
-async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode = "fresh", parentSessionManager, sessionOverride, trackingName) {
+async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode = "fresh", parentSessionManager, sessionOverride, trackingName, 
+// Trailing param (kept after trackingName so existing positional call sites
+// don't shift). Reasoning effort forwarded to the child (#508).
+thinkingOverride) {
     const agent = agents.find((a) => a.name === agentName);
     if (!agent) {
         const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
@@ -368,6 +371,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             task,
             tmpPromptPath,
             modelOverride,
+            thinkingOverride,
             contextMode,
             parentSessionManager,
             session: sessionOverride,
@@ -441,10 +445,12 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             }
     }
 }
-async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode = "fresh", parentSessionManager, sessionOverride, trackingName) {
+async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride, contextMode = "fresh", parentSessionManager, sessionOverride, trackingName, 
+// Trailing param (see runSingleAgent). Reasoning effort forwarded to the child (#508).
+thinkingOverride) {
     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 = null;
     let tmpPromptPath = null;
@@ -487,7 +493,7 @@ async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defau
             ? await cmuxClient.createSplit(directionOrSurfaceId)
             : 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);
         const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
@@ -496,6 +502,7 @@ async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defau
             task,
             tmpPromptPath,
             modelOverride,
+            thinkingOverride,
             contextMode,
             parentSessionManager,
             session: sessionOverride,
@@ -520,7 +527,7 @@ async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defau
         ].join("; ");
         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);
         if (!finished) {
@@ -583,11 +590,16 @@ async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defau
             }
     }
 }
+const ThinkingLevelSchema = StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"], {
+    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"], {
         description: 'Context mode for this task (see context field on the top-level params).',
         default: "fresh",
@@ -598,6 +610,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"], {
         description: 'Context mode for this step (see context field on the top-level params).',
         default: "fresh",
@@ -629,6 +642,7 @@ const SubagentParams = Type.Object({
     confirmProjectAgents: Type.Optional(Type.Boolean({ description: "Prompt before running project-local agents. Default: false.", default: false })),
     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: "Run the subagent in an isolated filesystem (git worktree). " +
             "Changes are captured as patches and merged back. " +
@@ -749,7 +763,7 @@ export default function (pi) {
                         isError: true,
                     };
                 }
-                const result = await runSingleAgent(ctx.cwd, agents, selected.agent, followUp, selected.cwd, undefined, signal, onUpdate, makeDetails("single"), params.model, "fresh", ctx.sessionManager, { mode: "fork", sessionFile: selected.sessionFile, sessionDir: path.dirname(selected.sessionFile) }, selected.trackingName);
+                const result = await runSingleAgent(ctx.cwd, agents, selected.agent, followUp, selected.cwd, undefined, signal, onUpdate, makeDetails("single"), params.model, "fresh", 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)" }],
                     details: makeDetails("single")([result]),
@@ -1017,7 +1031,7 @@ export default function (pi) {
                             const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, undefined, (partial) => {
                                 if (partial.details?.results[0])
                                     persistRunResults([partial.details.results[0]]);
-                            }, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0]);
+                            }, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking);
                             if (isolation && result.exitCode === 0) {
                                 const patches = await isolation.captureDelta();
                                 if (patches.length > 0) {
@@ -1073,7 +1087,7 @@ export default function (pi) {
                                 }
                             }
                         };
-                        const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, signal, chainUpdate, makeDetails("chain"), step.model || params.model, step.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[i]);
+                        const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, signal, chainUpdate, makeDetails("chain"), step.model || params.model, step.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[i], step.thinking || params.thinking);
                         results.push(result);
                         persistRunResults(results);
                         const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
@@ -1145,6 +1159,7 @@ export default function (pi) {
                     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) => {
                             if (partial.details?.results[0]) {
                                 allResults[index] = partial.details.results[0];
@@ -1153,8 +1168,8 @@ export default function (pi) {
                             }
                         };
                         const executeOnce = (runCwd) => cmuxSplitsEnabled
-                            ? runSingleAgentInCmuxSplit(cmuxClient, gridSurfaces[index] ?? (index % 2 === 0 ? "right" : "down"), ctx.cwd, agents, t.agent, t.task, runCwd, undefined, signal, updateParallelResult, makeDetails("parallel"), taskModel, t.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[index])
-                            : runSingleAgent(ctx.cwd, agents, t.agent, t.task, runCwd, undefined, signal, updateParallelResult, makeDetails("parallel"), taskModel, t.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[index]);
+                            ? runSingleAgentInCmuxSplit(cmuxClient, gridSurfaces[index] ?? (index % 2 === 0 ? "right" : "down"), ctx.cwd, agents, t.agent, t.task, runCwd, undefined, signal, updateParallelResult, makeDetails("parallel"), taskModel, t.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[index], taskThinking)
+                            : runSingleAgent(ctx.cwd, agents, t.agent, t.task, runCwd, undefined, signal, updateParallelResult, makeDetails("parallel"), taskModel, t.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[index], taskThinking);
                         const runTask = async () => {
                             let isolation = null;
                             const effectiveCwd = t.cwd ?? ctx.cwd;
@@ -1232,8 +1247,8 @@ export default function (pi) {
                                 onUpdate(partial);
                         };
                         const result = cmuxSplitsEnabled
-                            ? await runSingleAgentInCmuxSplit(cmuxClient, "right", ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0])
-                            : await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0]);
+                            ? await runSingleAgentInCmuxSplit(cmuxClient, "right", ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking)
+                            : await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking);
                         finalResults = [result];
                         // Capture and merge delta if isolated
                         if (isolation) {

package/dist/resources/extensions/subagent/launch.js

@@ -17,7 +17,7 @@ export function buildShellEnvAssignments(env = process.env) {
     const value = env[SUBAGENT_CHILD_ENV_VAR];
     return value ? [`${SUBAGENT_CHILD_ENV_VAR}=${JSON.stringify(value)}`] : [];
 }
-export function buildSubagentProcessArgs(agent, task, tmpPromptPath, modelOverride, session = { mode: "fresh" }) {
+export function buildSubagentProcessArgs(agent, task, tmpPromptPath, modelOverride, thinkingOverride, session = { mode: "fresh" }) {
     const args = ["--mode", "json", "-p"];
     if (session.mode === "fork") {
         args.push("--session", session.sessionFile);
@@ -30,6 +30,11 @@ export function buildSubagentProcessArgs(agent, task, tmpPromptPath, modelOverri
     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)
@@ -69,7 +74,7 @@ export function resolveSubagentSessionArgs(contextMode = "fresh", parentSessionM
 export function createSubagentLaunchPlan(input) {
     const session = input.session ?? resolveSubagentSessionArgs(input.contextMode ?? "fresh", input.parentSessionManager);
     return {
-        args: buildSubagentProcessArgs(input.agent, input.task, input.tmpPromptPath, input.modelOverride, session),
+        args: buildSubagentProcessArgs(input.agent, input.task, input.tmpPromptPath, input.modelOverride, input.thinkingOverride, session),
         env: buildSubagentProcessEnv(),
         cwd: input.cwd ?? input.defaultCwd,
         session,

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-9y3LeeR2uGr2yRj9RjY3D
+tJOKQbQRO-9MiFDO8DIDS