@opengsd/gsd-pi 1.2.0-dev.b1abb545 → 1.2.0-dev.fb12b103

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -11,8 +11,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, saveGateResult, getPendingGatesForTurn, getMilestoneSlices, updateMilestoneStatus, } from "../gsd-db.js";
+import { completeSliceCascade, setSliceSummaryMd, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
 import { getGatesForTurn } from "../gate-registry.js";
 import { gsdProjectionRoot, clearPathCache, resolveMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
@@ -295,52 +294,34 @@ export async function handleCompleteSlice(params, basePath) {
             error: `UAT requires browser verification (opening a page in a browser, navigating to a page or localhost, screenshots) but declares "UAT mode: artifact-driven", which only runs static/file checks and would defer the browser work to a human. Use a mode that actually verifies the UI: "browser-executable" (interactive browser tools), "runtime-executable" (a browser test command such as playwright), or a browser-inclusive "mixed"/"live-runtime". Re-author the UAT Type section and complete the slice again.`,
         };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
+    // ── Atomic completion cascade (guards + writes in one transaction) ───────
     const completedAt = new Date().toISOString();
     let guardError = null;
     let existingSummaryMd = "";
     let duplicateComplete = false;
-    transaction(() => {
-        // State machine preconditions (inside txn for atomicity).
-        // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
-        // Only block if they exist and are closed.
-        const milestone = getMilestone(params.milestoneId);
-        if (milestone && isClosedStatus(milestone.status)) {
-            guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
-            return;
-        }
-        const slice = getSlice(params.milestoneId, params.sliceId);
-        existingSummaryMd = slice?.full_summary_md?.trim() ?? "";
-        if (slice && isClosedStatus(slice.status)) {
-            duplicateComplete = true;
-            return;
-        }
-        // Verify all tasks are complete
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        if (tasks.length === 0) {
-            guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
-            return;
-        }
-        const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
-        if (incompleteTasks.length > 0) {
-            const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
-            guardError = `incomplete tasks: ${incompleteIds}`;
-            return;
-        }
-        // All guards passed — perform writes. Preserve existing planning metadata:
-        // completion should not overwrite title/risk/depends/demo/sequence.
-        insertMilestone({ id: params.milestoneId, title: params.milestoneId });
-        if (!slice) {
-            insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceTitle || params.sliceId });
-        }
-        updateSliceStatus(params.milestoneId, params.sliceId, "complete", completedAt);
-        const updatedSlices = getMilestoneSlices(params.milestoneId);
-        if (milestone?.status === "planned" &&
-            updatedSlices.length > 0 &&
-            updatedSlices.every((s) => isClosedStatus(s.status))) {
-            updateMilestoneStatus(params.milestoneId, "active");
-        }
+    const outcome = completeSliceCascade(params.milestoneId, params.sliceId, {
+        sliceTitle: params.sliceTitle,
+        completedAt,
     });
+    if (outcome.ok) {
+        existingSummaryMd = outcome.existingSummaryMd;
+        duplicateComplete = outcome.duplicate;
+    }
+    else {
+        switch (outcome.reason) {
+            case "milestone-closed":
+                guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${outcome.status})`;
+                break;
+            case "no-tasks":
+                guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
+                break;
+            case "incomplete-tasks": {
+                const incompleteIds = outcome.incomplete.map((t) => `${t.id} (status: ${t.status})`).join(", ");
+                guardError = `incomplete tasks: ${incompleteIds}`;
+                break;
+            }
+        }
+    }
     if (duplicateComplete) {
         const staleSummaryPath = sliceSummaryPath(artifactBasePath, params.milestoneId, params.sliceId);
         const duplicateIsStale = isStaleWrite("complete-slice");

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -4,6 +4,7 @@ import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { isContextModeEnabled } from "../preferences-types.js";
+import { projectRootFromWorktreePath } from "../worktree-root.js";
 import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 const UAT_EXEC_INTENTS = [
     "uat-artifact-check",
@@ -141,14 +142,10 @@ function normalizeScanPath(value) {
 }
 function parseWorktreeBase(baseDir) {
     const normalizedBase = normalizeScanPath(baseDir);
-    const marker = "/.gsd/worktrees/";
-    const markerIndex = normalizedBase.indexOf(marker);
-    if (markerIndex <= 0)
+    const originalRoot = projectRootFromWorktreePath(normalizedBase);
+    if (!originalRoot)
         return null;
-    return {
-        originalRoot: normalizedBase.slice(0, markerIndex),
-        worktreeRoot: normalizedBase,
-    };
+    return { originalRoot, worktreeRoot: normalizedBase };
 }
 function pathInside(parent, target) {
     const parentWithSep = parent.endsWith("/") ? parent : `${parent}/`;
@@ -234,7 +231,7 @@ function scriptReferencesOriginalRootFromWorktree(script, baseDir) {
         return false;
     const normalizedScript = script.replace(/\\/g, "/");
     return comparablePathVariants(parsed.originalRoot).some((originalRoot) => {
-        const originalRootPattern = new RegExp(`${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd/worktrees(?:/|$)))`);
+        const originalRootPattern = new RegExp(`${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd(?:-worktrees|/worktrees)(?:/|$)))`);
         return originalRootPattern.test(normalizedScript);
     });
 }
@@ -345,6 +342,7 @@ function formatResult(result) {
             exit_code: result.exit_code,
             signal: result.signal,
             timed_out: result.timed_out,
+            force_resolved: result.force_resolved,
             duration_ms: result.duration_ms,
             stdout_bytes: result.stdout_bytes,
             stderr_bytes: result.stderr_bytes,
@@ -358,6 +356,10 @@ function formatResult(result) {
     };
 }
 function formatExit(result) {
+    // force_resolved means a non-closing (D-state) child was force-resolved past its
+    // hard deadline rather than observed exiting; distinguish it from a clean timeout.
+    if (result.force_resolved)
+        return "timeout(force-killed)";
     if (result.timed_out)
         return "timeout";
     if (result.signal)

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -12,7 +12,8 @@ import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
-import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
+import { runTaskPathChecks } from "../pre-execution-checks.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "../repository-registry.js";
@@ -193,11 +194,16 @@ function validateTaskPathsBeforePersist(params, basePath, defaultTargets, allowe
     const additionalRoots = allowedRoots
         .map((root) => resolve(root))
         .filter((root) => root !== baseRoot);
-    const context = additionalRoots.length > 0 ? { additionalRoots } : undefined;
-    const checks = [
-        ...checkFilePathConsistency(taskRows, basePath, context),
-        ...checkTaskOrdering(taskRows, basePath, context),
-    ];
+    const resolvedCanonicalRoot = resolve(resolveWorktreeProjectRoot(basePath));
+    const canonicalProjectRoot = resolvedCanonicalRoot !== baseRoot ? resolvedCanonicalRoot : undefined;
+    const hasContext = additionalRoots.length > 0 || canonicalProjectRoot !== undefined;
+    const context = hasContext
+        ? {
+            ...(additionalRoots.length > 0 ? { additionalRoots } : {}),
+            ...(canonicalProjectRoot !== undefined ? { canonicalProjectRoot } : {}),
+        }
+        : undefined;
+    const checks = runTaskPathChecks(taskRows, basePath, context);
     const blocking = checks.filter((check) => !check.passed && check.blocking);
     if (blocking.length === 0)
         return null;

package/dist/resources/extensions/gsd/tools/reopen-milestone.js

@@ -7,9 +7,8 @@
  * artifacts so the DB-filesystem reconciler does not auto-correct
  * entities back to "complete".
  */
-import { getMilestone, getMilestoneSlices, getSliceTasks, reopenMilestoneStatus, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getMilestoneSlices, getSliceTasks, reopenMilestoneCascade, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -23,35 +22,18 @@ export async function handleReopenMilestone(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    let guardError = null;
-    let slicesResetCount = 0;
-    let tasksResetCount = 0;
-    transaction(() => {
-        const milestone = getMilestone(params.milestoneId);
-        if (!milestone) {
-            guardError = `milestone not found: ${params.milestoneId}`;
-            return;
+    // ── Atomic reopen cascade (guards + writes in one transaction) ───────────
+    const outcome = reopenMilestoneCascade(params.milestoneId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "milestone-not-found":
+                return { error: `milestone not found: ${params.milestoneId}` };
+            case "milestone-not-closed":
+                return { error: `milestone ${params.milestoneId} is not closed (status: ${outcome.status}) — nothing to reopen` };
         }
-        if (!isClosedStatus(milestone.status)) {
-            guardError = `milestone ${params.milestoneId} is not closed (status: ${milestone.status}) — nothing to reopen`;
-            return;
-        }
-        reopenMilestoneStatus(params.milestoneId);
-        const slices = getMilestoneSlices(params.milestoneId);
-        slicesResetCount = slices.length;
-        for (const slice of slices) {
-            updateSliceStatus(params.milestoneId, slice.id, "in_progress");
-            const tasks = getSliceTasks(params.milestoneId, slice.id);
-            tasksResetCount += tasks.length;
-            for (const task of tasks) {
-                updateTaskStatus(params.milestoneId, slice.id, task.id, "pending");
-            }
-        }
-    });
-    if (guardError) {
-        return { error: guardError };
     }
+    const slicesResetCount = outcome.slicesReset;
+    const tasksResetCount = outcome.tasksReset;
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────

package/dist/resources/extensions/gsd/tools/reopen-slice.js

@@ -9,9 +9,8 @@
  */
 // GSD — reopen-slice tool handler
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-import { getMilestone, getSlice, getSliceTasks, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getSliceTasks, reopenSliceCascade, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -27,39 +26,21 @@ export async function handleReopenSlice(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    let guardError = null;
-    let tasksResetCount = 0;
-    transaction(() => {
-        const milestone = getMilestone(params.milestoneId);
-        if (!milestone) {
-            guardError = `milestone not found: ${params.milestoneId}`;
-            return;
+    // ── Atomic reopen cascade (guards + writes in one transaction) ───────────
+    const outcome = reopenSliceCascade(params.milestoneId, params.sliceId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "milestone-not-found":
+                return { error: `milestone not found: ${params.milestoneId}` };
+            case "milestone-closed":
+                return { error: `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${outcome.status})` };
+            case "slice-not-found":
+                return { error: `slice not found: ${params.milestoneId}/${params.sliceId}` };
+            case "slice-not-complete":
+                return { error: `slice ${params.sliceId} is not complete (status: ${outcome.status}) — nothing to reopen` };
         }
-        if (isClosedStatus(milestone.status)) {
-            guardError = `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
-            return;
-        }
-        const slice = getSlice(params.milestoneId, params.sliceId);
-        if (!slice) {
-            guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
-            return;
-        }
-        if (!isClosedStatus(slice.status)) {
-            guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
-            return;
-        }
-        // Fetch tasks inside txn so the list is consistent with the slice status check
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        tasksResetCount = tasks.length;
-        updateSliceStatus(params.milestoneId, params.sliceId, "in_progress");
-        for (const task of tasks) {
-            updateTaskStatus(params.milestoneId, params.sliceId, task.id, "pending");
-        }
-    });
-    if (guardError) {
-        return { error: guardError };
     }
+    const tasksResetCount = outcome.tasksReset;
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────

package/dist/resources/extensions/gsd/tools/skip-slice.js

@@ -9,8 +9,7 @@
  * This function performs DB writes only. The MCP wrapper in
  * bootstrap/db-tools.ts handles state-cache invalidation and STATE.md rebuild.
  */
-import { getSlice, getSliceTasks, isDbAvailable, transaction, updateSliceStatus, updateTaskStatus, } from "../gsd-db.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isDbAvailable, skipSliceCascade, } from "../gsd-db.js";
 /**
  * Mark a slice as "skipped" and cascade the skip to every non-closed task in
  * that slice. Runs as a single transaction so slice status and task statuses
@@ -39,40 +38,23 @@ export function handleSkipSlice(params) {
     if (!isDbAvailable()) {
         throw new Error("handleSkipSlice: GSD database is not available");
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ────
-    let guardError = null;
-    let guardCode = null;
-    let wasAlreadySkipped = false;
-    let tasksSkipped = 0;
-    transaction(() => {
-        const slice = getSlice(params.milestoneId, params.sliceId);
-        if (!slice) {
-            guardError = `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`;
-            guardCode = "slice_not_found";
-            return;
+    // ── Atomic skip cascade (guards + writes in one transaction) ────────────
+    const outcome = skipSliceCascade(params.milestoneId, params.sliceId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "slice-not-found":
+                return {
+                    ...base,
+                    error: `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`,
+                    errorCode: "slice_not_found",
+                };
+            case "slice-already-complete":
+                return {
+                    ...base,
+                    error: `Slice ${params.sliceId} is already complete — cannot skip.`,
+                    errorCode: "already_complete",
+                };
         }
-        if (slice.status === "complete" || slice.status === "done") {
-            guardError = `Slice ${params.sliceId} is already complete — cannot skip.`;
-            guardCode = "already_complete";
-            return;
-        }
-        wasAlreadySkipped = slice.status === "skipped";
-        if (!wasAlreadySkipped) {
-            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
-        }
-        // Cascade: mark every non-closed task as skipped so milestone completion
-        // doesn't trip the deep-task guard (#4375). Closed tasks (complete/done/
-        // skipped) are left untouched — we never downgrade.
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        for (const task of tasks) {
-            if (!isClosedStatus(task.status)) {
-                updateTaskStatus(params.milestoneId, params.sliceId, task.id, "skipped");
-                tasksSkipped++;
-            }
-        }
-    });
-    if (guardError) {
-        return { ...base, error: guardError, errorCode: guardCode ?? undefined };
     }
-    return { ...base, tasksSkipped, wasAlreadySkipped };
+    return { ...base, tasksSkipped: outcome.tasksSkipped, wasAlreadySkipped: outcome.wasAlreadySkipped };
 }

package/dist/resources/extensions/gsd/uat-policy.js

@@ -1,5 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Central UAT mode policy for dispatch, tool presentation, and result validation.
+import { hasBrowserContractPrefix } from "../shared/browser-contract.js";
 import { extractUatType } from "./files.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
 import { parseMcpToolName } from "./mcp-tool-name.js";
@@ -84,7 +85,7 @@ export function uatTypeIncludesBrowser(uatType) {
 export function isUatBrowserToolName(toolName) {
     const parsed = parseMcpToolName(toolName);
     const canonicalName = parsed?.toolName ?? toolName;
-    if (canonicalName.startsWith("browser_"))
+    if (hasBrowserContractPrefix(canonicalName))
         return true;
     return parsed?.toolName === "*" && parsed.serverName.toLowerCase().includes("browser");
 }

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

@@ -11,7 +11,7 @@ import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
-import { getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
 /**
  * Undo the last completed unit: revert git commits,
@@ -275,20 +275,21 @@ export async function handleResetSlice(args, ctx, _pi, basePath) {
             `Run /gsd reset-slice ${rawId} --force to confirm.`, "warning");
         return;
     }
-    // Reset all tasks
-    let tasksReset = 0;
+    // Reset all task statuses to "pending" and the slice to "active" in one
+    // atomic commit (DB is source of truth). Previously a per-task updateTaskStatus
+    // loop + a separate updateSliceStatus, which could leave a partial reset if
+    // interrupted mid-loop.
+    resetSliceCascade(mid, sid);
+    // Delete task summary files — projection cleanup, separate from the DB reset.
+    const tasksReset = tasks.length;
     let summariesDeleted = 0;
     for (const t of tasks) {
-        updateTaskStatus(mid, sid, t.id, "pending");
-        tasksReset++;
         const summaryPath = resolveTaskFile(basePath, mid, sid, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             unlinkSync(summaryPath);
             summariesDeleted++;
         }
     }
-    // Reset slice status
-    updateSliceStatus(mid, sid, "active");
     // Delete slice summary and UAT files
     let sliceFilesDeleted = 0;
     const slicePath = resolveSlicePath(basePath, mid, sid);

package/dist/resources/extensions/gsd/unit-closeout.js

@@ -0,0 +1,138 @@
+// Project/App: gsd-pi
+// File Purpose: Unit Closeout module — durable completion pipeline behind one seam (ADR-032).
+//
+// `closeUnit` owns what makes a Unit's completion durable. This pass ships the
+// **Interactive Closeout adapter** path: commit the work and compute the
+// Closeout Git Verdict, failing closed (loudly) instead of silently when a
+// non-`none` `git.isolation` preference was never honoured by the session.
+// Motivating failure (2026-06-10): an interactive session under
+// `git.isolation: worktree` completed a milestone with every source file
+// untracked on the integration branch — no commit, no merge, no warning.
+//
+// The interactive adapter only fires on milestone boundaries — the durability
+// gap is the milestone close, and committing at every task/slice would sweep a
+// developer's unrelated working-tree changes. `closeUnit` itself stays general
+// over all boundaries for the pending Auto Closeout adapter re-seat.
+//
+// The auto loop keeps its existing closeout pipeline for now (the Auto
+// Closeout adapter re-seat is the documented next step in ADR-032); the
+// interactive trigger in bootstrap/register-hooks.ts is a no-op while
+// `isAutoActive()`, so auto-mode behaviour is untouched.
+//
+// Re-entrancy is naturally safe: a re-fired completion commits an already-clean
+// tree, which yields `nothing-to-commit`, and `appendNotification` carries its
+// own dedup window — so `closeUnit` keeps no result cache of its own.
+import { appendNotification } from "./notification-store.js";
+import { readStringField } from "./auto-unit-tool-scope.js";
+import { MILESTONE_BRANCH_PREFIX } from "./branch-patterns.js";
+import { nativeGetCurrentBranch } from "./native-git-bridge.js";
+import { getIsolationMode } from "./preferences.js";
+import { autoCommitCurrentBranch } from "./worktree.js";
+import { logWarning } from "./workflow-logger.js";
+const defaultDeps = {
+    isolationMode: (basePath) => getIsolationMode(basePath),
+    currentBranch: (basePath) => {
+        try {
+            return nativeGetCurrentBranch(basePath);
+        }
+        catch {
+            return null;
+        }
+    },
+    commit: (basePath, unitType, unitId) => autoCommitCurrentBranch(basePath, unitType, unitId),
+    notify: (message, severity) => appendNotification(message, severity),
+};
+export function closeUnit(request, deps = defaultDeps) {
+    let commitMessage = null;
+    let gitVerdict;
+    let notice;
+    try {
+        commitMessage = deps.commit(request.basePath, request.unitType, request.unitId);
+        gitVerdict = commitMessage === null ? "nothing-to-commit" : "committed";
+    }
+    catch (err) {
+        gitVerdict = "commit-failed";
+        notice = `Unit closeout commit failed for ${request.unitId}: ${err instanceof Error ? err.message : String(err)}`;
+        logWarning("engine", notice);
+        deps.notify(notice, "error");
+    }
+    if (request.boundary === "milestone" && gitVerdict !== "commit-failed") {
+        const isolation = deps.isolationMode(request.basePath);
+        if (isolation !== "none") {
+            const branch = deps.currentBranch(request.basePath);
+            if (branch?.startsWith(MILESTONE_BRANCH_PREFIX)) {
+                gitVerdict = "milestone-branch";
+                notice =
+                    `Milestone ${request.unitId} completed on ${branch}. ` +
+                        `Merge it to the integration branch with the worktree tooling (/gsd worktree merge).`;
+                deps.notify(notice, "info");
+            }
+            else {
+                gitVerdict = "isolation-bypassed";
+                notice =
+                    `Needs attention: milestone ${request.unitId} completed outside a milestone worktree/branch ` +
+                        `while git.isolation is "${isolation}" — the isolation preference was not honoured this session. ` +
+                        (commitMessage
+                            ? `Work was committed directly on "${branch ?? "the current branch"}".`
+                            : `The working tree had nothing left to commit on "${branch ?? "the current branch"}".`);
+                logWarning("engine", notice);
+                deps.notify(notice, "warning");
+            }
+        }
+    }
+    return { gitVerdict, commitMessage, notice };
+}
+// ─── Interactive Closeout adapter (tool-observation trigger) ─────────────
+// Canonical closeout tool → boundary. Aliases are canonicalized by the hook.
+// Only the milestone boundary is wired interactively: it is the durability gap
+// that motivated ADR-032, and committing at every task/slice would sweep a
+// developer's unrelated working-tree changes. `closeUnit` still handles every
+// boundary for the pending Auto Closeout adapter re-seat.
+const CLOSEOUT_TOOL_BOUNDARIES = {
+    gsd_complete_milestone: "milestone",
+};
+// Commit attribution uses the canonical unit types so interactive closeout
+// commits carry the same GSD-Unit evidence trailers the verification prompts
+// look for.
+const BOUNDARY_UNIT_TYPES = {
+    task: "execute-task",
+    slice: "complete-slice",
+    milestone: "complete-milestone",
+};
+export function isUnitCloseoutTool(canonicalToolName) {
+    return canonicalToolName in CLOSEOUT_TOOL_BOUNDARIES;
+}
+function readId(input, camel, snake) {
+    const value = readStringField(input, camel, snake);
+    return value && value.length > 0 ? value : undefined;
+}
+/**
+ * Interactive Closeout adapter entry, called from the host's tool-observation
+ * hook for successful closeout tool calls when auto-mode is NOT active.
+ * Returns null when the tool input doesn't identify a unit.
+ */
+export function runInteractiveUnitCloseout(args, deps = defaultDeps) {
+    const boundary = CLOSEOUT_TOOL_BOUNDARIES[args.canonicalToolName];
+    if (!boundary)
+        return null;
+    const milestoneId = readId(args.input, "milestoneId", "milestone_id");
+    if (!milestoneId)
+        return null;
+    const sliceId = readId(args.input, "sliceId", "slice_id");
+    const taskId = readId(args.input, "taskId", "task_id");
+    let unitId = milestoneId;
+    if (boundary !== "milestone") {
+        if (!sliceId)
+            return null;
+        unitId = boundary === "slice" ? `${milestoneId}/${sliceId}` : `${milestoneId}/${sliceId}/${taskId ?? ""}`;
+        if (boundary === "task" && !taskId)
+            return null;
+    }
+    return closeUnit({
+        basePath: args.basePath,
+        unitType: BOUNDARY_UNIT_TYPES[boundary],
+        unitId,
+        boundary,
+        outcome: "complete",
+    }, deps);
+}