gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.d8826a445

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -1,10 +1,10 @@
 /**
  * complete-task handler — the core operation behind gsd_complete_task.
  *
- * Validates inputs, writes task row to DB in a transaction, then (outside
- * the transaction) renders SUMMARY.md to disk, toggles the plan checkbox,
- * stores the rendered markdown in the DB for D004 recovery, and invalidates
- * caches.
+ * Validates inputs, writes task row and rendered SUMMARY.md to DB in a
+ * transaction, then renders projections to disk and invalidates caches.
+ * Projection write failures are reported as stale projections and do not roll
+ * back committed DB state.
  */
 
 import { join } from "node:path";
@@ -22,13 +22,12 @@ import {
   getSlice,
   getTask,
   updateTaskStatus,
-  setTaskSummaryMd,
   deleteVerificationEvidence,
   saveGateResult,
   getPendingGatesForTurn,
 } from "../gsd-db.js";
 import { getGatesForTurn } from "../gate-registry.js";
-import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
+import { resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
@@ -168,6 +167,7 @@ export async function handleCompleteTask(
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
+  let summaryMd = "";
 
   // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
   // Building the artifact runs the full shape validation (2-4 options, unique
@@ -237,6 +237,9 @@ export async function handleCompleteTask(
     }
 
     // All guards passed — perform writes
+    const taskRow = paramsToTaskRow(params, completedAt);
+    summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
+
     insertMilestone({ id: params.milestoneId, title: params.milestoneId });
     insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
     insertTask({
@@ -254,6 +257,7 @@ export async function handleCompleteTask(
       knownIssues: params.knownIssues ?? "None.",
       keyFiles: params.keyFiles ?? [],
       keyDecisions: params.keyDecisions ?? [],
+      fullSummaryMd: summaryMd,
     });
 
     for (const evidence of (params.verificationEvidence ?? [])) {
@@ -301,13 +305,7 @@ export async function handleCompleteTask(
     return { error: guardError };
   }
 
-  // ── Filesystem operations (outside transaction) ─────────────────────────
-  // If disk render fails, roll back the DB status so deriveState() and
-  // verifyExpectedArtifact() stay consistent (both say "not done").
-
-  // Render summary markdown via the single source of truth (#2720)
-  const taskRow = paramsToTaskRow(params, completedAt);
-  const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
+  let projectionStale = false;
 
   // Resolve and write summary to disk
   let summaryPath: string;
@@ -325,30 +323,16 @@ export async function handleCompleteTask(
   try {
     await saveFile(summaryPath, summaryMd);
 
-    // Toggle plan checkbox via renderer module
-    const planPath = resolveSliceFile(basePath, params.milestoneId, params.sliceId, "PLAN");
-    if (planPath) {
-      await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
-    } else {
-      process.stderr.write(
-        `gsd-db: complete_task — could not find plan file for ${params.sliceId}/${params.milestoneId}, skipping checkbox toggle\n`,
-      );
-    }
+    // Toggle or regenerate the plan projection from DB. Missing projection
+    // files are rebuilt by the renderer instead of being skipped.
+    await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
   } catch (renderErr) {
-    // Disk render failed — roll back DB status so state stays consistent
-    logWarning("tool", `complete_task — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
-    // Delete orphaned verification_evidence rows first (FK constraint
-    // references tasks, so evidence must go before status change).
-    // Without this, retries accumulate duplicate evidence rows (#2724).
-    deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
-    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
-    invalidateStateCache();
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
+    projectionStale = true;
+    logWarning("projection", `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}; DB completion remains committed`, {
+      error: (renderErr as Error).message,
+    });
   }
 
-  // Store rendered markdown in DB for D004 recovery
-  setTaskSummaryMd(params.milestoneId, params.sliceId, params.taskId, summaryMd);
-
   // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
   // Each gate id maps to a specific params field via taskGateFieldForId.
   // When the model populates the field, record `pass`; when it's empty,
@@ -471,5 +455,6 @@ export async function handleCompleteTask(
     sliceId: params.sliceId,
     milestoneId: params.milestoneId,
     summaryPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -14,7 +14,6 @@ import { join } from "node:path";
 import {
   transaction,
   insertAssessment,
-  deleteAssessmentByScope,
   getMilestoneSlices,
 } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
@@ -45,6 +44,7 @@ export interface ValidateMilestoneResult {
   milestoneId: string;
   verdict: string;
   validationPath: string;
+  stale?: boolean;
 }
 
 export interface ValidateMilestoneOptions {
@@ -150,13 +150,14 @@ export async function handleValidateMilestone(
   });
 
   // ── Filesystem render (outside transaction) ────────────────────────────
-  // If disk render fails, roll back the DB row so state stays consistent.
+  let projectionStale = false;
   try {
     await saveFile(validationPath, validationMd);
   } catch (renderErr) {
-    logWarning("tool", `validate_milestone — disk render failed, rolling back DB row: ${(renderErr as Error).message}`);
-    deleteAssessmentByScope(params.milestoneId, 'milestone-validation');
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
+    projectionStale = true;
+    logWarning("projection", `validate_milestone projection write failed for ${params.milestoneId}; DB validation remains committed`, {
+      error: (renderErr as Error).message,
+    });
   }
 
   invalidateStateCache();
@@ -202,5 +203,6 @@ export async function handleValidateMilestone(
     milestoneId: params.milestoneId,
     verdict: params.verdict,
     validationPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/workflow-manifest.ts

@@ -76,7 +76,9 @@ export function snapshotState(): StateManifest {
   // Wrap all reads in a deferred transaction so the snapshot is consistent
   // (all SELECTs see the same DB state even if a concurrent write lands between them).
   return readTransaction(() => {
-  const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all() as Record<string, unknown>[];
+  const rawMilestones = db.prepare(
+    "SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id",
+  ).all() as Record<string, unknown>[];
   const milestones: MilestoneRow[] = rawMilestones.map((r) => ({
     id: r["id"] as string,
     title: r["title"] as string,
@@ -95,6 +97,7 @@ export function snapshotState(): StateManifest {
     definition_of_done: JSON.parse((r["definition_of_done"] as string) || "[]"),
     requirement_coverage: (r["requirement_coverage"] as string) ?? "",
     boundary_map_markdown: (r["boundary_map_markdown"] as string) ?? "",
+    sequence: Number(r["sequence"] ?? 0),
   }));
 
   const rawSlices = db.prepare("SELECT * FROM slices ORDER BY milestone_id, sequence, id").all() as Record<string, unknown>[];

package/src/resources/extensions/gsd/workflow-mcp-auto-prep.ts

@@ -29,29 +29,13 @@ function getAuthModeSafe(
   }
 }
 
-function hasClaudeCodeProvider(ctx: WorkflowMcpAutoPrepContext): boolean {
-  return getAuthModeSafe(ctx, "claude-code") === "externalCli";
-}
-
-function isClaudeCodeProviderReady(ctx: WorkflowMcpAutoPrepContext): boolean {
-  const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
-  if (typeof readyCheck !== "function") return false;
-  try {
-    return readyCheck("claude-code");
-  } catch {
-    return false;
-  }
-}
-
 export function shouldAutoPrepareWorkflowMcp(ctx: WorkflowMcpAutoPrepContext): boolean {
   const provider = ctx.model?.provider;
   const baseUrl = ctx.model?.baseUrl;
   const authMode = getAuthModeSafe(ctx, provider);
 
-  if (usesWorkflowMcpTransport(authMode as any, baseUrl)) return true;
-  if (provider === "claude-code") return true;
-  if (hasClaudeCodeProvider(ctx)) return true;
-  return isClaudeCodeProviderReady(ctx);
+  if (provider !== "claude-code") return false;
+  return usesWorkflowMcpTransport(authMode as any, baseUrl) || authMode === "externalCli";
 }
 
 export function prepareWorkflowMcpForProject(

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -349,9 +349,9 @@ export function getRequiredWorkflowToolsForAutoUnit(unitType: string): string[]
     case "execute-task":
     case "execute-task-simple":
     case "reactive-execute":
-      return ["gsd_complete_task"];
+      return ["gsd_task_complete"];
     case "complete-slice":
-      return ["gsd_complete_slice"];
+      return ["gsd_slice_complete"];
     case "replan-slice":
       return ["gsd_replan_slice"];
     case "reassess-roadmap":

package/src/resources/extensions/gsd/workflow-reconcile.ts

@@ -20,7 +20,7 @@ import {
 } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { invalidateStateCache } from "./state.js";
-import { clearPathCache } from "./paths.js";
+import { clearPathCache, resolveGsdPathContract } from "./paths.js";
 import { clearParseCache } from "./files.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -492,7 +492,7 @@ function _reconcileWorktreeLogsInner(
   atomicWriteSync(join(mainBasePath, ".gsd", "event-log.jsonl"), logContent);
 
   // Step 8: Replay into DB (wrapped in a transaction by replayEvents)
-  openDatabase(join(mainBasePath, ".gsd", "gsd.db"));
+  openDatabase(resolveGsdPathContract(mainBasePath).projectDb);
   replayEvents(merged);
 
   // Step 9: Write manifest
@@ -647,7 +647,7 @@ export function resolveConflict(
   writeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
 
   // Replay resolved events through the DB (updates DB state)
-  openDatabase(join(basePath, ".gsd", "gsd.db"));
+  openDatabase(resolveGsdPathContract(basePath).projectDb);
   replayEvents(eventsToReplay);
   invalidateStateCache();
   clearPathCache();

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

@@ -0,0 +1,95 @@
+// GSD-2 + Workspace handle: single source of truth for path resolution per milestone
+
+import { join, resolve } from "node:path";
+import { type GsdPathContract, resolveGsdPathContract, normalizeRealPath } from "./paths.js";
+import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
+
+export type GsdWorkspaceMode = "project" | "worktree";
+
+export interface GsdWorkspace {
+  readonly projectRoot: string;          // realpath-normalized absolute
+  readonly worktreeRoot: string | null;  // realpath-normalized absolute, null when no worktree
+  readonly mode: GsdWorkspaceMode;
+  readonly contract: GsdPathContract;    // pre-resolved, frozen
+  readonly identityKey: string;          // canonical key (realpath of projectRoot) for dedup/cache
+  readonly lockRoot: string;             // where auto.lock and {MID}-META.json live (always projectRoot)
+}
+
+export interface MilestoneScope {
+  readonly workspace: GsdWorkspace;
+  readonly milestoneId: string;
+  // path methods:
+  readonly contextFile: () => string;
+  readonly roadmapFile: () => string;
+  readonly stateFile: () => string;
+  readonly dbPath: () => string;
+  readonly milestoneDir: () => string;
+  readonly metaJson: () => string;       // {MID}-META.json on lockRoot
+}
+
+function tryRealpath(p: string): string {
+  return normalizeRealPath(p);
+}
+
+/**
+ * Create an immutable GsdWorkspace handle from a raw base path.
+ * Resolves both the project root and (when applicable) the worktree root,
+ * normalizes them via realpath, and freezes the result.
+ */
+export function createWorkspace(rawBasePath: string): GsdWorkspace {
+  const resolvedBase = resolve(rawBasePath);
+  const isWorktree = isGsdWorktreePath(resolvedBase);
+
+  const projectRootRaw = resolveWorktreeProjectRoot(resolvedBase);
+  const projectRoot = tryRealpath(resolve(projectRootRaw));
+
+  const worktreeRoot = isWorktree ? tryRealpath(resolvedBase) : null;
+
+  // Derive a canonical base from the already-realpath-normalized paths so that
+  // resolveGsdPathContract always receives a canonical path. Using the raw
+  // resolvedBase here can produce a non-canonical projectGsd when the input
+  // path contains symlinks, causing contract.projectGsd to diverge from the
+  // realpath-normalized projectRoot / identityKey.
+  const canonicalBase = isWorktree ? (worktreeRoot ?? resolvedBase) : projectRoot;
+  const contract = Object.freeze(resolveGsdPathContract(canonicalBase));
+
+  const identityKey = tryRealpath(projectRoot);
+
+  const mode: GsdWorkspaceMode = isWorktree ? "worktree" : "project";
+
+  const workspace: GsdWorkspace = Object.freeze({
+    projectRoot,
+    worktreeRoot,
+    mode,
+    contract,
+    identityKey,
+    lockRoot: projectRoot,
+  });
+
+  return workspace;
+}
+
+/**
+ * Bind a milestoneId to a workspace, producing an immutable MilestoneScope
+ * with path-returning closures that resolve via the authoritative projectGsd.
+ *
+ * All milestone-content paths route to contract.projectGsd (canonical),
+ * since that is the authoritative source of truth regardless of worktree mode.
+ */
+export function scopeMilestone(workspace: GsdWorkspace, milestoneId: string): MilestoneScope {
+  const { contract } = workspace;
+  const gsd = contract.projectGsd;
+
+  const scope: MilestoneScope = Object.freeze({
+    workspace,
+    milestoneId,
+    contextFile: () => join(gsd, "milestones", milestoneId, `${milestoneId}-CONTEXT.md`),
+    roadmapFile: () => join(gsd, "milestones", milestoneId, `${milestoneId}-ROADMAP.md`),
+    stateFile: () => join(gsd, "STATE.md"),
+    dbPath: () => contract.projectDb,
+    milestoneDir: () => join(gsd, "milestones", milestoneId),
+    metaJson: () => join(gsd, `${milestoneId}-META.json`),
+  });
+
+  return scope;
+}

package/src/resources/extensions/gsd/worktree-command.ts

@@ -15,7 +15,7 @@ import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, resolveGitHeadPath, nudgeGitBranchCache } from "./worktree.js";
 import { runWorktreePostCreateHook } from "./auto-worktree.js";
 import { showConfirm } from "../shared/tui.js";
-import { gsdRoot, milestonesDir } from "./paths.js";
+import { gsdRoot, milestonesDir, resolveGsdPathContract } from "./paths.js";
 import {
   createWorktree,
   listWorktrees,
@@ -651,8 +651,9 @@ async function handleMerge(
     const commitMessage = `${commitType}: merge worktree ${name}\n\nGSD-Worktree: ${name}`;
 
     // Reconcile worktree DB into main DB before squash merge
-    const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
-    const mainDbPath = join(basePath, ".gsd", "gsd.db");
+    const contract = resolveGsdPathContract(worktreePath(basePath, name), basePath);
+    const wtDbPath = join(contract.worktreeGsd ?? join(contract.workRoot, ".gsd"), "gsd.db");
+    const mainDbPath = contract.projectDb;
     if (existsSync(wtDbPath) && existsSync(mainDbPath)) {
       try {
         const { reconcileWorktreeDb } = await import("./gsd-db.js");

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -1,3 +1,4 @@
+// GSD-2 — WorktreeResolver: encapsulates worktree path state and merge/exit lifecycle.
 /**
  * WorktreeResolver — encapsulates worktree path state and merge/exit lifecycle.
  *
@@ -23,7 +24,20 @@ import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "./worktree-root.js";
+
+// ─── Path Comparison Helper ────────────────────────────────────────────────
+/**
+ * Compare two paths for physical identity, tolerating trailing slashes,
+ * symlink differences, and case variations on case-insensitive volumes.
+ *
+ * Used in place of string `===` / `!==` wherever one operand may be
+ * realpath-normalised (e.g. from the workspace registry) and the other
+ * may not be (e.g. a raw caller-supplied basePath).
+ */
+function isSamePath(a: string, b: string): boolean {
+  return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
 
 // ─── Dependency Interface ──────────────────────────────────────────────────
 
@@ -589,7 +603,7 @@ export class WorktreeResolver {
         milestoneId,
         "ROADMAP",
       );
-      if (!roadmapPath && this.s.basePath !== originalBase) {
+      if (!roadmapPath && !isSamePath(this.s.basePath, originalBase)) {
         roadmapPath = this.deps.resolveMilestoneFile(
           this.s.basePath,
           milestoneId,

package/src/resources/extensions/gsd/write-intercept.ts

@@ -91,9 +91,9 @@ function matchesBlockedPattern(path: string): boolean {
  * Directs the agent to use engine tool calls instead.
  */
 export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
-- To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
-- To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
-- To save a decision: call gsd_save_decision(scope, decision, choice, rationale)
+- To complete a task: call gsd_task_complete(milestone_id, slice_id, task_id, summary)
+- To complete a slice: call gsd_slice_complete(milestone_id, slice_id, summary, uat_result)
+- To save a decision: call gsd_decision_save(scope, decision, choice, rationale)
 - To start a task: call gsd_start_task(milestone_id, slice_id, task_id)
 - To record verification: call gsd_record_verification(milestone_id, slice_id, task_id, evidence)
 - To report a blocker: call gsd_report_blocker(milestone_id, slice_id, task_id, description)`;

package/dist/web/standalone/.next/server/chunks/8527.js

@@ -1 +0,0 @@
-exports.id=8527,exports.ids=[8527],exports.modules={18527:(a,b,c)=>{"use strict";c.d(b,{isOnboardingComplete:()=>l,readOnboardingRecord:()=>k});var d=c(73024),e=c(76760);c(77598);var f=c(16698),g=c(48161);c(31421),process.env.GSD_ENABLE_NATIVE_GSD_PARSER,Symbol("native-unavailable"),new f.AsyncLocalStorage,c(89134),Object.values({Q3:{id:"Q3",scope:"slice",ownerTurn:"gate-evaluate",question:"How can this be exploited?",guidance:"Identify abuse scenarios: parameter tampering, replay attacks, privilege escalation.\nMap data exposure risks: PII, tokens, secrets accessible through this slice.\nDefine input trust boundaries: untrusted user input reaching DB, API, or filesystem.\nIf none apply, return verdict 'omitted' with rationale explaining why.",promptSection:"Abuse Surface"},Q4:{id:"Q4",scope:"slice",ownerTurn:"gate-evaluate",question:"Which existing requirements (R-IDs) does this slice touch, and which must be re-tested?",guidance:"List the R-IDs (e.g. R001, R003) touched by this slice; see the milestone requirements artifact at .gsd/milestones/<id>/REQUIREMENTS.md.\nIdentify what must be re-tested after shipping.\nFlag decisions that should be revisited given the new scope.\nIf no existing requirements are affected, return verdict 'omitted'.",promptSection:"Broken Promises"},Q5:{id:"Q5",scope:"task",ownerTurn:"execute-task",question:"What breaks when dependencies fail?",guidance:"Enumerate the task's external dependencies (APIs, filesystem, network, subprocesses).\nDescribe the failure path for each: timeout, malformed response, connection loss.\nVerify the implementation handles each failure or explicitly bubbles the error.\nReturn verdict 'omitted' only if the task has no external dependencies.",promptSection:"Failure Modes"},Q6:{id:"Q6",scope:"task",ownerTurn:"execute-task",question:"What is the 10x load breakpoint?",guidance:"Identify the resource that saturates first at 10x the expected load.\nDescribe the protection applied (pool sizing, rate limiting, pagination, caching).\nReturn verdict 'omitted' if the task has no runtime load dimension.",promptSection:"Load Profile"},Q7:{id:"Q7",scope:"task",ownerTurn:"execute-task",question:"What negative tests protect this task?",guidance:"List malformed inputs, error paths, and boundary conditions the tests cover.\nPoint to the specific test files or cases that assert each negative scenario.\nReturn verdict 'omitted' only if the task has no meaningful negative surface.",promptSection:"Negative Tests"},Q8:{id:"Q8",scope:"slice",ownerTurn:"complete-slice",question:"How will ops know this slice is healthy or broken?",guidance:"Describe the health signal (metric, log line, dashboard) that proves the slice works.\nDescribe the failure signal that triggers an alert or paging.\nDocument the recovery procedure and any monitoring gaps.\nReturn verdict 'omitted' only for slices with no runtime behavior at all.",promptSection:"Operational Readiness"},MV01:{id:"MV01",scope:"milestone",ownerTurn:"validate-milestone",question:"Is every success criterion in the milestone roadmap satisfied?",guidance:"Walk the success-criteria checklist from the milestone roadmap.\nFor each criterion, point to the slice / assessment / verification evidence that proves it.\nReturn verdict 'flag' if any criterion is unmet or unverifiable.",promptSection:"Success Criteria Checklist"},MV02:{id:"MV02",scope:"milestone",ownerTurn:"validate-milestone",question:"Does every slice have a SUMMARY.md and a passing assessment?",guidance:"Confirm every slice listed in the roadmap has a SUMMARY.md.\nConfirm each slice has an ASSESSMENT verdict of 'pass' (or justified 'omitted').\nFlag missing artifacts and slices with outstanding follow-ups or known limitations.",promptSection:"Slice Delivery Audit"},MV03:{id:"MV03",scope:"milestone",ownerTurn:"validate-milestone",question:"Do the slices integrate end-to-end?",guidance:"Trace at least one cross-slice flow proving the pieces compose.\nFlag gaps where two slices were built in isolation with no integration evidence.",promptSection:"Cross-Slice Integration"},MV04:{id:"MV04",scope:"milestone",ownerTurn:"validate-milestone",question:"Are all touched requirements covered and still coherent?",guidance:"For each requirement advanced, validated, surfaced, or invalidated across the milestone's slices, confirm the milestone-level evidence matches.\nFlag requirements that slices claim to advance but no artifact proves.",promptSection:"Requirement Coverage"}});let h=process.env.GSD_CODING_AGENT_DIR||(0,e.join)(process.env.GSD_HOME?(0,e.resolve)(process.env.GSD_HOME):(0,e.join)((0,g.homedir)(),".gsd"),"agent"),i=(0,e.join)(h,"onboarding.json"),j={version:1,flowVersion:1,completedAt:null,completedSteps:[],skippedSteps:[],lastResumePoint:null};function k(){if(!(0,d.existsSync)(i))return{...j};try{let a=JSON.parse((0,d.readFileSync)(i,"utf-8"));return{version:"number"==typeof a.version?a.version:1,flowVersion:"number"==typeof a.flowVersion?a.flowVersion:0,completedAt:"string"==typeof a.completedAt?a.completedAt:null,completedSteps:Array.isArray(a.completedSteps)?a.completedSteps.filter(a=>"string"==typeof a):[],skippedSteps:Array.isArray(a.skippedSteps)?a.skippedSteps.filter(a=>"string"==typeof a):[],lastResumePoint:"string"==typeof a.lastResumePoint?a.lastResumePoint:null}}catch{return{...j}}}function l(){let a=k();return null!==a.completedAt&&1===a.flowVersion}},65168:a=>{function b(a){var b=Error("Cannot find module '"+a+"'");throw b.code="MODULE_NOT_FOUND",b}b.keys=()=>[],b.resolve=b,b.id=65168,a.exports=b},89134:(a,b,c)=>{"use strict";c.d(b,{DZ:()=>e,rs:()=>d});let d="GSD_GIT_ERROR";class e extends Error{constructor(a,b,c){super(b,c),this.name="GSDError",this.code=a}}}};