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

package/src/resources/extensions/gsd/auto/workflow-unit-dispatch.ts

@@ -10,7 +10,7 @@ import type {
 } from "./types.js";
 import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
 import type { UokGraphNode } from "../uok/contracts.js";
-import { runUnitPhase } from "./phases.js";
+import { runUnitPhase } from "./unit-phase.js";
 import { decideDispatchNodeKind } from "./workflow-kernel.js";
 
 export type DispatchContract = "legacy-direct" | "uok-scheduler";

package/src/resources/extensions/gsd/auto/worktree-safety-phase.ts

@@ -0,0 +1,149 @@
+// Project/App: gsd-pi
+// File Purpose: Worktree-safety helpers shared across auto-loop phase modules.
+
+import { classifyProject } from "../detection.js";
+import { resolveEffectiveUnitIsolationMode, getIsolationMode } from "../preferences.js";
+import { createWorktreeSafetyModule, type WorktreeSafetyResult } 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";
+import type { IterationContext } from "./types.js";
+
+export function shouldDegradeEmptyWorktreeToProjectRoot(
+  worktreeClassification: ReturnType<typeof classifyProject>,
+  projectRootClassification: ReturnType<typeof classifyProject>,
+): boolean {
+  return (
+    worktreeClassification.kind === "greenfield" &&
+    projectRootClassification.kind !== "greenfield" &&
+    projectRootClassification.kind !== "invalid-repo"
+  );
+}
+
+export function unitWritesSource(unitType: string): boolean | null {
+  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: Extract<WorktreeSafetyResult, { ok: false }>): string {
+  return `Worktree Safety failed (${result.kind}): ${result.reason} ${result.remediation}`;
+}
+
+export function formatWorktreeSafetyStopReason(result: Extract<WorktreeSafetyResult, { ok: false }>): string {
+  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: string,
+  projectRoot: string,
+): boolean {
+  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: IterationContext,
+  unitType: string,
+  unitId: string,
+  milestoneId: string | undefined,
+  phase: string,
+): Promise<{ action: "break"; reason: string } | null> {
+  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/src/resources/extensions/gsd/auto-worktree.ts

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

package/src/resources/extensions/gsd/auto.ts

@@ -859,6 +859,20 @@ export function _warnIfWorktreeMissingForTest(
   return false;
 }
 
+export function anchorProcessCwdForAutoResume(basePath: string): boolean {
+  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(): boolean {
   return s.paused;
 }
@@ -1160,6 +1174,10 @@ function pauseAutoUnitIdentityMatches(expected: PauseAutoUnitIdentity | null): b
     s.currentUnit.startedAt === expected.startedAt;
 }
 
+function shouldPreserveCoordinationForPause(errorContext?: ErrorContext): boolean {
+  return errorContext?.category === "provider" && errorContext.isTransient === true;
+}
+
 function setLifecycleOutcome(
   ctx: ExtensionContext | undefined,
   input: {
@@ -2120,7 +2138,7 @@ export async function pauseAuto(
     clearLock(lockBase());
   }
 
-  if (s.workerId) {
+  if (s.workerId && !shouldPreserveCoordinationForPause(_errorContext)) {
     try {
       if (s.currentMilestoneId && s.milestoneLeaseToken) {
         releaseMilestoneLease(s.workerId, s.currentMilestoneId, s.milestoneLeaseToken);
@@ -2638,6 +2656,7 @@ export async function startAuto(
     }
     // 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/src/resources/extensions/gsd/bootstrap/dynamic-tools.ts

@@ -8,7 +8,12 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 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,
+  type WorkflowDatabaseOpenResult,
+  type WorkflowDatabaseStatus,
+} from "../db-workspace.js";
 import { getAutoWorktreePath } from "../auto-worktree.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { worktreesDirs } from "../worktree-placement.js";
@@ -69,15 +74,60 @@ export function resolveWorkflowToolBasePath(
 
 export { resolveProjectRootDbPath } from "../db-workspace.js";
 
+type WorkflowDatabaseOpenFailure = Extract<WorkflowDatabaseOpenResult, { ok: false }>;
+
+function sqliteProviderHint(status: WorkflowDatabaseStatus, nodeVersion: string): string {
+  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: WorkflowDatabaseStatus): string {
+  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: WorkflowDatabaseOpenFailure,
+  status?: WorkflowDatabaseStatus,
+  nodeVersion: string = process.versions.node,
+): string {
+  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: string = safeWorkspaceCwd()): Promise<boolean> {
   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;
 }
 

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -102,7 +102,7 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
       : 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}`);
@@ -128,7 +128,7 @@ export function formatMcpServerDetail(server: McpServerDetail): string {
     lines.push(`  Status:    error`);
     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/src/resources/extensions/gsd/commands-workflow-templates.ts

@@ -80,13 +80,13 @@ function datePrefix(): string {
 
 // ─── State Types ─────────────────────────────────────────────────────────────
 
-interface WorkflowPhaseState {
+export interface WorkflowPhaseState {
   name: string;
   index: number;
   status: "pending" | "active" | "completed";
 }
 
-interface WorkflowState {
+export interface WorkflowState {
   template: string;
   templateName: string;
   description: string;
@@ -99,6 +99,13 @@ interface WorkflowState {
   artifactDir: string;
 }
 
+export function isWorkflowStateComplete(state: WorkflowState): boolean {
+  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.
  */
@@ -133,7 +140,7 @@ function writeWorkflowState(
  * Scan all workflow artifact directories for in-progress STATE.json files.
  * Returns workflows that were started but not completed.
  */
-function findInProgressWorkflows(basePath: string): WorkflowState[] {
+export function findInProgressWorkflows(basePath: string): WorkflowState[] {
   const workflowsRoot = join(gsdRoot(basePath), "workflows");
   if (!existsSync(workflowsRoot)) return [];
 
@@ -152,7 +159,7 @@ function findInProgressWorkflows(basePath: string): WorkflowState[] {
         try {
           const raw = readFileSync(statePath, "utf-8");
           const state = JSON.parse(raw) as WorkflowState;
-          if (!state.completedAt) {
+          if (!isWorkflowStateComplete(state)) {
             results.push(state);
           }
         } catch { /* corrupted state file — skip */ }

package/src/resources/extensions/gsd/db/queries.ts

@@ -270,6 +270,35 @@ export function getMilestoneSlices(milestoneId: string): SliceRow[] {
   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: readonly string[]): Map<string, SliceRow[]> {
+  const db = getDbOrNull();
+  if (!db || milestoneIds.length === 0) return new Map();
+  const idList = [...milestoneIds];
+  const placeholders = idList.map((_, i) => `:mid${i}`).join(",");
+  const params: Record<string, unknown> = {};
+  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) as Record<string, unknown>[];
+  const byMilestone = new Map<string, SliceRow[]>();
+  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;
+}
+
 /** Dispatch-eligibility shape consumed by decision-path callers (ADR-017). */
 export interface MilestoneSliceSummary {
   id: string;