@opengsd/gsd-pi 1.2.0-dev.9ad8ae33 → 1.2.0-dev.a6376d75

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

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Unit dispatch contract adapter for auto-mode loop.
 import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
-import { runUnitPhase } from "./phases.js";
+import { runUnitPhase } from "./unit-phase.js";
 import { decideDispatchNodeKind } from "./workflow-kernel.js";
 export async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem, deps) {
     if (dispatchContract === "legacy-direct") {

package/dist/resources/extensions/gsd/auto/worktree-safety-phase.js

@@ -0,0 +1,125 @@
+// Project/App: gsd-pi
+// File Purpose: Worktree-safety helpers shared across auto-loop phase modules.
+import { classifyProject } from "../detection.js";
+import { resolveEffectiveUnitIsolationMode } from "../preferences.js";
+import { createWorktreeSafetyModule } from "../worktree-safety.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
+import { resolveManifest } from "../unit-context-manifest.js";
+import { debugLog } from "../debug-logger.js";
+import { isSamePathLocal } from "./phase-helpers.js";
+import { hasHeldMilestoneLease, reclaimMissingMilestoneLease } from "./milestone-lease-reclaim.js";
+export function shouldDegradeEmptyWorktreeToProjectRoot(worktreeClassification, projectRootClassification) {
+    return (worktreeClassification.kind === "greenfield" &&
+        projectRootClassification.kind !== "greenfield" &&
+        projectRootClassification.kind !== "invalid-repo");
+}
+export function unitWritesSource(unitType) {
+    if (unitType.startsWith("hook/"))
+        return false;
+    // Backward compatibility: sidecar queues from older builds may persist
+    // prefixed unit types (e.g. "sidecar/quick-task").
+    const normalizedUnitType = unitType.startsWith("sidecar/")
+        ? unitType.slice("sidecar/".length)
+        : unitType;
+    const manifest = resolveManifest(normalizedUnitType);
+    if (!manifest)
+        return null;
+    return manifest.tools.mode === "all" || manifest.tools.mode === "docs";
+}
+export function formatWorktreeSafetyFailure(result) {
+    return `Worktree Safety failed (${result.kind}): ${result.reason} ${result.remediation}`;
+}
+export function formatWorktreeSafetyStopReason(result) {
+    if (result.kind === "empty-worktree-with-project-content") {
+        return `Worktree Safety failed (${result.kind}). Run /gsd doctor fix, then /gsd auto.`;
+    }
+    return `Worktree Safety failed (${result.kind}).`;
+}
+export function resolveEmptyWorktreeWithProjectContent(unitRoot, projectRoot) {
+    if (isSamePathLocal(unitRoot, projectRoot))
+        return false;
+    const worktreeClassification = classifyProject(unitRoot);
+    if (worktreeClassification.kind !== "greenfield")
+        return false;
+    const projectRootClassification = classifyProject(projectRoot);
+    return shouldDegradeEmptyWorktreeToProjectRoot(worktreeClassification, projectRootClassification);
+}
+export async function validateSourceWriteWorktreeSafety(ic, unitType, unitId, milestoneId, phase) {
+    const { ctx, pi, s, deps } = ic;
+    if (!s.basePath)
+        return null;
+    // Custom engine workflows (graph-driven, registered via run dirs) define
+    // their own step ids that are not in the GSD UnitContextManifest. Don't
+    // fail closed for those — the custom engine owns its own dispatch
+    // contract. The fail-closed safety check applies only to built-in GSD
+    // units whose Tool Contract is registered in the manifest. Use a truthy
+    // check so undefined (test sessions that never set the field) routes
+    // through the safety check, matching the regression test contract.
+    if (s.activeEngineId)
+        return null;
+    const writesSource = unitWritesSource(unitType);
+    if (writesSource === null) {
+        const msg = `Worktree Safety failed (missing-tool-contract): missing Tool Contract for ${unitType}. Add a UnitContextManifest entry before dispatching this Unit.`;
+        debugLog("worktreeSafety", {
+            phase,
+            unitType,
+            unitId,
+            milestoneId,
+            result: { ok: false, kind: "missing-tool-contract", reason: msg },
+            basePath: s.basePath,
+        });
+        ctx.ui.notify(msg, "error");
+        await deps.stopAuto(ctx, pi, msg);
+        return { action: "break", reason: "missing-tool-contract" };
+    }
+    if (!writesSource)
+        return null;
+    const projectRoot = s.canonicalProjectRoot ?? resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
+    // A degraded session already fell back to the milestone branch in the
+    // project root — validating against the canonical worktree root there
+    // would fail every dispatch with a false invalid-root. The same applies
+    // to a stranded-recovery session that adopted the milestone branch.
+    const isolationMode = resolveEffectiveUnitIsolationMode(deps.getIsolationMode(projectRoot), s.isolationDegraded, s.strandedRecoveryIsolationMode);
+    reclaimMissingMilestoneLease(s, milestoneId, isolationMode, phase);
+    const safety = createWorktreeSafetyModule();
+    const result = safety.validateUnitRoot({
+        unitType,
+        unitId,
+        writeScope: "source-writing",
+        projectRoot,
+        unitRoot: s.basePath,
+        milestoneId,
+        isolationMode,
+        expectedBranch: isolationMode !== "none" && milestoneId ? deps.autoWorktreeBranch(milestoneId) : null,
+        emptyWorktreeWithProjectContent: resolveEmptyWorktreeWithProjectContent(s.basePath, projectRoot),
+        // The milestone lease coordinates concurrent workers on an isolated
+        // milestone worktree/branch, which is established by enterMilestone in
+        // worktree/branch modes. `none` mode has no per-milestone isolation and
+        // does not reliably claim a lease (e.g. a fresh headless resume of an
+        // already-active milestone never re-enters it), so requiring a held lease
+        // there would falsely fail dispatch. Enforce the lease only in isolated
+        // modes; none-mode safety still validates the unit root.
+        lease: s.workerId
+            ? {
+                required: isolationMode !== "none",
+                held: hasHeldMilestoneLease(s, milestoneId),
+                owner: s.workerId,
+            }
+            : undefined,
+    });
+    if (result.ok)
+        return null;
+    const msg = formatWorktreeSafetyFailure(result);
+    debugLog("worktreeSafety", {
+        phase,
+        unitType,
+        unitId,
+        milestoneId,
+        result,
+        basePath: s.basePath,
+        projectRoot,
+    });
+    ctx.ui.notify(msg, "error");
+    await deps.stopAuto(ctx, pi, formatWorktreeSafetyStopReason(result));
+    return { action: "break", reason: result.kind };
+}

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

@@ -1041,7 +1041,7 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
  * still works after process restart when module state has been reset.
  */
 export function isInAutoWorktree(basePath) {
-    const targetPath = isGsdWorktreePath(basePath) ? basePath : process.cwd();
+    const targetPath = isGsdWorktreePath(basePath) ? basePath : safeCwd("");
     if (!isGsdWorktreePath(targetPath))
         return false;
     const storedBase = getAutoWorktreeOriginalBase();

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

@@ -512,6 +512,16 @@ export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
     }
     return false;
 }
+export function anchorProcessCwdForAutoResume(basePath) {
+    try {
+        process.chdir(basePath);
+        return true;
+    }
+    catch (err) {
+        logWarning("session", `resume cwd anchor failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts", basePath });
+        return false;
+    }
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -751,6 +761,9 @@ function pauseAutoUnitIdentityMatches(expected) {
         s.currentUnit.id === expected.id &&
         s.currentUnit.startedAt === expected.startedAt;
 }
+function shouldPreserveCoordinationForPause(errorContext) {
+    return errorContext?.category === "provider" && errorContext.isTransient === true;
+}
 function setLifecycleOutcome(ctx, input) {
     if (!ctx?.hasUI)
         return;
@@ -1585,7 +1598,7 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
         releaseSessionLock(lockBase());
         clearLock(lockBase());
     }
-    if (s.workerId) {
+    if (s.workerId && !shouldPreserveCoordinationForPause(_errorContext)) {
         try {
             if (s.currentMilestoneId && s.milestoneLeaseToken) {
                 releaseMilestoneLease(s.workerId, s.currentMilestoneId, s.milestoneLeaseToken);
@@ -2030,6 +2043,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         // ADR-016 phase 2 / B3 (#5621): paused-resume worktree-path adoption.
         buildLifecycle().resumeFromPausedSession(base, resumeWorktreePath);
+        anchorProcessCwdForAutoResume(s.basePath || base);
         // Rebuild scope now that s.basePath reflects the actual worktree (or project root).
         rebuildScope(s.basePath, s.currentMilestoneId);
         // Ensure the workflow-logger audit log is pinned to the project root

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

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { logWarning } from "../workflow-logger.js";
-import { openWorkflowDatabase } from "../db-workspace.js";
+import { getWorkflowDatabaseStatus, openWorkflowDatabase, } from "../db-workspace.js";
 import { getAutoWorktreePath } from "../auto-worktree.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { worktreesDirs } from "../worktree-placement.js";
@@ -61,16 +61,46 @@ export function resolveWorkflowToolBasePath(ctx, scope) {
     return cwd;
 }
 export { resolveProjectRootDbPath } from "../db-workspace.js";
+function sqliteProviderHint(status, nodeVersion) {
+    if (status.provider)
+        return `Provider: ${status.provider}.`;
+    const major = Number.parseInt(nodeVersion.split(".")[0] ?? "", 10);
+    if (Number.isFinite(major) && major < 22) {
+        return (`No SQLite provider available. Upgrade Node to >= 22.0.0 (current: v${nodeVersion}), ` +
+            "use the packaged GSD runtime, or install/restore better-sqlite3 in this runtime.");
+    }
+    return ("No SQLite provider available. Use a Node build with node:sqlite enabled, " +
+        "run the packaged GSD runtime, or install/restore better-sqlite3 in this runtime.");
+}
+function dbOpenPhaseHint(status) {
+    if (status.lastPhase === "open")
+        return "The database file could not be opened";
+    if (status.lastPhase === "initSchema")
+        return "The database schema could not be initialized";
+    if (status.lastPhase === "vacuum-recovery")
+        return "Corruption recovery (VACUUM) failed";
+    if (status.attempted)
+        return "The database could not be opened";
+    return "The database provider could not be loaded";
+}
+export function formatWorkflowDatabaseOpenFailure(result, status, nodeVersion = process.versions.node) {
+    if (result.reason === "missing-gsd-dir") {
+        return `ensureDbOpen failed — no .gsd directory found at ${result.location.projectGsd}`;
+    }
+    if (result.reason === "missing-database") {
+        return `ensureDbOpen failed — no GSD database found at ${result.location.projectDb}`;
+    }
+    const resolvedStatus = status ?? getWorkflowDatabaseStatus();
+    const detail = result.error?.message ?? resolvedStatus.lastError?.message ?? "";
+    const detailSuffix = detail ? ` (${detail})` : "";
+    return (`ensureDbOpen failed for ${result.location.projectDb}: ` +
+        `${dbOpenPhaseHint(resolvedStatus)}${detailSuffix}. ${sqliteProviderHint(resolvedStatus, nodeVersion)}`);
+}
 export async function ensureDbOpen(basePath = safeWorkspaceCwd()) {
     const result = openWorkflowDatabase(basePath);
     if (result.ok)
         return true;
-    if (result.reason === "missing-gsd-dir") {
-        logWarning("bootstrap", "ensureDbOpen failed — no .gsd directory found");
-    }
-    else {
-        logWarning("bootstrap", `ensureDbOpen failed: ${result.error?.message ?? "open failed"}`);
-    }
+    logWarning("bootstrap", formatWorkflowDatabaseOpenFailure(result));
     return false;
 }
 export function registerDynamicTools(pi) {

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -59,7 +59,7 @@ export function formatMcpStatusReport(servers) {
                 : s.connected
                     ? `connected — ${s.toolCount} tools`
                     : s.available
-                        ? `available — ${s.toolCount} tools`
+                        ? `probe available — ${s.toolCount} tools`
                         : "disconnected";
         const warningText = s.envWarnings?.length ? ` — ${s.envWarnings.length} warning(s)` : "";
         lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}${warningText}`);
@@ -83,7 +83,7 @@ export function formatMcpServerDetail(server) {
         lines.push(`  Error:     ${server.error}`);
     }
     else if (server.connected || server.available) {
-        lines.push(`  Status:    ${server.connected ? "connected" : "available"}`);
+        lines.push(`  Status:    ${server.connected ? "connected" : "probe available"}`);
         lines.push(`  Tools:     ${server.toolCount}`);
         if (server.tools.length > 0) {
             lines.push("");

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

@@ -59,6 +59,13 @@ function datePrefix() {
     const dd = String(d.getDate()).padStart(2, "0");
     return `${yy}${mm}${dd}`;
 }
+export function isWorkflowStateComplete(state) {
+    if (state.completedAt)
+        return true;
+    return Array.isArray(state.phases) &&
+        state.phases.length > 0 &&
+        state.phases.every((phase) => phase.status === "completed");
+}
 /**
  * Write a STATE.json file to track workflow execution state.
  */
@@ -85,7 +92,7 @@ function writeWorkflowState(artifactDir, templateId, templateName, phases, descr
  * Scan all workflow artifact directories for in-progress STATE.json files.
  * Returns workflows that were started but not completed.
  */
-function findInProgressWorkflows(basePath) {
+export function findInProgressWorkflows(basePath) {
     const workflowsRoot = join(gsdRoot(basePath), "workflows");
     if (!existsSync(workflowsRoot))
         return [];
@@ -105,7 +112,7 @@ function findInProgressWorkflows(basePath) {
                 try {
                     const raw = readFileSync(statePath, "utf-8");
                     const state = JSON.parse(raw);
-                    if (!state.completedAt) {
+                    if (!isWorkflowStateComplete(state)) {
                         results.push(state);
                     }
                 }

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

@@ -218,6 +218,36 @@ export function getMilestoneSlices(milestoneId) {
     const rows = getDbOrNull().prepare("SELECT * FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId });
     return rows.map(rowToSlice);
 }
+/**
+ * Load slices for many milestones in a single query. Returns a Map keyed by
+ * milestone_id, preserving `ORDER BY sequence, id` within each bucket.
+ */
+export function getSlicesByMilestoneIds(milestoneIds) {
+    const db = getDbOrNull();
+    if (!db || milestoneIds.length === 0)
+        return new Map();
+    const idList = [...milestoneIds];
+    const placeholders = idList.map((_, i) => `:mid${i}`).join(",");
+    const params = {};
+    idList.forEach((id, i) => {
+        params[`:mid${i}`] = id;
+    });
+    const rows = db
+        .prepare(`SELECT * FROM slices WHERE milestone_id IN (${placeholders}) ORDER BY milestone_id, sequence, id`)
+        .all(params);
+    const byMilestone = new Map();
+    for (const row of rows) {
+        const slice = rowToSlice(row);
+        const bucket = byMilestone.get(slice.milestone_id);
+        if (bucket) {
+            bucket.push(slice);
+        }
+        else {
+            byMilestone.set(slice.milestone_id, [slice]);
+        }
+    }
+    return byMilestone;
+}
 /**
  * Consolidated DB read for dispatch/gate/completion decisions (ADR-017).
  * `done` uses the canonical closed-status predicate (`isClosedStatus`) — the