@opengsd/gsd-pi 1.5.0 → 1.6.0

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

@@ -822,6 +822,26 @@ export function renderPreferencesForSystemPrompt(preferences, resolutions, optio
     }
     return lines.join("\n");
 }
+/**
+ * Render a compact response-language directive for injection into dispatched
+ * prompt *content* (discuss/QA and auto-execution unit prompts).
+ *
+ * The main session's system prompt already carries the full GSD Skill
+ * Preferences block (including language) via `before_agent_start`, but
+ * discuss/QA turns and auto-execution units are dispatched as separate
+ * turns/sessions whose prompts are assembled here — without that block — so the
+ * configured language never reaches them (#1210). Injecting this directive into
+ * the dispatched prompt content makes the `language` preference effective across
+ * both guided and auto workflows.
+ *
+ * Returns "" when no language is configured.
+ */
+export function renderLanguageDirectiveForPrompt(preferences) {
+    if (!preferences?.language)
+        return "";
+    const safeLang = preferences.language.replace(/[\r\n]/g, " ").slice(0, 50);
+    return `## Response Language\n\nAlways respond in ${safeLang} — questions, explanations, and summaries.`;
+}
 // ─── Hook Resolution ──────────────────────────────────────────────────────────
 /**
  * Resolve enabled post-unit hooks from effective preferences.

package/dist/resources/extensions/gsd/prompts/system.md

@@ -38,7 +38,7 @@ If a `GSD Skill Preferences` block appears below, treat it as durable guidance f
 
 ### Naming Convention
 
-Directories use bare IDs. Files use ID-SUFFIX format. Milestones: `M001/` or `M{seq}-{rand6}/` when `unique_milestone_ids: true`; files like `M001-CONTEXT.md`, `M001-ROADMAP.md`, `M001-RESEARCH.md`. Slices: `S01/` with `S01-PLAN.md`, `S01-RESEARCH.md`, `S01-SUMMARY.md`, `S01-UAT.md`. Tasks: `T01-PLAN.md`, `T01-SUMMARY.md`. Titles live inside content, not names.
+GSD projects use a flat-phase layout. Phase directories are `{MM}-{slug}` where `{MM}` is the zero-padded phase number and `{slug}` is derived from the phase title (e.g. `47-real-time-runtime-hardening`). Phase-level files are `{MM}-SUFFIX.md` (e.g. `47-CONTEXT.md`, `47-RESEARCH.md`, `47-ROADMAP.md`, `47-VALIDATION.md`, `47-SUMMARY.md`). Slice/plan files live directly in the phase directory as `{MM}-{SS}-SUFFIX.md` (e.g. `47-01-PLAN.md`, `47-01-SUMMARY.md`, `47-01-UAT.md`). Task plan content lives inside the slice plan file (`{MM}-{SS}-PLAN.md`) as checkboxes; there is no `tasks/` subdirectory and no `tasks/T##-PLAN.md`. Titles live inside content, not names. Prefer GSD-provided layout-aware paths/resolvers over hardcoding artifact paths, since phase slugs are title-derived.
 
 ### Directory Structure
 
@@ -46,13 +46,13 @@ Directories use bare IDs. Files use ID-SUFFIX format. Milestones: `M001/` or `M{
 .gsd/
   PROJECT.md, REQUIREMENTS.md, DECISIONS.md, KNOWLEDGE.md, CODEBASE.md, OVERRIDES.md, QUEUE.md, STATE.md
   runtime/, activity/, worktrees/
-  milestones/M001/
-    M001-CONTEXT.md, M001-RESEARCH.md, M001-ROADMAP.md, M001-SUMMARY.md
-    slices/S01/
-      S01-CONTEXT.md, S01-RESEARCH.md, S01-PLAN.md, S01-SUMMARY.md, S01-UAT.md
-      tasks/T01-PLAN.md, tasks/T01-SUMMARY.md
+  phases/{MM}-{slug}/
+    {MM}-CONTEXT.md, {MM}-RESEARCH.md, {MM}-ROADMAP.md, {MM}-VALIDATION.md, {MM}-SUMMARY.md
+    {MM}-{SS}-PLAN.md, {MM}-{SS}-SUMMARY.md, {MM}-{SS}-UAT.md
 ```
 
+Task plan content is embedded in `{MM}-{SS}-PLAN.md`; do not expect `tasks/T##-PLAN.md`.
+
 `runtime/`, `activity/`, `worktrees/`, and `STATE.md` are system-managed. `PROJECT.md` is current state; `REQUIREMENTS.md` is the active capability contract; `DECISIONS.md` and `KNOWLEDGE.md` are append-only; `CODEBASE.md` is an auto-refreshed codebase map.
 
 ### Isolation Model

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

@@ -13,7 +13,7 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 import { QUICK_BRANCH_RE } from "./branch-patterns.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { GitServiceImpl, runGit } from "./git-service.js";
+import { GitServiceImpl, runGit, taskBranchArgs } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat } from "./native-git-bridge.js";
 import { nativeHasStagedChanges } from "./native-git-bridge.js";
@@ -317,6 +317,7 @@ export async function handleQuick(args, ctx, pi) {
     const git = new GitServiceImpl(basePath, gitPrefs);
     const branchName = `gsd/quick/${taskNum}-${slug}`;
     let originalBranch = git.getCurrentBranch();
+    let returnBranch = originalBranch;
     const { getIsolationMode } = await import("./preferences.js");
     const usesBranch = getIsolationMode() !== "none" && isGitOpsEnabled();
     let branchCreated = false;
@@ -331,7 +332,15 @@ export async function handleQuick(args, ctx, pi) {
                     }
                 }
                 catch { /* nothing to commit — fine */ }
-                runGit(basePath, ["checkout", "-b", branchName]);
+                const branchArgs = taskBranchArgs(basePath, branchName, current, git.getMainBranch());
+                const startPoint = branchArgs[3];
+                // When the quick branch is redirected off a stale task branch, the
+                // squash-merge on closeout must return to the same base — merging a
+                // base-branch-rooted quick branch back into the stale task branch
+                // would drag the base's newer history into it.
+                if (startPoint)
+                    returnBranch = startPoint;
+                runGit(basePath, branchArgs);
                 branchCreated = true;
             }
         }
@@ -345,7 +354,7 @@ export async function handleQuick(args, ctx, pi) {
     if (actualBranch === branchName && originalBranch !== branchName) {
         persistPendingReturn({
             basePath,
-            originalBranch,
+            originalBranch: returnBranch,
             quickBranch: branchName,
             taskNum,
             slug,

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/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";