gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -6,9 +6,10 @@ import { deriveState } from "./state.js";
 import { saveFile } from "./files.js";
 import { nativeIsRepo, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
 import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
-import { ensureGitignore } from "./gitignore.js";
+import { ensureGitignore, isGsdGitignored } from "./gitignore.js";
 import { readAllSessionStatuses, isSessionStale, removeSessionStatus } from "./session-status-io.js";
 import { recoverFailedMigration } from "./migrate-external.js";
+import { splitCompletedKey } from "./forensics.js";
 export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldFix) {
     const root = gsdRoot(basePath);
     // ── Stale crash lock ──────────────────────────────────────────────────
@@ -107,9 +108,6 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
             const keys = JSON.parse(raw);
             const orphaned = [];
             for (const key of keys) {
-                // Key format: "unitType/unitId" e.g. "execute-task/M001/S01/T01"
-                // Hook units have compound types: "hook/<hookName>/unitId"
-                const { splitCompletedKey } = await import("./forensics.js");
                 const parsed = splitCompletedKey(key);
                 if (!parsed)
                     continue;
@@ -352,6 +350,26 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                         fixable: false,
                     });
                 }
+                // ── Symlinked .gsd without .gitignore entry (#4423) ──
+                // When `.gsd` is a symlink AND not gitignored, `git add -A -- :!.gsd/...`
+                // pathspecs fail with "beyond a symbolic link". Without self-heal this
+                // silently drops new user files during auto-commit.
+                if (nativeIsRepo(basePath) && !isGsdGitignored(basePath)) {
+                    issues.push({
+                        severity: "warning",
+                        code: "symlinked_gsd_unignored",
+                        scope: "project",
+                        unitId: "project",
+                        message: ".gsd is a symlink to external state but is not listed in .gitignore. This causes git pathspec exclusions to fail and can lead to silently dropped new files during auto-commit. Add `.gsd` to .gitignore.",
+                        file: ".gitignore",
+                        fixable: true,
+                    });
+                    if (shouldFix("symlinked_gsd_unignored")) {
+                        const modified = ensureGitignore(basePath);
+                        if (modified)
+                            fixesApplied.push("added .gsd to .gitignore (symlinked external state)");
+                    }
+                }
             }
         }
     }

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

@@ -154,8 +154,14 @@ function auditRequirements(content) {
         const owner = block.match(/^-\s+Primary owning slice:\s+(.+)$/m)?.[1]?.trim().toLowerCase() ?? "";
         const notes = block.match(/^-\s+Notes:\s+(.+)$/m)?.[1]?.trim().toLowerCase() ?? "";
         if (status === "active" && (!owner || owner === "none" || owner === "none yet")) {
+            // #4414: Downgrade to warning. A newly-created requirement has
+            // primary_owner='' by default until the planning agent wires it to
+            // a slice via gsd_requirement_update. Flagging this as an error
+            // during normal planning is noisy — the real failure mode is when
+            // it persists past milestone completion, which is covered by other
+            // audits. Keep the signal but don't treat it as a blocker.
             issues.push({
-                severity: "error",
+                severity: "warning",
                 code: "active_requirement_missing_owner",
                 scope: "project",
                 unitId: requirementId,

package/dist/resources/extensions/gsd/ecosystem/gsd-extension-api.js

@@ -0,0 +1,144 @@
+// GSD2 — Ecosystem Extension API wrapper
+// Wraps pi's ExtensionAPI to expose typed GSD context (phase + active unit)
+// to extensions loaded from `./.gsd/extensions/`. The wrapper intercepts only
+// `on("before_agent_start", ...)` so GSD can dispatch ecosystem handlers AFTER
+// refreshing state — fixing the load-order race where third-party
+// `.pi/extensions/` handlers see a stale module-level snapshot (#3338).
+//
+// SINGLE-SESSION INVARIANT: the module-level `_snapshot` is per-process.
+// Worktree or project switches do NOT reload extensions, matching pi's
+// `.pi/extensions/` behavior. Only re-launching the CLI rebinds the snapshot.
+import { isGSDActive, getCurrentPhase } from "../../shared/gsd-phase-state.js";
+import { logWarning } from "../workflow-logger.js";
+// ─── Auto-loop phase mapping ────────────────────────────────────────────
+const AUTO_LOOP_PHASE_MAP = {
+    "plan-milestone": "planning",
+    "plan-slice": "planning",
+    "research": "researching",
+    "discuss": "discussing",
+    "execute-task": "executing",
+    "verify": "verifying",
+    "summarize-task": "summarizing",
+    "summarize-slice": "summarizing",
+    "advance": "advancing",
+    "validate-milestone": "validating-milestone",
+    "complete-milestone": "completing-milestone",
+    "replan-slice": "replanning-slice",
+};
+/** Exposed for unit tests. Returns null for unknown keys (does NOT default). */
+export function mapAutoLoopPhase(raw) {
+    return AUTO_LOOP_PHASE_MAP[raw] ?? null;
+}
+function resolvePhase(state) {
+    if (!state)
+        return null;
+    if (isGSDActive()) {
+        const raw = getCurrentPhase();
+        if (raw != null) {
+            const mapped = AUTO_LOOP_PHASE_MAP[raw];
+            if (mapped)
+                return mapped;
+            logWarning("ecosystem", `unknown auto-loop phase: ${raw}`);
+            // FALL THROUGH to state.phase rather than defaulting to "executing".
+        }
+    }
+    return state.phase;
+}
+function resolveActiveUnit(state) {
+    if (!state)
+        return null;
+    const m = state.activeMilestone;
+    const s = state.activeSlice;
+    const t = state.activeTask;
+    if (!m || !s || !t)
+        return null;
+    return {
+        milestoneId: m.id,
+        milestoneTitle: m.title,
+        sliceId: s.id,
+        sliceTitle: s.title,
+        taskId: t.id,
+        taskTitle: t.title,
+    };
+}
+let _snapshot = { phase: null, activeUnit: null };
+/** Refresh the snapshot from a freshly derived GSDState (or null on failure). */
+export function updateSnapshot(state) {
+    _snapshot = {
+        phase: resolvePhase(state),
+        activeUnit: resolveActiveUnit(state),
+    };
+}
+export function getSnapshotPhase() {
+    return _snapshot.phase;
+}
+export function getSnapshotActiveUnit() {
+    return _snapshot.activeUnit;
+}
+/** Test-only: reset the snapshot to its initial empty state. */
+export function _resetSnapshot() {
+    _snapshot = { phase: null, activeUnit: null };
+}
+// ─── Wrapper factory ────────────────────────────────────────────────────
+/**
+ * Build a GSDExtensionAPI by manually delegating every ExtensionAPI method
+ * to the underlying pi instance, except `on("before_agent_start", ...)`
+ * which is captured into `sharedHandlers` for GSD-owned dispatch.
+ *
+ * Uses `satisfies GSDExtensionAPI` (NOT `as`) so TypeScript catches drift
+ * when pi adds new ExtensionAPI methods.
+ */
+export function createGSDExtensionAPI(pi, sharedHandlers) {
+    const wrapper = {
+        // ── Event subscription (single intercept point) ────────────────────
+        on(event, handler) {
+            if (event === "before_agent_start") {
+                sharedHandlers.push(handler);
+                return;
+            }
+            pi.on(event, handler);
+        },
+        // ── Event emission ─────────────────────────────────────────────────
+        emitBeforeModelSelect: (...args) => pi.emitBeforeModelSelect(...args),
+        emitAdjustToolSet: (...args) => pi.emitAdjustToolSet(...args),
+        // ── Tool / command / shortcut / flag registration ──────────────────
+        registerTool: ((tool) => pi.registerTool(tool)),
+        registerCommand: (...args) => pi.registerCommand(...args),
+        registerBeforeInstall: (...args) => pi.registerBeforeInstall(...args),
+        registerAfterInstall: (...args) => pi.registerAfterInstall(...args),
+        registerBeforeRemove: (...args) => pi.registerBeforeRemove(...args),
+        registerAfterRemove: (...args) => pi.registerAfterRemove(...args),
+        registerShortcut: (...args) => pi.registerShortcut(...args),
+        registerFlag: (...args) => pi.registerFlag(...args),
+        getFlag: (...args) => pi.getFlag(...args),
+        // ── Message rendering ──────────────────────────────────────────────
+        registerMessageRenderer: ((customType, renderer) => pi.registerMessageRenderer(customType, renderer)),
+        // ── Actions ────────────────────────────────────────────────────────
+        sendMessage: ((message, options) => pi.sendMessage(message, options)),
+        sendUserMessage: (...args) => pi.sendUserMessage(...args),
+        retryLastTurn: () => pi.retryLastTurn(),
+        appendEntry: ((customType, data) => pi.appendEntry(customType, data)),
+        // ── Session metadata ───────────────────────────────────────────────
+        setSessionName: (...args) => pi.setSessionName(...args),
+        getSessionName: () => pi.getSessionName(),
+        setLabel: (...args) => pi.setLabel(...args),
+        exec: (...args) => pi.exec(...args),
+        getActiveTools: () => pi.getActiveTools(),
+        getAllTools: () => pi.getAllTools(),
+        setActiveTools: (...args) => pi.setActiveTools(...args),
+        getCommands: () => pi.getCommands(),
+        // ── Model & thinking ───────────────────────────────────────────────
+        setModel: (...args) => pi.setModel(...args),
+        getThinkingLevel: () => pi.getThinkingLevel(),
+        setThinkingLevel: (...args) => pi.setThinkingLevel(...args),
+        // ── Provider registration ──────────────────────────────────────────
+        registerProvider: (...args) => pi.registerProvider(...args),
+        unregisterProvider: (...args) => pi.unregisterProvider(...args),
+        // ── Shared event bus (passthrough property) ────────────────────────
+        events: pi.events,
+        // ── GSD-specific additions ─────────────────────────────────────────
+        getPhase: () => _snapshot.phase,
+        getActiveUnit: () => _snapshot.activeUnit,
+    };
+    return wrapper;
+}

package/dist/resources/extensions/gsd/ecosystem/loader.js

@@ -0,0 +1,145 @@
+// GSD2 — Ecosystem extension loader for ./.gsd/extensions/
+// Discovers and registers single-file extensions that consume GSDExtensionAPI.
+// Trust-gated (mirrors pi's `.pi/extensions/` model) and isolated from pi's
+// own loader chain — handlers run in GSD's own dispatch step, not pi's.
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+import { logWarning } from "../workflow-logger.js";
+import { createGSDExtensionAPI, } from "./gsd-extension-api.js";
+// ─── Trust check (inlined; pi does not export isProjectTrusted from its
+// package root, and constraint forbids modifying packages/pi-coding-agent/) ─
+const TRUSTED_PROJECTS_FILE = "trusted-projects.json";
+function isProjectTrusted(projectPath, agentDir) {
+    const canonical = path.resolve(projectPath);
+    const trustedPath = path.join(agentDir, TRUSTED_PROJECTS_FILE);
+    try {
+        const content = fs.readFileSync(trustedPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed)) {
+            return parsed.includes(canonical);
+        }
+    }
+    catch {
+        // missing or malformed — treat as untrusted
+    }
+    return false;
+}
+// ─── Ready-promise singleton ────────────────────────────────────────────
+let _readyPromise = null;
+let _untrustedWarned = false;
+/**
+ * Discover and register ecosystem extensions from `./.gsd/extensions/`.
+ * Idempotent: subsequent calls with the same arguments return the same
+ * pending promise (no double-load).
+ */
+export function loadEcosystemExtensions(pi, sharedHandlers, cwd = process.cwd()) {
+    if (_readyPromise)
+        return _readyPromise;
+    _readyPromise = _loadEcosystemExtensionsImpl(pi, sharedHandlers, cwd);
+    return _readyPromise;
+}
+/**
+ * Returns a promise that resolves when ecosystem loading has completed.
+ * If loading was never kicked off this returns a resolved promise so the
+ * `before_agent_start` handler can `await` unconditionally.
+ */
+export function getEcosystemReadyPromise() {
+    return _readyPromise ?? Promise.resolve();
+}
+/** Test-only: clear the singleton so tests can re-run loading. */
+export function _resetEcosystemLoader() {
+    _readyPromise = null;
+    _untrustedWarned = false;
+}
+// ─── Implementation ─────────────────────────────────────────────────────
+async function _loadEcosystemExtensionsImpl(pi, sharedHandlers, cwd) {
+    const extDir = path.join(cwd, ".gsd", "extensions");
+    if (!fs.existsSync(extDir))
+        return;
+    // Trust gate: refuse to load arbitrary code from untrusted project dirs.
+    if (!isProjectTrusted(cwd, getAgentDir())) {
+        if (!_untrustedWarned) {
+            _untrustedWarned = true;
+            logWarning("ecosystem", ".gsd/extensions present but project is not trusted — skipping ecosystem extensions. Run `pi trust` to opt in.");
+        }
+        return;
+    }
+    // Resolve realpath ONCE so symlink-escape detection has a stable anchor.
+    let realExtDir;
+    try {
+        realExtDir = fs.realpathSync(extDir);
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to resolve extensions dir: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    let entries;
+    try {
+        entries = fs
+            .readdirSync(extDir)
+            .filter((f) => f.endsWith(".js") || f.endsWith(".ts"))
+            .sort(); // deterministic load order
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to read extensions dir: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // The wrapper api is built once per loader run and shared by all extensions
+    // so they all read from the same module-level snapshot.
+    const api = createGSDExtensionAPI(pi, sharedHandlers);
+    for (const entry of entries) {
+        await _loadOne(extDir, realExtDir, entry, api);
+    }
+}
+async function _loadOne(extDir, realExtDir, entry, api) {
+    const fullPath = path.join(extDir, entry);
+    // Symlink-escape guard: reject entries whose realpath is not under realExtDir.
+    let realFullPath;
+    try {
+        realFullPath = fs.realpathSync(fullPath);
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to resolve ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    const realExtDirWithSep = realExtDir.endsWith(path.sep) ? realExtDir : realExtDir + path.sep;
+    if (realFullPath !== realExtDir &&
+        !realFullPath.startsWith(realExtDirWithSep)) {
+        logWarning("ecosystem", `rejecting ${entry}: realpath escapes extensions dir`);
+        return;
+    }
+    // For .ts files, require a sibling compiled .js — we do not run a TS loader
+    // in production. Drop mtime heuristics: if .js exists, prefer it; otherwise warn.
+    let importPath = realFullPath;
+    if (entry.endsWith(".ts")) {
+        const jsSibling = realFullPath.slice(0, -3) + ".js";
+        if (fs.existsSync(jsSibling)) {
+            importPath = jsSibling;
+        }
+        else {
+            logWarning("ecosystem", `${entry}: TypeScript source has no compiled .js sibling — compile it first`);
+            return;
+        }
+    }
+    let mod;
+    try {
+        mod = await import(pathToFileURL(importPath).href);
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to import ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    const factory = mod?.default;
+    if (typeof factory !== "function") {
+        logWarning("ecosystem", `${entry}: default export is not a function`);
+        return;
+    }
+    try {
+        await factory(api);
+    }
+    catch (err) {
+        logWarning("ecosystem", `factory threw for ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/resources/extensions/gsd/error-classifier.js

@@ -19,11 +19,14 @@ export function resetRetryState(state) {
 }
 // ── Classification ──────────────────────────────────────────────────────────
 const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
-const RATE_LIMIT_RE = /rate.?limit|too many requests|429/i;
+// Include provider-specific quota-window phrasing like:
+// - "You've hit your limit"
+// - "usage limit" / "quota reached"
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429|hit your limit|usage limit|quota (?:reached|hit)|limit.*resets?/i;
 // OpenRouter affordability-style quota errors should be treated as transient
 // so core retry logic can lower maxTokens and continue in-session.
 const AFFORDABILITY_RE = /requires more credits|can only afford|insufficient credits|not enough credits|fewer max_tokens/i;
-const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i;
+const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns|unexpected eof/i;
 const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
 const CONNECTION_RE = /terminated|connection.?(?:refused|error)|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
@@ -36,7 +39,7 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
  *
  * Classification order:
  *  1. Permanent (auth/billing/quota) — unless also rate-limited
- *  2. Rate limit (429, rate.?limit, too many requests)
+ *  2. Rate limit (429, rate.?limit, too many requests, hit-your-limit/quota-window phrasing)
  *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
  *  4. Stream truncation (malformed JSON from mid-stream cut)
  *  5. Server (500/502/503, overloaded, server_error)