@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.553dc518

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

@@ -51,10 +51,16 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
-import { createAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
+import { autoWorktreeBranch } from "./auto-worktree-branch-lifecycle.js";
+import { createAutoWorktree } from "./auto-worktree-creation.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
+import { checkResourcesStale } from "./auto-worktree-resource-version.js";
+import { escapeStaleWorktree } from "./auto-worktree-runtime-cleanup.js";
+import { teardownAutoWorktree } from "./auto-worktree-teardown.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
-import { createMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
+import { createDefaultMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, verifyExpectedArtifact, } from "./auto-recovery.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -1746,7 +1752,7 @@ export function buildWorktreeLifecycleDeps() {
             return new GitServiceImpl(basePath, gitConfig);
         },
         worktreeProjection: new WorktreeStateProjection(),
-        mergeMilestone: createMilestoneMergeTransaction(mergeMilestoneToMain),
+        mergeMilestone: createDefaultMilestoneMergeTransaction(),
     };
 }
 function buildLifecycle() {

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { logWarning } from "../workflow-logger.js";
 import { getWorkflowDatabaseStatus, openWorkflowDatabase, } from "../db-workspace.js";
-import { getAutoWorktreePath } from "../auto-worktree.js";
+import { getAutoWorktreePath } from "../auto-worktree-path-resolution.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { worktreesDirs } from "../worktree-placement.js";
 export function safeWorkspaceCwd() {

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -15,7 +15,7 @@ import { loadFile, saveFile, formatContinue } from "../files.js";
 import { clearAutoCompletionStopInProgress, clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, isInteractiveElicitationInFlight, markToolEnd, markToolStart, recordAutoToolSurfaceSnapshot, recordToolInvocationError, } from "../auto-runtime-state.js";
 import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, isToolUnavailableError, } from "../auto-tool-tracking.js";
 import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
-import { checkToolCallLoop, recordToolCallLoopMutation, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
+import { checkToolCallLoop, configureToolCallLoopGuard, recordToolCallLoopMutation, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { MINIMAL_AUTO_BASE_TOOL_NAMES } from "./core-session-tools.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
@@ -432,6 +432,22 @@ async function applyCompactionThresholdOverride(ctx) {
         ctx.setCompactionThresholdOverride?.(0.6);
     }
 }
+/**
+ * Apply user-tunable tool-call loop guard thresholds (#1198) from GSD
+ * preferences plus GSD_TOOL_LOOP_* env overrides. Runs at session boundaries
+ * so both interactive sessions and `/gsd auto` pick up the configuration.
+ * Non-fatal: falls back to built-in defaults when preferences cannot be loaded.
+ */
+async function applyToolCallLoopGuardConfig(basePath) {
+    try {
+        const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+        const prefs = loadEffectiveGSDPreferences(basePath);
+        configureToolCallLoopGuard(prefs?.preferences.tool_call_loop_guard);
+    }
+    catch {
+        configureToolCallLoopGuard(null);
+    }
+}
 function clearDeferredApprovalGate(basePath) {
     if (!basePath) {
         deferredApprovalGates.clear();
@@ -779,6 +795,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         resetWriteGateState(basePath);
         resetToolCallLoopGuard();
+        await applyToolCallLoopGuardConfig(basePath);
         approvalQuestionAbortInFlight = false;
         clearDeferredApprovalGate();
         await resetAskUserQuestionsTurnCache();
@@ -864,6 +881,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         initSessionNotifications(ctx);
         resetWriteGateState(basePath);
         resetToolCallLoopGuard();
+        await applyToolCallLoopGuardConfig(basePath);
         clearDeferredApprovalGate();
         await resetAskUserQuestionsTurnCache();
         clearDiscussionFlowState(basePath);

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -11,7 +11,7 @@ import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { extractIntroAndRules } from "../knowledge-parser.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
-import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
+import { getActiveAutoWorktreeContext } from "../auto-worktree-session-registry.js";
 import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-session-state.js";
 import { deriveState } from "../state.js";
 import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -21,29 +21,117 @@
  * signature, so the identical-args streak never trips, while allowing
  * tool-heavy turns that are making file-mutation progress. Whichever guard
  * trips first blocks.
+ *
+ * Thresholds, exempt tools, and enable flags are user-tunable (#1198) via the
+ * `tool_call_loop_guard` key in `.gsd/PREFERENCES.md` and `GSD_TOOL_LOOP_*`
+ * environment variables, applied through {@link configureToolCallLoopGuard}.
+ * Defaults preserve the original hardcoded behavior.
  */
 import { createHash } from "node:crypto";
 import { INHERENTLY_REPEATABLE_TOOL_SET } from "./core-session-tools.js";
 import { hasBrowserContractPrefix } from "../../shared/browser-contract.js";
 import { canonicalToolName } from "../engine-hook-contract.js";
-const MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
+/** Built-in defaults. Preserved when preferences/env do not override them. */
+const DEFAULT_MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
+const DEFAULT_PER_TOOL_DEFAULT_CAP = 6;
+const DEFAULT_PER_TOOL_REPEATABLE_CAP = 15;
+const DEFAULT_PER_TOOL_CAP_EXEMPT_TOOLS = ["find", "glob", "grep", "ls", "read", "search_and_read"];
 /** Interactive/user-facing tools where even 1 duplicate is confusing. */
 const STRICT_LOOP_TOOLS = new Set(["ask_user_questions"]);
 const MAX_CONSECUTIVE_STRICT = 1;
+const STATE_MUTATING_TOOL_SET = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
+function defaultGuardConfig() {
+    return {
+        guardEnabled: true,
+        identicalEnabled: true,
+        maxConsecutiveIdentical: DEFAULT_MAX_CONSECUTIVE_IDENTICAL_CALLS,
+        repeatedEnabled: true,
+        perToolDefaultCap: DEFAULT_PER_TOOL_DEFAULT_CAP,
+        perToolRepeatableCap: DEFAULT_PER_TOOL_REPEATABLE_CAP,
+        perToolExempt: new Set(DEFAULT_PER_TOOL_CAP_EXEMPT_TOOLS),
+    };
+}
+let config = defaultGuardConfig();
+/** Parse a positive-integer env var, returning undefined when unset/invalid. */
+function envPositiveInt(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === "")
+        return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) && n >= 1 ? Math.floor(n) : undefined;
+}
+/** Parse a boolean env var (`true`/`1` vs `false`/`0`), undefined when unset. */
+function envBool(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === "")
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === "true" || v === "1" || v === "yes" || v === "on")
+        return true;
+    if (v === "false" || v === "0" || v === "no" || v === "off")
+        return false;
+    return undefined;
+}
+/** Parse a comma-separated tool-name list env var. */
+function envToolList(name) {
+    const raw = process.env[name];
+    if (!raw)
+        return [];
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
 /**
- * Per-turn cap on calls to the SAME tool name, regardless of args (#783).
+ * Resolve preferences + environment overrides into the active configuration.
+ * Environment variables win over preferences; preferences win over built-in
+ * defaults. User-supplied exempt tools are additive to the built-in exempt
+ * set so defaults are always preserved.
  *
- * General-purpose execution tools are routinely called many times per turn
- * (touching multiple files, running several commands), so they get a higher
- * ceiling. Everything else — workflow one-shot tools (e.g. gsd_complete_milestone)
- * and any non-allowlisted tool — gets the default cap. The default is generous
- * enough to absorb legitimate retries but catches the reported improvisation
- * loop (~51 calls) well before a cost spike.
+ * Applied to both interactive sessions and `/gsd auto` (called from the
+ * session_start / session_switch hooks).
  */
-const PER_TOOL_DEFAULT_CAP = 6;
-const PER_TOOL_REPEATABLE_CAP = 15;
-const PER_TOOL_CAP_EXEMPT_TOOLS = new Set(["find", "glob", "grep", "ls", "read", "search_and_read"]);
-const STATE_MUTATING_TOOL_SET = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
+export function configureToolCallLoopGuard(prefs) {
+    const next = defaultGuardConfig();
+    if (prefs) {
+        if (typeof prefs.enabled === "boolean")
+            next.guardEnabled = prefs.enabled;
+        if (prefs.identical_args) {
+            if (typeof prefs.identical_args.enabled === "boolean")
+                next.identicalEnabled = prefs.identical_args.enabled;
+            if (typeof prefs.identical_args.max_consecutive_calls === "number" && prefs.identical_args.max_consecutive_calls >= 1) {
+                next.maxConsecutiveIdentical = Math.floor(prefs.identical_args.max_consecutive_calls);
+            }
+        }
+        if (prefs.repeated_tool) {
+            if (typeof prefs.repeated_tool.enabled === "boolean")
+                next.repeatedEnabled = prefs.repeated_tool.enabled;
+            if (typeof prefs.repeated_tool.default_cap === "number" && prefs.repeated_tool.default_cap >= 1) {
+                next.perToolDefaultCap = Math.floor(prefs.repeated_tool.default_cap);
+            }
+            if (typeof prefs.repeated_tool.repeatable_cap === "number" && prefs.repeated_tool.repeatable_cap >= 1) {
+                next.perToolRepeatableCap = Math.floor(prefs.repeated_tool.repeatable_cap);
+            }
+            for (const tool of prefs.repeated_tool.exempt_tools ?? []) {
+                if (typeof tool === "string" && tool.trim())
+                    next.perToolExempt.add(tool.trim());
+            }
+        }
+    }
+    // Environment overrides (win over preferences).
+    const envEnabled = envBool("GSD_TOOL_LOOP_GUARD_ENABLED");
+    if (envEnabled !== undefined)
+        next.guardEnabled = envEnabled;
+    const envIdenticalMax = envPositiveInt("GSD_TOOL_LOOP_IDENTICAL_MAX");
+    if (envIdenticalMax !== undefined)
+        next.maxConsecutiveIdentical = envIdenticalMax;
+    const envDefaultCap = envPositiveInt("GSD_TOOL_LOOP_REPEATED_DEFAULT_CAP");
+    if (envDefaultCap !== undefined)
+        next.perToolDefaultCap = envDefaultCap;
+    const envRepeatableCap = envPositiveInt("GSD_TOOL_LOOP_REPEATED_REPEATABLE_CAP");
+    if (envRepeatableCap !== undefined)
+        next.perToolRepeatableCap = envRepeatableCap;
+    for (const tool of envToolList("GSD_TOOL_LOOP_EXEMPT_TOOLS"))
+        next.perToolExempt.add(tool);
+    config = next;
+}
 let consecutiveCount = 0;
 let lastSignature = "";
 let lastToolName = "";
@@ -72,14 +160,17 @@ function hashToolCall(toolName, args) {
  * Returns `{ block: true, reason }` when the loop threshold is exceeded.
  *
  * Two independent guards run; whichever trips first blocks:
- *  1. Identical-signature streak (MAX_CONSECUTIVE_IDENTICAL_CALLS, strict for
+ *  1. Identical-signature streak (config.maxConsecutiveIdentical, strict for
  *     ask_user_questions).
- *  2. Per-tool-name cap (PER_TOOL_DEFAULT_CAP / PER_TOOL_REPEATABLE_CAP),
+ *  2. Per-tool-name cap (config.perToolDefaultCap / config.perToolRepeatableCap),
  *     independent of args, reset after file-mutation progress — catches
  *     improvisation loops (#783).
+ *
+ * Both guards, their thresholds, and the per-tool exempt set are user-tunable
+ * via {@link configureToolCallLoopGuard} (#1198).
  */
 export function checkToolCallLoop(toolName, args) {
-    if (!enabled)
+    if (!enabled || !config.guardEnabled)
         return { block: false, count: 0 };
     const sig = hashToolCall(toolName, args);
     if (sig === lastSignature) {
@@ -93,12 +184,14 @@ export function checkToolCallLoop(toolName, args) {
     // ── Guard 1: identical-signature streak ──
     const threshold = STRICT_LOOP_TOOLS.has(toolName)
         ? MAX_CONSECUTIVE_STRICT
-        : MAX_CONSECUTIVE_IDENTICAL_CALLS;
-    if (consecutiveCount > threshold) {
+        : config.maxConsecutiveIdentical;
+    if (config.identicalEnabled && consecutiveCount > threshold) {
         return {
             block: true,
             reason: `Tool loop detected (identical args): ${toolName} called ${consecutiveCount} times ` +
-                `with identical arguments. Blocking to prevent infinite loop. ` +
+                `with identical arguments (max ${threshold}). Blocking to prevent infinite loop. ` +
+                `Raise tool_call_loop_guard.identical_args.max_consecutive_calls in .gsd/PREFERENCES.md ` +
+                `(or GSD_TOOL_LOOP_IDENTICAL_MAX) if this is expected. ` +
                 `Do not retry this tool or call other tools this turn — stop and respond to the user in text.`,
             count: consecutiveCount,
         };
@@ -119,19 +212,23 @@ export function checkToolCallLoop(toolName, args) {
     // so the arg-independent per-tool cap misfires on legitimate verification;
     // Guard 1's identical-signature streak still catches a genuinely stuck
     // browser loop.
-    if (PER_TOOL_CAP_EXEMPT_TOOLS.has(toolName) ||
+    if (!config.repeatedEnabled ||
+        config.perToolExempt.has(toolName) ||
         hasBrowserContractPrefix(canonicalToolName(toolName))) {
         return { block: false, count: consecutiveCount };
     }
     const perToolCap = INHERENTLY_REPEATABLE_TOOL_SET.has(toolName)
-        ? PER_TOOL_REPEATABLE_CAP
-        : PER_TOOL_DEFAULT_CAP;
+        ? config.perToolRepeatableCap
+        : config.perToolDefaultCap;
     if (perToolCount > perToolCap) {
         return {
             block: true,
             reason: `Tool loop detected (repeated tool): ${toolName} called ${perToolCount} times ` +
                 `this turn (cap ${perToolCap}). Blocking to prevent infinite loop. ` +
                 `The tool may be unavailable or failing repeatedly. ` +
+                `Raise tool_call_loop_guard.repeated_tool.default_cap/repeatable_cap or add "${toolName}" ` +
+                `to tool_call_loop_guard.repeated_tool.exempt_tools in .gsd/PREFERENCES.md ` +
+                `(or GSD_TOOL_LOOP_REPEATED_* / GSD_TOOL_LOOP_EXEMPT_TOOLS) if this is expected. ` +
                 `Do not retry this tool or pivot to other tools this turn — stop and respond to the user in text.`,
             count: perToolCount,
         };

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -16,7 +16,7 @@ import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captur
 import { appendOverride, appendKnowledge } from "./files.js";
 import { formatDoctorIssuesForPrompt, formatDoctorReport, formatDoctorReportJson, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
 import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { buildClaudeRuntimeFloorAdvisory } from "../../shared/claude-runtime-floor.js";

package/dist/resources/extensions/gsd/commands-workflow-templates.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { resolveByName, autoDetect, listTemplates, getTemplateInfo, loadWorkflowTemplate, loadRegistry, isLegacyWorkflowMode, } from "./workflow-templates.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { createGitService, runGit } from "./git-service.js";
+import { createGitService, runGit, taskBranchArgs } from "./git-service.js";
 import { isAutoActive, isAutoPaused } from "./auto.js";
 import { getErrorMessage } from "./error-utils.js";
 import { resolvePlugin } from "./workflow-plugins.js";
@@ -349,7 +349,7 @@ export async function handleStart(args, ctx, pi) {
                     git.autoCommit("workflow-template", templateId, []);
                 }
                 catch { /* nothing to commit */ }
-                runGit(basePath, ["checkout", "-b", branchName]);
+                runGit(basePath, taskBranchArgs(basePath, branchName, current, git.getMainBranch()));
                 branchCreated = true;
             }
         }
@@ -481,7 +481,7 @@ export function dispatchMarkdownPhasePlugin(plugin, description, ctx, pi) {
                     git.autoCommit("workflow-template", templateId, []);
                 }
                 catch { /* nothing to commit */ }
-                runGit(basePath, ["checkout", "-b", branchName]);
+                runGit(basePath, taskBranchArgs(basePath, branchName, current, git.getMainBranch()));
                 branchCreated = true;
             }
         }

package/dist/resources/extensions/gsd/db/queries.js

@@ -218,7 +218,7 @@ export function getMilestone(id) {
 export function getActiveMilestoneFromDb() {
     if (!getDbOrNull())
         return null;
-    const row = getDbOrNull().prepare("SELECT * FROM milestones WHERE status NOT IN ('complete', 'done', 'skipped', 'closed', 'parked') ORDER BY id LIMIT 1").get();
+    const row = getDbOrNull().prepare(`SELECT * FROM milestones WHERE status NOT IN (${TERMINAL_STATUS_SQL}, 'parked') ORDER BY id LIMIT 1`).get();
     if (!row)
         return null;
     return rowToMilestone(row);
@@ -230,11 +230,11 @@ export function getActiveSliceFromDb(milestoneId) {
     // Uses json_each() to expand the JSON depends array and checks each dep is complete.
     const row = getDbOrNull().prepare(`SELECT s.* FROM slices s
      WHERE s.milestone_id = :mid
-       AND s.status NOT IN ('complete', 'done', 'skipped')
+       AND s.status NOT IN (${TERMINAL_STATUS_SQL})
        AND NOT EXISTS (
          SELECT 1 FROM json_each(s.depends) AS dep
          WHERE dep.value NOT IN (
-           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done', 'skipped')
+           SELECT id FROM slices WHERE milestone_id = :mid AND status IN (${TERMINAL_STATUS_SQL})
          )
        )
      ORDER BY s.sequence, s.id
@@ -246,7 +246,7 @@ export function getActiveSliceFromDb(milestoneId) {
 export function getActiveTaskFromDb(milestoneId, sliceId) {
     if (!getDbOrNull())
         return null;
-    const row = getDbOrNull().prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN ('complete', 'done') ORDER BY sequence, id LIMIT 1").get({ ":mid": milestoneId, ":sid": sliceId });
+    const row = getDbOrNull().prepare(`SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN (${TERMINAL_STATUS_SQL}) ORDER BY sequence, id LIMIT 1`).get({ ":mid": milestoneId, ":sid": sliceId });
     if (!row)
         return null;
     return rowToTask(row);
@@ -265,7 +265,7 @@ export function getParallelMonitorSliceProgress(milestoneId) {
        s.id AS id,
        s.status AS status,
        COUNT(t.id) AS total,
-       COALESCE(SUM(CASE WHEN t.status='complete' THEN 1 ELSE 0 END), 0) AS done
+       COALESCE(SUM(CASE WHEN t.status IN (${TERMINAL_STATUS_SQL}) THEN 1 ELSE 0 END), 0) AS done
      FROM slices s
      LEFT JOIN tasks t ON s.milestone_id=t.milestone_id AND s.id=t.slice_id
      WHERE s.milestone_id=:mid
@@ -417,7 +417,7 @@ export function getSliceScopedArtifacts(milestoneId, sliceId) {
 export function getActiveMilestoneIdFromDb() {
     if (!getDbOrNull())
         return null;
-    const row = getDbOrNull().prepare("SELECT id, status FROM milestones WHERE status NOT IN ('complete', 'done', 'skipped', 'closed', 'parked') ORDER BY id LIMIT 1").get();
+    const row = getDbOrNull().prepare(`SELECT id, status FROM milestones WHERE status NOT IN (${TERMINAL_STATUS_SQL}, 'parked') ORDER BY id LIMIT 1`).get();
     if (!row)
         return null;
     return rowToIdStatusSummary(row);
@@ -432,7 +432,7 @@ export function getSliceStatusSummary(milestoneId) {
 export function getActiveTaskIdFromDb(milestoneId, sliceId) {
     if (!getDbOrNull())
         return null;
-    const row = getDbOrNull().prepare("SELECT id, status, title FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN ('complete', 'done') ORDER BY sequence, id LIMIT 1").get({ ":mid": milestoneId, ":sid": sliceId });
+    const row = getDbOrNull().prepare(`SELECT id, status, title FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN (${TERMINAL_STATUS_SQL}) ORDER BY sequence, id LIMIT 1`).get({ ":mid": milestoneId, ":sid": sliceId });
     if (!row)
         return null;
     return rowToActiveTaskSummary(row);
@@ -443,8 +443,8 @@ export function getSliceTaskCounts(milestoneId, sliceId) {
         return emptyTaskStatusCounts();
     const row = getDbOrNull().prepare(`SELECT
        COUNT(*) as total,
-       SUM(CASE WHEN status IN ('complete', 'done') THEN 1 ELSE 0 END) as done,
-       SUM(CASE WHEN status NOT IN ('complete', 'done') THEN 1 ELSE 0 END) as pending
+       SUM(CASE WHEN status IN (${TERMINAL_STATUS_SQL}) THEN 1 ELSE 0 END) as done,
+       SUM(CASE WHEN status NOT IN (${TERMINAL_STATUS_SQL}) THEN 1 ELSE 0 END) as pending
      FROM tasks WHERE milestone_id = :mid AND slice_id = :sid`).get({ ":mid": milestoneId, ":sid": sliceId });
     return rowToTaskStatusCounts(row);
 }

package/dist/resources/extensions/gsd/doctor-engine-checks.js

@@ -3,7 +3,7 @@ import { isAbsolute, join, relative, sep } from "node:path";
 import { deleteArtifactByPath, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, isMemoriesFtsAvailable, repairTaskCompletionFromSummary, _getAdapter, } from "./gsd-db.js";
 import { MEMORIES_FTS_REBUILT_KEY } from "./db-memory-fts-schema.js";
 import { isAfter, latestExplicitReopenAt } from "./milestone-reopen-events.js";
-import { gsdProjectionRoot, gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "./paths.js";
+import { buildTaskFileName, gsdProjectionRoot, gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, } from "./paths.js";
 import { deriveState } from "./state.js";
 import { isClosedStatus } from "./status-guards.js";
 import { workflowEventLogPath } from "./workflow-event-ledger.js";
@@ -12,6 +12,7 @@ import { flushWorkflowProjections } from "./projection-flush.js";
 import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { parsePlan } from "./parsers-legacy.js";
 import { parseSummary } from "./files.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 const USER_AUTHORED_ARTIFACT_TYPES = new Set(["CONTEXT", "RESEARCH"]);
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -113,10 +114,10 @@ function isClearedByMilestoneShellProjectionFlush(basePath, issue, reRenderedMil
         return false;
     return issue.file === relativeFile(basePath, roadmapPath);
 }
-function artifactExistsOnDisk(basePath, artifactPath) {
-    return resolveArtifactDiskPath(basePath, artifactPath) !== null;
+function artifactExistsOnDisk(basePath, artifactPath, row) {
+    return resolveArtifactDiskPath(basePath, artifactPath, row) !== null;
 }
-function resolveArtifactDiskPath(basePath, artifactPath) {
+function resolveLiteralArtifactDiskPath(basePath, artifactPath) {
     const relativeArtifactPath = artifactPathRelativeToGsd(artifactPath);
     if (isAbsolute(relativeArtifactPath)) {
         return existsSync(relativeArtifactPath) ? relativeArtifactPath : null;
@@ -128,6 +129,48 @@ function resolveArtifactDiskPath(basePath, artifactPath) {
     }
     return null;
 }
+function relativeToGsdRoot(basePath, diskPath) {
+    for (const root of [gsdProjectionRoot(basePath), gsdRoot(basePath)]) {
+        if (!isPathInside(root, diskPath))
+            continue;
+        return relative(root, diskPath).split("\\").join("/");
+    }
+    return null;
+}
+function isFlatPhaseDiskPath(basePath, diskPath) {
+    return relativeToGsdRoot(basePath, diskPath)?.startsWith(`${LAYOUT_SEGMENTS.level1}/`) ?? false;
+}
+function hasFlatPhaseLayout(basePath) {
+    return existsSync(join(gsdProjectionRoot(basePath), LAYOUT_SEGMENTS.level1));
+}
+function resolveFlatPhaseArtifactDiskPath(basePath, row) {
+    if (!hasFlatPhaseLayout(basePath))
+        return null;
+    if (!row.milestone_id)
+        return null;
+    const artifactType = normalizedArtifactType(row.artifact_type);
+    if (!artifactType)
+        return null;
+    if (row.slice_id && row.task_id) {
+        const phaseDir = resolveMilestonePath(basePath, row.milestone_id);
+        if (!phaseDir || !isFlatPhaseDiskPath(basePath, phaseDir))
+            return null;
+        const candidate = join(phaseDir, buildTaskFileName(row.task_id, artifactType));
+        return existsSync(candidate) ? candidate : null;
+    }
+    const candidate = row.slice_id
+        ? resolveSliceFile(basePath, row.milestone_id, row.slice_id, artifactType)
+        : resolveMilestoneFile(basePath, row.milestone_id, artifactType);
+    return candidate && isFlatPhaseDiskPath(basePath, candidate) ? candidate : null;
+}
+function resolveArtifactDiskPath(basePath, artifactPath, row) {
+    if (row && isMilestonesArtifactPath(row.path)) {
+        const flatPath = resolveFlatPhaseArtifactDiskPath(basePath, row);
+        if (flatPath)
+            return flatPath;
+    }
+    return resolveLiteralArtifactDiskPath(basePath, artifactPath);
+}
 function taskExistsInPlan(basePath, milestoneId, sliceId, taskId) {
     const planPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN");
     if (!planPath || !existsSync(planPath))
@@ -156,7 +199,7 @@ function readTaskCompletionEvidenceFromSummary(basePath, row) {
     if (!row.task_status && Number(row.task_count) > 0 && !taskExistsInPlan(basePath, row.milestone_id, row.slice_id, row.task_id)) {
         return null;
     }
-    const diskPath = resolveArtifactDiskPath(basePath, row.path);
+    const diskPath = resolveArtifactDiskPath(basePath, row.path, { ...row, artifact_type: "SUMMARY" });
     if (!diskPath)
         return null;
     try {
@@ -256,6 +299,43 @@ function hasPresentMilestonesReplacement(basePath, row, artifactRows) {
         sameArtifactIdentity(row, other) &&
         artifactExistsOnDisk(basePath, other.path));
 }
+function hasPresentFlatPhaseReplacement(basePath, row, artifactRows) {
+    if (resolveFlatPhaseArtifactDiskPath(basePath, row))
+        return true;
+    return artifactRows.some((other) => other.path !== row.path &&
+        !isMilestonesArtifactPath(other.path) &&
+        sameArtifactIdentity(row, other) &&
+        artifactExistsOnDisk(basePath, other.path, other));
+}
+function hasNoFlatPhaseFileEquivalent(row) {
+    const artifactType = normalizedArtifactType(row.artifact_type);
+    if (row.slice_id && row.task_id) {
+        return artifactType === "PLAN" || artifactType === "SUMMARY";
+    }
+    return Boolean(row.slice_id && !row.task_id && artifactType === "SUMMARY");
+}
+function staleMilestonesArtifactRowFixable(basePath, row, artifactRows) {
+    if (!isMilestonesArtifactPath(row.path))
+        return false;
+    if (!hasFlatPhaseLayout(basePath))
+        return false;
+    if (hasPresentFlatPhaseReplacement(basePath, row, artifactRows))
+        return true;
+    return hasNoFlatPhaseFileEquivalent(row) && !resolveLiteralArtifactDiskPath(basePath, row.path);
+}
+function stalePhasesArtifactRowFixable(basePath, row, artifactRows) {
+    const issuePath = artifactPathRelativeToGsd(row.path);
+    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) && hasPresentMilestonesReplacement(basePath, row, artifactRows);
+}
+function staleArtifactRowFixable(basePath, row, artifactRows) {
+    return staleMilestonesArtifactRowFixable(basePath, row, artifactRows) ||
+        stalePhasesArtifactRowFixable(basePath, row, artifactRows);
+}
+function staleArtifactPruneMessage(row) {
+    return isMilestonesArtifactPath(row.path)
+        ? `pruned stale legacy artifact row ${row.path}`
+        : `pruned stale flat-phase artifact row ${row.path}`;
+}
 export async function checkEngineHealth(basePath, issues, fixesApplied, options) {
     const dbPath = resolveGsdPathContract(basePath).projectDb;
     if (!isDbAvailable() && existsSync(dbPath)) {
@@ -456,18 +536,20 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
              ORDER BY path`)
                     .all();
                 for (const row of artifactRows) {
-                    if (artifactExistsOnDisk(basePath, row.path))
-                        continue;
                     const unitId = artifactUnitId(row);
                     const issuePath = artifactPathRelativeToGsd(row.path);
-                    if (options?.repair && issuePath.startsWith("phases/") && hasPresentMilestonesReplacement(basePath, row, artifactRows)) {
+                    if (artifactExistsOnDisk(basePath, row.path))
+                        continue;
+                    if (options?.repair && staleArtifactRowFixable(basePath, row, artifactRows)) {
                         // Route the write through the Single Writer owner (gsd-db.ts) instead
                         // of issuing raw DELETE SQL here — doctor is a read-only consumer and
                         // the single-writer invariant forbids write SQL outside the allowlist.
                         deleteArtifactByPath(row.path);
-                        fixesApplied.push(`pruned stale flat-phase artifact row ${row.path}`);
+                        fixesApplied.push(staleArtifactPruneMessage(row));
                         continue;
                     }
+                    if (artifactExistsOnDisk(basePath, row.path, row))
+                        continue;
                     if (isUserAuthoredArtifactType(row.artifact_type)) {
                         const artifactType = normalizedArtifactType(row.artifact_type);
                         missingUserContentArtifacts.push({ path: issuePath, artifactType });
@@ -489,7 +571,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
                         unitId,
                         message: `Artifact ${issuePath} is recorded in the database as ${row.artifact_type || "UNKNOWN"} but no matching file exists on disk`,
                         file: issuePath,
-                        fixable: issuePath.startsWith("phases/") && hasPresentMilestonesReplacement(basePath, row, artifactRows),
+                        fixable: staleArtifactRowFixable(basePath, row, artifactRows),
                     });
                 }
             }
@@ -518,7 +600,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
                     .all();
                 const seen = new Set();
                 for (const row of rows) {
-                    if (!artifactExistsOnDisk(basePath, row.path))
+                    if (!artifactExistsOnDisk(basePath, row.path, row))
                         continue;
                     const reopenAt = latestExplicitReopenAt(basePath, row.milestone_id);
                     if (!isAfter(row.imported_at, reopenAt))

package/dist/resources/extensions/gsd/flat-phase-migration.js

@@ -4,7 +4,7 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { renderAllFromDb, renderRoadmapFromDb } from "./markdown-renderer.js";
-import { getAllMilestones, getMilestoneSlices } from "./gsd-db.js";
+import { deleteArtifactsByPathPrefix, getAllMilestones, getMilestoneSlices } from "./gsd-db.js";
 import { migrateFromMarkdown } from "./md-importer.js";
 import { countDbHierarchy } from "./migration-auto-check.js";
 import { logWarning } from "./workflow-logger.js";
@@ -163,7 +163,8 @@ export function pruneStaleFlatPhaseBackups(basePath) {
  * 2. Rename .gsd/milestones/ aside so path resolvers target phases/
  * 3. Render flat-phase from the DB (which already has the data)
  * 4. Verify counts match
- * 5. Remove the renamed legacy tree
+ * 5. Prune legacy milestones/ artifact rows
+ * 6. Remove the renamed legacy tree
  *
  * Idempotent: if .gsd/milestones/ doesn't exist, returns immediately.
  */
@@ -262,7 +263,17 @@ export async function migrateToFlatPhase(basePath) {
         rollbackPartialMigration(basePath, backupDir, migratingPath);
         throw new Error("flat-phase migration verification failed: no artifacts rendered");
     }
-    // 6. Verified — remove the renamed legacy tree (backup already on disk).
+    // 6. Verified — prune legacy artifact rows now that renderAllFromDb has
+    // re-inserted flat-phase rows for artifacts that still have files.
+    try {
+        deleteArtifactsByPathPrefix("milestones/");
+    }
+    catch (err) {
+        logWarning("migration", `flat-phase migration could not prune legacy artifact rows: ${err.message}`);
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw err;
+    }
+    // 7. Remove the renamed legacy tree (backup already on disk).
     try {
         removePathWithRetries(migratingPath);
     }

package/dist/resources/extensions/gsd/forensics.js

@@ -24,7 +24,7 @@ import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
 import { isDbAvailable, getHierarchyCompletionCounts } from "./gsd-db.js";
 import { formatDuration } from "../shared/format-utils.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { clearGSDPreferencesCache, loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { showNextAction } from "../shared/tui.js";
 import { isInteractiveCommandContext, notifyForensicsNeedsInteractiveMenu, } from "./command-feedback.js";

package/dist/resources/extensions/gsd/git-conflict-resolve.js

@@ -2,8 +2,8 @@
 // File Purpose: Shared auto-resolution of safe merge conflict paths.
 import { logWarning } from "./workflow-logger.js";
 import { nativeAddPaths, nativeCheckoutTheirs, nativeRmForce, } from "./native-git-bridge.js";
-import { isSafeToAutoResolve } from "./auto-worktree.js";
-export { isSafeToAutoResolve } from "./auto-worktree.js";
+import { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
+export { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
 /**
  * Auto-resolve paths that are safe to accept from the milestone side
  * (.gsd/ state and build artifacts).