@opengsd/gsd-pi 1.5.0 → 1.6.0-dev.aa7f94e8

package/dist/resources/extensions/gsd/rule-registry.js

@@ -8,21 +8,53 @@
 import { logWarning } from "./workflow-logger.js";
 import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { parseUnitId } from "./unit-id.js";
+import { resolveMilestonePath } from "./paths.js";
 import { queryJournal } from "./journal.js";
 import { readUnitRuntimeRecord } from "./unit-runtime.js";
 import { extractFrontmatterVerdict } from "./verdict-parser.js";
 // ─── Artifact Path Resolution ──────────────────────────────────────────────
 export function resolveHookArtifactPath(basePath, unitId, artifactName) {
     const { milestone, slice, task } = parseUnitId(unitId);
+    // Prefer the active phase directory (flat-phase layout: .gsd/phases/<NN>-.../).
+    // Configured gate artifacts are canonical phase-level files (e.g.
+    // BROWSER-RUNTIME-EVIDENCE.md), so resolve the exact declared name first,
+    // then a task-prefixed variant for retry sentinels / rework briefs.
+    const candidates = [];
+    const phaseDir = resolveMilestonePath(basePath, milestone);
+    const isFlatPhaseDir = phaseDir !== null
+        && !(dirname(phaseDir).endsWith("/milestones") || dirname(phaseDir).endsWith("\\milestones"));
+    if (isFlatPhaseDir) {
+        candidates.push(join(phaseDir, artifactName));
+        if (task !== undefined) {
+            candidates.push(join(phaseDir, `${task}-${artifactName}`));
+        }
+    }
+    // Legacy nested layout fallbacks (.gsd/milestones/<M>/slices/<S>/tasks/...).
+    const legacyBase = join(basePath, ".gsd", "milestones", milestone);
+    let legacyDefault;
     if (task !== undefined && slice !== undefined) {
-        return join(basePath, ".gsd", "milestones", milestone, "slices", slice, "tasks", `${task}-${artifactName}`);
-    }
-    if (slice !== undefined) {
-        return join(basePath, ".gsd", "milestones", milestone, "slices", slice, artifactName);
-    }
-    return join(basePath, ".gsd", "milestones", milestone, artifactName);
+        legacyDefault = join(legacyBase, "slices", slice, "tasks", `${task}-${artifactName}`);
+        candidates.push(legacyDefault);
+        candidates.push(join(legacyBase, "slices", slice, "tasks", artifactName));
+        candidates.push(join(legacyBase, "slices", slice, artifactName));
+    }
+    else if (slice !== undefined) {
+        legacyDefault = join(legacyBase, "slices", slice, artifactName);
+        candidates.push(legacyDefault);
+    }
+    else {
+        legacyDefault = join(legacyBase, artifactName);
+    }
+    candidates.push(join(legacyBase, artifactName));
+    const existing = candidates.find((candidate) => existsSync(candidate));
+    if (existing)
+        return existing;
+    // Nothing on disk yet: prefer the active phase path when the phase dir is
+    // known, otherwise fall back to the legacy default (preserves pre-flat-phase
+    // behavior for missing-artifact diagnostics).
+    return isFlatPhaseDir ? join(phaseDir, artifactName) : legacyDefault;
 }
 // ─── Dispatch Rule Conversion ──────────────────────────────────────────────
 /**
@@ -70,6 +102,13 @@ export class RuleRegistry {
     activeHook = null;
     hookQueue = [];
     cycleCounts = new Map();
+    /**
+     * Cycle keys that have already been granted a one-shot re-dispatch after a
+     * lost/interrupted dispatch (hook charged a cycle but never produced its own
+     * unit-end). Bounds the dispatch-cycle refund to exactly one per gate so a
+     * hook that repeatedly fails to complete cannot loop forever.
+     */
+    redispatchedGateKeys = new Set();
     retryPending = false;
     retryTrigger = null;
     hookFailure = null;
@@ -269,6 +308,10 @@ export class RuleRegistry {
             cycle: currentCycle,
             pendingRetry: false,
         };
+        return this._buildHookDispatch(config, triggerUnitId);
+    }
+    /** Construct the sidecar dispatch for a hook without mutating registry state. */
+    _buildHookDispatch(config, triggerUnitId) {
         const { milestone: mid, slice: sid, task: tid } = parseUnitId(triggerUnitId);
         let prompt = config.prompt
             .replace(/\{milestoneId\}/g, mid ?? "")
@@ -278,11 +321,27 @@ export class RuleRegistry {
         return {
             hookName: config.name,
             prompt,
-            model: config.model,
+            // Model selection (including fallbacks[]) is handled by
+            // resolveModelWithFallbacksForUnit for the `hook/<name>` unit type (#1229).
             unitType: `hook/${config.name}`,
             unitId: triggerUnitId,
         };
     }
+    /**
+     * Reconstruct the in-flight hook's dispatch from the restored `activeHook`
+     * state, without mutating the registry. Used to reconcile a persisted
+     * `activeHook` whose session-local dispatch was lost across a pause/resume
+     * or crash-recovery, so the hook actually runs instead of being charged
+     * against the next unrelated unit's close-out (#1246).
+     */
+    getPendingHookDispatch(basePath) {
+        if (!this.activeHook)
+            return null;
+        const config = resolvePostUnitHooks(basePath).find(h => h.name === this.activeHook.hookName);
+        if (!config)
+            return null;
+        return this._buildHookDispatch(config, this.activeHook.triggerUnitId);
+    }
     _assessHookCompletion(basePath, hook) {
         return this._assessConfiguredHookCompletion(basePath, hook.hookName, hook.triggerUnitId);
     }
@@ -368,6 +427,30 @@ export class RuleRegistry {
     }
     _handleBlockingGateCompletion(config, hook, basePath, observedCleanExecution) {
         if (!observedCleanExecution) {
+            // The hook was charged a cycle at dispatch but never produced its own
+            // unit-end — its dispatch was lost/interrupted (pause/resume, crash
+            // recovery). Refund that dispatch-consumed cycle exactly once so the gate
+            // is re-dispatched at least once instead of hard-blocking on a hook that
+            // never actually ran.
+            //
+            // This refund is intentionally UNCONDITIONAL on the first lost dispatch —
+            // it must NOT be gated on `currentCycle >= max_cycles`. A lost dispatch is
+            // a non-run: charging its cycle at dispatch time must not consume the
+            // hook's real-run budget. Gating the refund on "budget already exhausted"
+            // lets a lost dispatch below max_cycles silently eat a genuine cycle, so
+            // the hook gets one fewer real run than configured — reintroducing #1244
+            // for max_cycles >= 2 (see the "does not steal a real-run cycle" test).
+            // The redispatchedGateKeys flag bounds this to a single refund per gate,
+            // so repeated lost dispatches still terminate (total dispatches never
+            // exceed max_cycles + 1) and a hook that keeps failing blocks normally.
+            const cycleKey = hookCycleKey(config, hook);
+            if (!this.redispatchedGateKeys.has(cycleKey)) {
+                this.redispatchedGateKeys.add(cycleKey);
+                const currentCycle = this.cycleCounts.get(cycleKey);
+                if (typeof currentCycle === "number" && currentCycle > 0) {
+                    this.cycleCounts.set(cycleKey, currentCycle - 1);
+                }
+            }
             return this._rerunGateOrBlock(config, hook, basePath, {
                 reason: `hook/${config.name} did not complete cleanly before the trigger unit resumed`,
             });
@@ -639,6 +722,7 @@ export class RuleRegistry {
         this.activeHook = null;
         this.hookQueue = [];
         this.cycleCounts.clear();
+        this.redispatchedGateKeys.clear();
         this.retryPending = false;
         this.retryTrigger = null;
         this.hookFailure = null;
@@ -652,6 +736,7 @@ export class RuleRegistry {
     persistState(basePath) {
         const state = {
             cycleCounts: Object.fromEntries(this.cycleCounts),
+            redispatchedGateKeys: Array.from(this.redispatchedGateKeys),
             activeHook: this.activeHook ? { ...this.activeHook } : null,
             hookQueue: this.hookQueue.map(entry => ({
                 hookName: entry.config.name,
@@ -687,6 +772,14 @@ export class RuleRegistry {
                     }
                 }
             }
+            this.redispatchedGateKeys.clear();
+            if (Array.isArray(state.redispatchedGateKeys)) {
+                for (const key of state.redispatchedGateKeys) {
+                    if (typeof key === "string") {
+                        this.redispatchedGateKeys.add(key);
+                    }
+                }
+            }
             this.activeHook = state.activeHook && typeof state.activeHook === "object"
                 ? { ...state.activeHook }
                 : null;
@@ -715,7 +808,7 @@ export class RuleRegistry {
         try {
             const filePath = this._hookStatePath(basePath);
             if (existsSync(filePath)) {
-                writeFileSync(filePath, JSON.stringify({ cycleCounts: {}, activeHook: null, hookQueue: [], savedAt: new Date().toISOString() }, null, 2), "utf-8");
+                writeFileSync(filePath, JSON.stringify({ cycleCounts: {}, redispatchedGateKeys: [], activeHook: null, hookQueue: [], savedAt: new Date().toISOString() }, null, 2), "utf-8");
             }
         }
         catch (e) {
@@ -793,7 +886,10 @@ export class RuleRegistry {
         return {
             hookName: hook.name,
             prompt,
-            model: hook.model,
+            // Model selection (including fallbacks[]) is resolved by dispatchHookUnit
+            // via resolveModelWithFallbacksForUnit for the `hook/<name>` unit type,
+            // matching the auto-mode path. Emitting the primary-only model here would
+            // discard the configured fallback chain (#1229).
             unitType: `hook/${hook.name}`,
             unitId,
         };

package/dist/resources/extensions/gsd/session-status-io.js

@@ -18,6 +18,11 @@ const PARALLEL_DIR = "parallel";
 const STATUS_SUFFIX = ".status.json";
 const SIGNAL_SUFFIX = ".signal.json";
 const DEFAULT_STALE_TIMEOUT_MS = 30_000;
+// How long a paused worker waits for the coordinator to lift the pause before
+// it degrades to in-process serialization (#1273). Kept below the stale
+// timeout so the wait never races the coordinator's liveness detection.
+const DEFAULT_RESUME_WAIT_MS = 10_000;
+const DEFAULT_RESUME_POLL_MS = 250;
 function isSessionStatus(data) {
     return data !== null && typeof data === "object" && "milestoneId" in data && "pid" in data;
 }
@@ -105,6 +110,32 @@ export function consumeSignal(basePath, milestoneId) {
     }
     return msg;
 }
+/**
+ * Wait for a coordinator to lift a `pause` on a worker by sending `resume`
+ * (or `stop`). Polls the signal file until one of those arrives or the timeout
+ * elapses. Intervening `pause`/`rebase` signals are consumed and ignored so a
+ * repeated pause doesn't reset the wait.
+ *
+ * A worker's `pause` is only ever lifted by the interactive/dashboard resumer;
+ * unattended `gsd headless auto` owns no resumer, so callers use the `"timeout"`
+ * result to degrade to in-process serialization instead of stranding the worker
+ * at a terminal pause it cannot resume (#1273).
+ */
+export async function awaitWorkerResume(basePath, milestoneId, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_RESUME_WAIT_MS;
+    const pollMs = opts.pollMs ?? DEFAULT_RESUME_POLL_MS;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const msg = consumeSignal(basePath, milestoneId);
+        if (msg?.signal === "resume")
+            return "resume";
+        if (msg?.signal === "stop")
+            return "stop";
+        if (Date.now() >= deadline)
+            return "timeout";
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}
 // ─── Stale Detection ───────────────────────────────────────────────────────
 /** Check whether a session is stale (PID dead or heartbeat timed out). */
 export function isSessionStale(status, timeoutMs = DEFAULT_STALE_TIMEOUT_MS) {

package/dist/resources/extensions/gsd/skill-discovery.js

@@ -8,41 +8,49 @@
  * prompt block when reload fails before the next agent turn.
  */
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { getSkillDirectories } from "@gsd/pi-coding-agent";
 import { gsdHome } from "./gsd-home.js";
 import { getInstalledSkills, normalizeSkillName } from "./skills.js";
-/** Snapshot of normalized skill names at auto-mode start */
-let baselineSkills = null;
+let snapshot = null;
 /**
  * Snapshot the current installed skill catalog. Call at auto-mode start.
+ * `cwd` is the project base path; skills dropped into `<cwd>/.agents/skills/`,
+ * `<cwd>/.claude/skills/`, or `<cwd>/.gsd/skills/` mid-session are detected.
  */
-export function snapshotSkills() {
-    baselineSkills = snapshotCurrentSkillNames();
+export function snapshotSkills(options) {
+    const searchDirs = getSkillDirectories({
+        cwd: options?.cwd ?? process.cwd(),
+        gsdHome: gsdHome(),
+    }).map((entry) => entry.path);
+    snapshot = {
+        baselineNames: snapshotCurrentSkillNames(searchDirs),
+        searchDirs,
+    };
 }
 /**
  * Clear the snapshot. Call when auto-mode stops.
  */
 export function clearSkillSnapshot() {
-    baselineSkills = null;
+    snapshot = null;
 }
 /**
  * Check if a snapshot is active (auto-mode is running with discovery).
  */
 export function hasSkillSnapshot() {
-    return baselineSkills !== null;
+    return snapshot !== null;
 }
 /**
  * Detect skills installed since the snapshot was taken.
  * Returns skill metadata for any new skills found in the loader catalog or on disk.
  */
 export function detectNewSkills() {
-    if (!baselineSkills)
+    if (!snapshot)
         return [];
     const newSkills = [];
-    for (const skill of getCurrentSkillsForDiscovery()) {
+    for (const skill of getCurrentSkillsForDiscovery(snapshot.searchDirs)) {
         const normalized = normalizeSkillName(skill.name);
-        if (baselineSkills.has(normalized))
+        if (snapshot.baselineNames.has(normalized))
             continue;
         newSkills.push(skill);
     }
@@ -68,7 +76,13 @@ export async function refreshCatalogForNewSkills(options) {
             return newSkills;
         }
     }
-    snapshotSkills();
+    // Re-snapshot, preserving the search dirs captured at auto-mode start.
+    if (snapshot) {
+        snapshot = {
+            baselineNames: snapshotCurrentSkillNames(),
+            searchDirs: snapshot.searchDirs,
+        };
+    }
     const names = newSkills.map((skill) => skill.name).join(", ");
     options?.notify?.(`GSD: loaded new skills: ${names}`, "info");
     return newSkills;
@@ -103,17 +117,16 @@ function escapeXml(value) {
         }
     });
 }
-function skillSearchDirs() {
-    return [
-        join(gsdHome(), "agent", "skills"),
-        join(homedir(), ".agents", "skills"),
-        join(homedir(), ".claude", "skills"),
-    ];
+function snapshotCurrentSkillNames(searchDirsOverride) {
+    // Uses explicit dirs, the snapshot's search dirs when active, or user-only dirs
+    // (no project context) when called before a snapshot is taken.
+    const searchDirs = searchDirsOverride ?? snapshot?.searchDirs ?? defaultSearchDirs();
+    return new Set(getCurrentSkillsForDiscovery(searchDirs).map(skill => normalizeSkillName(skill.name)));
 }
-function snapshotCurrentSkillNames() {
-    return new Set(getCurrentSkillsForDiscovery().map(skill => normalizeSkillName(skill.name)));
+function defaultSearchDirs() {
+    return getSkillDirectories({ cwd: process.cwd(), gsdHome: gsdHome() }).map((entry) => entry.path);
 }
-function getCurrentSkillsForDiscovery() {
+function getCurrentSkillsForDiscovery(searchDirs) {
     const skills = new Map();
     for (const skill of getInstalledSkills()) {
         const normalized = normalizeSkillName(skill.name);
@@ -123,16 +136,16 @@ function getCurrentSkillsForDiscovery() {
             location: skill.filePath,
         });
     }
-    for (const skill of getDiskSkills()) {
+    for (const skill of getDiskSkills(searchDirs)) {
         const normalized = normalizeSkillName(skill.name);
         if (!skills.has(normalized))
             skills.set(normalized, skill);
     }
     return [...skills.values()];
 }
-function getDiskSkills() {
+function getDiskSkills(searchDirs) {
     const skills = new Map();
-    for (const dir of skillSearchDirs()) {
+    for (const dir of searchDirs) {
         if (!existsSync(dir))
             continue;
         let entries;

package/dist/resources/extensions/gsd/slice-parallel-orchestrator.js

@@ -19,7 +19,8 @@ import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
-import { runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { syncGsdStateToWorktreeByScope } from "./auto-worktree-sync.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { writeSessionStatus, } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";