@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.4fb2d460

package/README.md

@@ -28,16 +28,16 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.4.0**
-
-- **models:** Add Claude Sonnet 5.
-- **Added:** Add Hermes plugin installer.
-- **compat:** Report .planning/ drift in /gsd sync and doctor.
-- **compat:** Project to .planning/ inside renderAllFromDb.
-- **compat:** Add external-planning-edit drift handler.
-- **compat:** Add DB → .planning/ projection writer.
-- **compat:** Extract .planning/ layout detector.
-- **compat:** Extend marker schema 1→2 with planning field.
+Latest release: **v1.5.0**
+
+- **hermes:** Add /gsd new-milestone command for chat-driven milestone creation (#1162).
+- **gsd:** Make CODEBASE.md workspace-aware in parent mode.
+- **gsd:** Doctor probe + validation for parent-workspace repos.
+- **gsd:** Surface per-repo git health in /gsd status + document limits.
+- **gsd:** Wire repository assignment into slice/task planning.
+- **gsd:** Add parent-workspace discovery UX + document nested-only layout.
+- **provider:** Add Cursor Agent provider.
+- **gsd:** Make workspace.mode parent behavioral (mode contract).
 
 <!-- release-highlights:end -->
 

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-f30abebf080db301
+dc6f7673892b74e1

package/dist/resources/extensions/ask-user-questions.js

@@ -209,7 +209,7 @@ export default function AskUserQuestions(pi) {
             "For single-select: each question must have 2-3 options. Put the recommended option first with '(Recommended)' suffix. Do not include an 'Other' or 'None of the above' option - the client adds one automatically.",
             "For multi-select: set allowMultiple: true. The user can pick any number of options. No 'None of the above' is added.",
             "When options involve code patterns, config choices, or architecture decisions, add a 'preview' field with markdown content (code blocks, lists, headers, etc.). The preview renders in a side-by-side panel when the option is highlighted.",
-            "Preview content is rendered in a fixed-height panel (max ~20 lines visible). Keep previews concise — show the most relevant snippet, not exhaustive examples. Longer content is truncated with a '+N lines hidden' indicator.",
+            "Preview content is rendered in a fixed-height panel (max ~20 lines visible). Keep previews concise — show the most relevant snippet, not exhaustive examples. Longer content stays fully accessible: the user scrolls it with PgUp/PgDn, with '▲/▼ N more' indicators marking hidden rows.",
         ],
         parameters: AskUserQuestionsParams,
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/dist/resources/extensions/gsd/auto/closeout.js

@@ -1,12 +1,17 @@
 // Project/App: gsd-pi
 // File Purpose: Auto-loop closeout, milestone report, and merge helpers.
 import { importExtensionModule } from "@gsd/pi-coding-agent";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { join, basename } from "node:path";
+import { readFileSync } from "node:fs";
 import { MergeConflictError } from "../git-service.js";
 import { findUnmergedCompletedMilestones } from "../unmerged-milestone-guard.js";
 import { getIsolationMode } from "../preferences.js";
 import { isDbAvailable, getMilestone } from "../gsd-db.js";
 import { refreshWorkflowDatabaseFromDisk } from "../db-workspace.js";
 import { isClosedStatus } from "../status-guards.js";
+import { PLANNING_ARTIFACT_SUFFIXES } from "../paths.js";
 import { logWarning, logError } from "../workflow-logger.js";
 import { debugLog } from "../debug-logger.js";
 import { _resolveReportBasePath } from "./phase-helpers.js";
@@ -51,7 +56,15 @@ export async function restorePreflightStashOrStop(ic, preflight, milestoneId) {
  */
 export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, options = {}) {
     const { ctx, pi, s, deps } = ic;
-    const projectRoot = s.originalBasePath || s.basePath;
+    // Resolve the project root once, before the merge can flip session path
+    // pointers (worktree teardown mutates s.basePath / s.scope). The guarded
+    // merge's preflight/postflight stash restore, the pre-merge ignored-markdown
+    // snapshot, the dirty-projection check, and the rebuild must all target this
+    // same tree; otherwise `.gsd` markdown restored on one tree can be silently
+    // overwritten by a rebuild on another. canonicalProjectRoot is the
+    // authoritative `.gsd`/DB writer path (see AutoSession.canonicalProjectRoot).
+    const projectRoot = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
+    const ignoredProjectionSnapshot = snapshotIgnoredGsdMarkdownProjections(projectRoot);
     const mergeResult = deps.lifecycle.exitMilestone(milestoneId, {
         merge: true,
         guardedMerge: {
@@ -61,11 +74,11 @@ export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, option
         },
     }, ctx.ui);
     if (mergeResult.ok) {
-        await markMilestoneMergedAndRebuild(s);
+        await markMilestoneMergedAndRebuild(s, projectRoot, ignoredProjectionSnapshot);
         return null;
     }
     if (mergeResult.reason === "postflight-stash-restore-failed") {
-        await markMilestoneMergedAndRebuild(s);
+        await markMilestoneMergedAndRebuild(s, projectRoot, ignoredProjectionSnapshot);
     }
     if (mergeResult.reason === "preflight-dirty-overlap" || mergeResult.reason === "preflight-unmerged-conflicts") {
         const reason = mergeResult.reason === "preflight-unmerged-conflicts"
@@ -122,10 +135,13 @@ export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, option
     }
     return null;
 }
-async function markMilestoneMergedAndRebuild(s) {
+async function markMilestoneMergedAndRebuild(s, rebuildBasePath, ignoredProjectionSnapshot) {
     s.milestoneMergedInPhases = true;
+    if (hasDirtyGsdMarkdownProjections(rebuildBasePath, ignoredProjectionSnapshot)) {
+        logWarning("engine", "skipping markdown projection rebuild after milestone merge because restored .gsd edits are dirty");
+        return;
+    }
     try {
-        const rebuildBasePath = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
         const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
         await rebuildMarkdownProjectionsFromDb(rebuildBasePath);
     }
@@ -133,6 +149,82 @@ async function markMilestoneMergedAndRebuild(s) {
         logWarning("engine", `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function hasDirtyGsdMarkdownProjections(basePath, ignoredProjectionSnapshot) {
+    try {
+        const output = execFileSync("git", ["status", "--porcelain", "-z", "--untracked-files=all", "--", ".gsd"], { cwd: basePath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const entries = output.split("\0").filter(Boolean);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (entry.length <= 3)
+                continue;
+            const status = entry.slice(0, 2);
+            const path = entry.slice(3);
+            if (isGeneratedGsdMarkdownProjection(path))
+                return true;
+            if ((status === "R " || status === "C ") && i + 1 < entries.length) {
+                const dest = entries[++i];
+                if (isGeneratedGsdMarkdownProjection(dest))
+                    return true;
+            }
+        }
+    }
+    catch (err) {
+        void err;
+        // Fall through to ignored-file snapshot comparison below.
+    }
+    return ignoredGsdMarkdownProjectionSnapshotChanged(basePath, ignoredProjectionSnapshot);
+}
+function isGeneratedGsdMarkdownProjection(path) {
+    const normalized = path.replace(/\\/g, "/");
+    if (normalized === ".gsd/DECISIONS.md")
+        return true;
+    if (!normalized.startsWith(".gsd/milestones/") && !normalized.startsWith(".gsd/phases/")) {
+        return false;
+    }
+    return isGeneratedPlanningArtifactFileName(basename(normalized));
+}
+function isGeneratedPlanningArtifactFileName(fileName) {
+    if (!fileName.endsWith(".md"))
+        return false;
+    const stem = fileName.slice(0, -".md".length).toUpperCase();
+    for (const suffix of PLANNING_ARTIFACT_SUFFIXES) {
+        if (!stem.endsWith(`-${suffix}`))
+            continue;
+        const idPrefix = stem.slice(0, -suffix.length - 1);
+        return /^(?:[MST]\d+|\d{2,})(?:-[A-Z0-9]+)*$/.test(idPrefix);
+    }
+    return false;
+}
+function snapshotIgnoredGsdMarkdownProjections(basePath) {
+    try {
+        const output = execFileSync("git", ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", ".gsd"], { cwd: basePath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const snapshot = new Map();
+        for (const path of output.split("\0")) {
+            if (!isGeneratedGsdMarkdownProjection(path))
+                continue;
+            snapshot.set(path, hashFile(join(basePath, path)));
+        }
+        return snapshot;
+    }
+    catch {
+        return null;
+    }
+}
+function hashFile(path) {
+    return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function ignoredGsdMarkdownProjectionSnapshotChanged(basePath, before) {
+    if (!before)
+        return true;
+    const after = snapshotIgnoredGsdMarkdownProjections(basePath);
+    if (!after || after.size !== before.size)
+        return true;
+    for (const [path, hash] of before) {
+        if (after.get(path) !== hash)
+            return true;
+    }
+    return false;
+}
 export async function _runMilestoneMergeOnceWithStashRestore(ic, milestoneId, options = {}) {
     if (ic.s.milestoneMergedInPhases) {
         debugLog("autoLoop", {

package/dist/resources/extensions/gsd/auto/orchestrator.js

@@ -21,7 +21,8 @@ import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { repairAutoWorktreeSafetyFailure } from "../auto-worktree-repair.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { preDispatchHealthGate, recordHealthSnapshot, } from "../doctor-proactive.js";
-import { checkResourcesStale, autoWorktreeBranch, mergeMilestoneToMain } from "../auto-worktree.js";
+import { autoWorktreeBranch } from "../auto-worktree-branch-lifecycle.js";
+import { checkResourcesStale } from "../auto-worktree-resource-version.js";
 import { getSessionLockStatus } from "../session-lock.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { emitJournalEvent as _emitJournalEvent } from "../journal.js";
@@ -31,7 +32,7 @@ import { getPriorSliceCompletionBlocker } from "../dispatch-guard.js";
 import { GitServiceImpl } from "../git-service.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { WorktreeLifecycle } from "../worktree-lifecycle.js";
-import { createMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
+import { createDefaultMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
 import { createWorkspace, scopeMilestone } from "../workspace.js";
 import { supportsStructuredQuestions } from "../workflow-mcp.js";
 import { getRegisteredToolSnapshot, getToolBaselineSnapshot } from "../auto-model-selection.js";
@@ -560,7 +561,7 @@ export class AutoOrchestrator {
                 return new GitServiceImpl(basePath, gitConfig);
             },
             worktreeProjection: new WorktreeStateProjection(),
-            mergeMilestone: createMilestoneMergeTransaction(mergeMilestoneToMain),
+            mergeMilestone: createDefaultMilestoneMergeTransaction(),
         });
     }
     rebuildScope(rawPath, milestoneId) {

package/dist/resources/extensions/gsd/auto/pre-dispatch.js

@@ -345,7 +345,8 @@ export async function runPreDispatch(ic, loopState) {
             if (stop)
                 return stop;
         }
-        // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+        // PR creation (auto_pr) is handled by the publication handoff in
+        // the milestone merge transaction (#2302).
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.canonicalProjectRoot);
         mid = state.activeMilestone?.id;
@@ -430,7 +431,8 @@ export async function runPreDispatch(ic, loopState) {
                 const stop = await _runMilestoneMergeOnceWithStashRestore(ic, s.currentMilestoneId);
                 if (stop)
                     return stop;
-                // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+                // PR creation (auto_pr) is handled by the publication handoff in
+                // the milestone merge transaction (#2302).
             }
             const unmappedActive = countUnmappedActiveRequirements();
             const completionStopReason = formatCompletePhaseNextAction(unmappedActive);
@@ -506,7 +508,8 @@ export async function runPreDispatch(ic, loopState) {
             const stop = await _runMilestoneMergeOnceWithStashRestore(ic, s.currentMilestoneId);
             if (stop)
                 return stop;
-            // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+            // PR creation (auto_pr) is handled by the publication handoff in
+            // the milestone merge transaction (#2302).
         }
         deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone", basename(s.originalBasePath || s.basePath));
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");

package/dist/resources/extensions/gsd/auto/unit-phase.js

@@ -17,7 +17,7 @@ import { isDbAvailable, getTask } from "../gsd-db.js";
 import { parseUnitId } from "../unit-id.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
-import { getUnitWorkflowDispatchReadinessError } from "../tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "../tool-contract.js";
 import { prepareWorkflowMcpForProject } from "../workflow-mcp-auto-prep.js";
 import { applyThinkingLevelForModel, floorThinkingLevelForUnit, } from "../auto-model-selection.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
@@ -246,17 +246,13 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentDispatchedModelId = s.currentUnitModel
         ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
         : null;
-    const compatibilityError = getUnitWorkflowDispatchReadinessError({
-        provider: s.currentUnitModel?.provider ?? ctx.model?.provider,
+    const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+        model: s.currentUnitModel,
+        fallbackModel: ctx.model,
+        getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
         projectRoot: s.basePath,
         surface: "auto-mode",
         unitType,
-        authMode: s.currentUnitModel?.provider
-            ? ctx.modelRegistry.getProviderAuthMode(s.currentUnitModel.provider)
-            : ctx.model?.provider
-                ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
-                : undefined,
-        baseUrl: s.currentUnitModel?.baseUrl ?? ctx.model?.baseUrl,
         activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     const workflowMcpPrepModel = s.currentUnitModel;

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -8,7 +8,7 @@
 import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { existsSync } from "node:fs";
 function resolveMilestoneArtifactPath(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
@@ -193,8 +193,17 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
                 ?? resolveSlicePath(base, mid, sid);
             if (!slicePath || !tid)
                 return null;
-            const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-            return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
+            // Legacy layout: slice dirs live under slices/<SID>/ and task summaries
+            // live in a tasks/ subdir. Flat-phase layout: slicePath IS the phase dir
+            // and task summaries live beside the plan files at the phase root. A
+            // tasks/ subdir may still exist in flat-phase for auxiliary task-scoped
+            // artifacts (e.g. T01-VERIFY.json gate outputs) — its mere existence must
+            // NOT redirect summary resolution into tasks/ (#1208).
+            const isLegacySlice = basename(dirname(slicePath)) === "slices";
+            const summaryDir = isLegacySlice
+                ? (resolveTasksDir(base, mid, sid) ?? slicePath)
+                : slicePath;
+            return join(summaryDir, buildTaskFileName(tid, "SUMMARY"));
         }
         case "complete-slice": {
             return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -7,10 +7,10 @@ import { loadFile } from "./files.js";
 import { isDbAvailable, getClosedSliceIds } from "./gsd-db.js";
 import { resolveSliceFile, relSliceFile, } from "./paths.js";
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
 export function parseDirectDispatchPhase(raw) {
     const tokens = raw.trim().split(/\s+/).filter(Boolean);
     if (tokens.length === 0)
@@ -213,13 +213,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
             ctx.ui.notify(`Unknown phase "${phase}". Valid phases: research, plan, execute, complete, validate, reassess, uat, replan.`, "warning");
             return;
     }
-    const compatibilityError = getUnitWorkflowDispatchReadinessError({
-        provider: ctx.model?.provider,
+    const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+        model: ctx.model,
+        getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
         projectRoot,
         surface: "direct phase dispatch",
         unitType,
-        authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
-        baseUrl: ctx.model?.baseUrl,
         activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     if (compatibilityError) {
@@ -232,5 +231,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
         ctx.ui.notify("Session creation cancelled.", "warning");
         return;
     }
-    pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
+    // Inject the configured response language into the dispatched prompt content
+    // — the new session's system prompt does not carry the preferences block, so
+    // the language setting would otherwise never reach the unit (#1210).
+    const languageDirective = renderLanguageDirectiveForPrompt(loadEffectiveGSDPreferences(dispatchBase)?.preferences);
+    const dispatchContent = languageDirective ? `${languageDirective}\n\n${prompt}` : prompt;
+    pi.sendMessage({ customType: "gsd-dispatch", content: dispatchContent, display: false }, { triggerTurn: true });
 }

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -1,5 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
+import { renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { getUatBrowserToolSupportError } from "./uat-policy.js";
 import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, getSliceRunUatAssessment, } from "./gsd-db.js";
@@ -1500,6 +1501,19 @@ export const DISPATCH_RULES = [
     },
 ];
 import { getRegistry } from "./rule-registry.js";
+/**
+ * Prepend the configured response-language directive to a dispatched unit
+ * prompt so auto-execution units respond in the language set in PREFERENCES.md
+ * (#1210). No-op for non-dispatch actions or when no language is configured.
+ */
+function applyLanguageDirectiveToDispatch(action, prefs) {
+    if (action.action !== "dispatch" || !action.prompt)
+        return action;
+    const directive = renderLanguageDirectiveForPrompt(prefs);
+    if (!directive)
+        return action;
+    return { ...action, prompt: `${directive}\n\n${action.prompt}` };
+}
 // ─── Resolver ─────────────────────────────────────────────────────────────
 /**
  * Evaluate dispatch rules in order. Returns the first matching action,
@@ -1551,7 +1565,7 @@ export async function resolveDispatch(ctx) {
                 level: "error",
             };
         }
-        return action;
+        return applyLanguageDirectiveToDispatch(action, ctx.prefs);
     }
     catch (err) {
         // Registry not initialized — fall back to inline loop
@@ -1572,7 +1586,7 @@ export async function resolveDispatch(ctx) {
                     matchedRule: rule.name,
                 };
             }
-            return action;
+            return applyLanguageDirectiveToDispatch(action, ctx.prefs);
         }
     }
     // No rule matched — unhandled phase.

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -149,12 +149,56 @@ export function refreshRecoveryDbForArtifact(unitType, unitId, basePath) {
         };
     }
     if (!isClosedStatus(task.status)) {
-        return {
-            ok: false,
-            fatal: true,
-            reason: "execute-task-artifact-db-mismatch",
-            message: `Stuck recovery found execute-task ${unitId} artifacts, but the DB task status is still '${task.status}' after refresh.`,
-        };
+        // The artifact was already confirmed on disk by verifyExpectedArtifact
+        // upstream (Gate 1 accepts a checked disk checkbox as proof of completion),
+        // but the DB task row is still open. A bare refreshWorkflowDatabaseFromDisk
+        // never promotes the disk checkbox into task status (the checkbox is
+        // rendered *from* the DB, never *into* it), so this divergence can never
+        // self-heal. Promote the task to align the DB with disk instead of failing
+        // shut — otherwise the lowest-pending derivation re-picks the same task
+        // forever and execute-task hard-stops with "state did not advance" (#1204).
+        // Mirrors the promotion pattern used by the context-exhaustion and
+        // reactive-execute-blocker recovery paths.
+        const ts = new Date().toISOString();
+        // Only the DB promotion is load-bearing: if it throws, nothing advanced
+        // and failing shut is correct. The plan checkbox rewrite and cache clears
+        // are best-effort follow-ups — a throw there must NOT abort recovery, or
+        // the DB is left complete without ever emitting the stuck-artifact-recovery
+        // event (#1221), stranding worktree reconciliation.
+        try {
+            updateTaskStatus(mid, sid, tid, "complete", ts);
+        }
+        catch (e) {
+            return {
+                ok: false,
+                fatal: true,
+                reason: "execute-task-artifact-db-promote-failed",
+                message: `Stuck recovery found execute-task ${unitId} artifacts, but promoting the DB task status from '${task.status}' failed: ${getErrorMessage(e)}`,
+            };
+        }
+        try {
+            const artifactBase = resolveArtifactVerificationBase(unitId, basePath);
+            const planPath = resolveExpectedArtifactPath("plan-slice", `${mid}/${sid}`, artifactBase);
+            if (planPath && existsSync(planPath)) {
+                const planContent = readFileSync(planPath, "utf-8");
+                const updatedPlan = planContent.replace(new RegExp(`^(\\s*-\\s+)\\[ \\]\\s+\\*\\*${tid}:`, "m"), `$1[x] **${tid}:`);
+                if (updatedPlan !== planContent) {
+                    atomicWriteSync(planPath, updatedPlan);
+                }
+            }
+            clearPathCache();
+            clearParseCache();
+        }
+        catch (e) {
+            logWarning("recovery", `stuck-artifact plan checkbox sync failed after DB promotion of ${unitId}: ${getErrorMessage(e)}`);
+        }
+        // Append event so worktree reconciliation can replay this recovery completion.
+        try {
+            appendEvent(basePath, { cmd: "complete-task", params: { milestoneId: mid, sliceId: sid, taskId: tid }, ts, actor: "system", trigger_reason: "stuck-artifact-recovery" });
+        }
+        catch (e) {
+            logWarning("recovery", `appendEvent failed for stuck-artifact task promotion: ${getErrorMessage(e)}`);
+        }
     }
     return { ok: true };
 }

package/dist/resources/extensions/gsd/auto-start.js

@@ -27,9 +27,10 @@ import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchList, nativeBranchExists, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, nativeHasChanges, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { checkoutBranchWithStashGuard } from "./worktree-git-recovery.js";
-import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
+import { cleanStaleRuntimeUnits } from "./auto-worktree-runtime-cleanup.js";
+import { readResourceVersion } from "./auto-worktree-resource-version.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
 import { queryJournal } from "./journal.js";
@@ -1409,7 +1410,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         // Snapshot installed skills
         if (resolveSkillDiscoveryMode(base) !== "off") {
-            snapshotSkills();
+            snapshotSkills({ cwd: s.basePath });
         }
         setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);