@opengsd/gsd-core 1.9.1 → 1.11.0

package/gsd-core/bin/lib/workstream.cjs

@@ -134,8 +134,8 @@ function cmdWorkstreamCreate(cwd, name, options, raw) {
             }
             else {
                 try {
-                    const milestone = getMilestoneInfo(cwd);
-                    existingWsName = generateSlugInternal(milestone.name) || 'default';
+                    const milestone = getMilestoneInfo(cwd).value;
+                    existingWsName = generateSlugInternal(milestone?.name ?? null) || 'default';
                 }
                 catch {
                     existingWsName = 'default';
@@ -207,6 +207,10 @@ function cmdWorkstreamList(cwd, raw) {
         has_roadmap: ws.files.roadmap,
         has_state: ws.files.state,
         status: ws.status,
+        // #2562: a refused shipped marker must reach the surface. Projecting
+        // `status` without it renders the refusal invisible at the CLI, which is
+        // the silent-collapse defect this issue is about.
+        milestone_shipped_unverified: ws.milestone_shipped_unverified,
         current_phase: ws.current_phase,
         phase_count: ws.phase_count,
         completed_phases: ws.completed_phases,
@@ -241,6 +245,7 @@ function cmdWorkstreamStatus(cwd, name, raw) {
         phase_count: inv.phase_count,
         completed_phases: inv.completed_phases,
         status: inv.status,
+        milestone_shipped_unverified: inv.milestone_shipped_unverified,
         current_phase: inv.current_phase,
         last_activity: inv.last_activity,
     }, raw, undefined);
@@ -353,6 +358,7 @@ function cmdWorkstreamProgress(cwd, raw) {
         name: ws.name,
         active: ws.active,
         status: ws.status,
+        milestone_shipped_unverified: ws.milestone_shipped_unverified,
         current_phase: ws.current_phase ?? null,
         phases: `${ws.completed_phases}/${ws.roadmap_phase_count}`,
         plans: `${ws.completed_plans}/${ws.total_plans}`,

package/gsd-core/bin/lib/worktree-base-ref.cjs

@@ -97,6 +97,19 @@ function buildMsgDiverged(headSha, forkRef, forkSha) {
     return `⚠ Worktree base mismatch: HEAD (${shortSha(headSha)}) differs from ${forkRef} (${shortSha(forkSha)}). Running this phase sequentially on the main working tree. To keep parallel worktrees, set worktree.baseRef:"head" in .claude/settings.local.json (or run: gsd-tools worktree set-baseref). See #683.`;
 }
 const MSG_UNKNOWN = `⚠ Cannot determine the worktree fork base (origin/HEAD unresolved). Running this phase sequentially on the main working tree to avoid a base mismatch. To keep parallel worktrees, set worktree.baseRef:"head" in .claude/settings.local.json (or run: gsd-tools worktree set-baseref). See #683.`;
+const MSG_HEAD_UNRESOLVABLE = `⚠ Cannot determine the worktree base (git rev-parse HEAD did not return a definitive answer). Running this phase sequentially on the main working tree to avoid an unverified base mismatch. Note: worktree.baseRef:"head" would silence this check without verifying the base — it skips the comparison rather than resolving it. Retry; if it persists, check for a stalled filesystem mount or a stale git index lock (.git/index.lock). See #683, #3050.`;
+/**
+ * Returns true when an execGit result indicates the subprocess was killed by
+ * a timeout. A timeout means the command genuinely could not complete — it
+ * must never be treated the same as a clean non-zero exit (e.g. "not a git
+ * repository"), which DID complete and reported a real answer.
+ *
+ * Delegates to the single shared predicate in shell-command-projection.cts
+ * (#3050 — "Generative Fix Divergence"); do not reimplement this locally.
+ */
+function isExecGitTimeout(result) {
+    return (0, shell_command_projection_cjs_1.isSpawnTimeout)(result);
+}
 // ─── Exports ──────────────────────────────────────────────────────────────────
 /**
  * Returns the first 8 characters of a SHA, or '' if null/empty.
@@ -304,13 +317,44 @@ function evaluateWorktreeBaseDegrade(deps) {
     // complete: any non-"head" value (including "fresh" and absent/null) has fresh/origin-HEAD
     // semantics and must be evaluated against origin/HEAD. (Reference: Claude Code worktrees docs, #683.)
     if (deps?.effectiveBaseRef === 'head') {
-        return { shouldDegrade: false, reason: 'baseref-head', message: null, headSha: null, forkRef: null, forkSha: null };
+        return { shouldDegrade: false, reason: 'baseref-head', message: null, headSha: null, forkRef: null, forkSha: null, headAbsenceVerified: null };
     }
     // b. Resolve HEAD sha.
     const headResult = execGit(['rev-parse', 'HEAD'], cwdOpts);
+    // A TIMEOUT means the command never completed — it is not evidence of "not a
+    // git repository" and must fail closed (distinct from the clean-exit-128
+    // "no-head" case below, which genuinely completed and reported no HEAD).
+    if (isExecGitTimeout(headResult)) {
+        return { shouldDegrade: true, reason: 'head-unresolvable', message: MSG_HEAD_UNRESOLVABLE, headSha: null, forkRef: null, forkSha: null, headAbsenceVerified: null };
+    }
     const headStdout = headResult.stdout ? headResult.stdout.trim() : '';
-    if (headResult.exitCode !== 0 || !headStdout) {
-        return { shouldDegrade: false, reason: 'no-head', message: null, headSha: null, forkRef: null, forkSha: null };
+    // exit 128 is git's definitive "not a git repository" answer — it completed
+    // and genuinely reported no HEAD. Only this specific, confirmed outcome
+    // stays a benign non-degrade; every other non-success outcome below is
+    // NOT a definitive answer from git and must fail closed (#3050).
+    if (headResult.exitCode === 128) {
+        return { shouldDegrade: false, reason: 'no-head', message: null, headSha: null, forkRef: null, forkSha: null, headAbsenceVerified: true };
+    }
+    // Exit 0 with empty stdout is pinned as benign no-degrade by an existing
+    // regression guard (tests/worktree-base-ref.test.cjs — "git rev-parse HEAD
+    // returns empty stdout"). Left unchanged deliberately; flagged in the
+    // #3050 review for a product-intent call rather than silently flipped.
+    // Unlike the exit-128 case above, git did NOT give a definitive "no HEAD"
+    // answer here — `headAbsenceVerified:false` names that gap explicitly
+    // instead of leaving it folded into an identical-looking 'no-head' reason
+    // (#3057 B8; the product question of whether this SHOULD degrade is
+    // unchanged and still open).
+    if (headResult.exitCode === 0 && !headStdout) {
+        return { shouldDegrade: false, reason: 'no-head', message: null, headSha: null, forkRef: null, forkSha: null, headAbsenceVerified: false };
+    }
+    if (headResult.exitCode !== 0) {
+        // Any other non-success outcome (e.g. exit 127 — git missing — or any
+        // other non-zero, non-128 exit) is not a definitive "not a repo" answer.
+        // Fail closed instead of silently treating it as benign.
+        // (`!headStdout` was previously OR'd in here but is unreachable: the
+        // exitCode===0 && !headStdout case is already handled above, and every
+        // other branch here has exitCode!==0 already true — #3050 review.)
+        return { shouldDegrade: true, reason: 'head-unresolvable', message: MSG_HEAD_UNRESOLVABLE, headSha: null, forkRef: null, forkSha: null, headAbsenceVerified: null };
     }
     const headSha = headStdout;
     // c. Resolve fork base (what the harness forks 'fresh' worktrees from = origin/HEAD).
@@ -340,11 +384,11 @@ function evaluateWorktreeBaseDegrade(deps) {
     }
     // d. Evaluate.
     if (forkSha === null) {
-        return { shouldDegrade: true, reason: 'fork-ref-unknown', message: MSG_UNKNOWN, headSha, forkRef: null, forkSha: null };
+        return { shouldDegrade: true, reason: 'fork-ref-unknown', message: MSG_UNKNOWN, headSha, forkRef: null, forkSha: null, headAbsenceVerified: null };
     }
     if (forkSha === headSha) {
-        return { shouldDegrade: false, reason: 'head-matches-fork', message: null, headSha, forkRef, forkSha };
+        return { shouldDegrade: false, reason: 'head-matches-fork', message: null, headSha, forkRef, forkSha, headAbsenceVerified: null };
     }
     const message = buildMsgDiverged(headSha, forkRef, forkSha);
-    return { shouldDegrade: true, reason: 'head-diverged-from-fork', message, headSha, forkRef, forkSha };
+    return { shouldDegrade: true, reason: 'head-diverged-from-fork', message, headSha, forkRef, forkSha, headAbsenceVerified: null };
 }