gsd-pi 2.72.0-dev.3159350 → 2.72.0-dev.4f3264a

package/dist/resources/extensions/async-jobs/await-tool.js

@@ -54,14 +54,11 @@ export function createAwaitTool(getManager) {
                     };
                 }
             }
-            // Suppress follow-up notifications for all watched jobs upfront.
-            // suppressFollowUp() cancels the pending delivery timer (if any), which
-            // handles both the within-turn case (job completes while we await) and
-            // the cross-turn case (job already completed before await_job was called).
-            // Previously this only set j.awaited = true, which missed the cross-turn
-            // case because the queueMicrotask had already fired (#3787).
+            // Mark all watched jobs as awaited upfront so the onJobComplete
+            // callback (which fires synchronously in the promise .then()) knows
+            // to suppress the follow-up message.
             for (const j of watched)
-                manager.suppressFollowUp(j.id);
+                j.awaited = true;
             // If all watched jobs are already done, return immediately
             const running = watched.filter((j) => j.status === "running");
             if (running.length === 0) {

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -118,38 +118,13 @@ export class AsyncJobManager {
         }
     }
     // ── Private ────────────────────────────────────────────────────────────
-    /**
-     * Suppress follow-up notification for a job — cancels any pending delivery
-     * timer and marks the job as awaited. Safe to call at any time, including
-     * before or after the job completes (#3787).
-     */
-    suppressFollowUp(id) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return;
-        job.awaited = true;
-        if (job.deliveryTimer !== undefined) {
-            clearTimeout(job.deliveryTimer);
-            job.deliveryTimer = undefined;
-        }
-    }
     deliverResult(job) {
         if (!this.onJobComplete)
             return;
-        // Use setTimeout(0) instead of queueMicrotask so the handle is cancellable.
-        // suppressFollowUp() can clear this timer even when await_job is called in
-        // a later LLM turn (after the job already completed). queueMicrotask ran
-        // immediately and could not be cancelled (#2762, #3787).
+        // Defer delivery by one microtask so await_job's .then() chain runs first
+        // and can set job.awaited = true before onJobComplete checks it (#2762).
         const cb = this.onJobComplete;
-        job.deliveryTimer = setTimeout(() => {
-            job.deliveryTimer = undefined;
-            if (!job.awaited)
-                cb(job);
-        }, 0);
-        // Allow process to exit even if timer is pending
-        if (typeof job.deliveryTimer === "object" && "unref" in job.deliveryTimer) {
-            job.deliveryTimer.unref();
-        }
+        queueMicrotask(() => cb(job));
     }
     scheduleEviction(id) {
         const existing = this.evictionTimers.get(id);

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -405,25 +405,32 @@ export function makeAbortedMessage(model, lastTextContent) {
 /**
  * Resolve the Claude Code permission mode for the current run.
  *
- * GSD subagents run underneath a host Claude Code session the user has
- * already consented to, and their work (edits, shell inspection, MCP calls)
- * spans the full workflow toolset. Defaulting the inner SDK to
- * `bypassPermissions` avoids per-tool approval prompts that offer no
- * meaningful safety beyond what the host session and the subagent prompts
- * already enforce. `GSD_CLAUDE_CODE_PERMISSION_MODE` lets security-conscious
- * users opt into a stricter mode (`acceptEdits`, `default`, `plan`).
+ * - Auto-mode / headless runs bypass permissions so tool calls don't block
+ *   on prompts the user isn't watching.
+ * - Interactive runs default to `acceptEdits` so file/bash writes still
+ *   land quickly but the SDK retains a permission gate.
+ * - `GSD_CLAUDE_CODE_PERMISSION_MODE` forces a specific mode when set.
  *
- * Tradeoff: bypass means a prompt-injection payload read from an untrusted
- * file could trigger tool calls without a second gate. Accepted for GSD
- * because the workflow is explicit user intent and the alternative
- * (#4099) is continuous approval fatigue that blocks real work.
+ * Cross-extension coupling is kept minimal by dynamically importing
+ * `isAutoActive` and falling back to the bypass default if the import
+ * fails (e.g. in unit tests that load stream-adapter in isolation).
  */
 export async function resolveClaudePermissionMode(env = process.env) {
     const override = env.GSD_CLAUDE_CODE_PERMISSION_MODE?.trim();
     if (override === "bypassPermissions" || override === "acceptEdits" || override === "default" || override === "plan") {
         return override;
     }
-    return "bypassPermissions";
+    try {
+        const autoMod = (await import("../gsd/auto.js"));
+        if (typeof autoMod.isAutoActive === "function" && autoMod.isAutoActive()) {
+            return "bypassPermissions";
+        }
+        return "acceptEdits";
+    }
+    catch {
+        // auto.ts unavailable (tests, non-GSD contexts) — stay permissive.
+        return "bypassPermissions";
+    }
 }
 /**
  * Build the options object passed to the Claude Agent SDK's `query()` call.
@@ -440,21 +447,13 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     const disallowedTools = ["AskUserQuestion"];
-    // Pre-authorize the safe built-ins and every registered workflow MCP
-    // server's tools. `acceptEdits` mode (the interactive default) only
-    // auto-approves file edits — Read/Glob/Grep, basic shell inspection, and
-    // every `mcp__gsd-workflow__*` call still surface as "This command
-    // requires approval" and block GSD actions (#4099).
-    const allowedTools = [
-        "Read",
-        "Write",
-        "Edit",
-        "Glob",
-        "Grep",
-        "Bash(ls:*)",
-        "Bash(pwd)",
-        ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
-    ];
+    // Pre-authorize every registered workflow MCP server's tools. Without this,
+    // `acceptEdits` mode (the interactive default) auto-approves built-in
+    // Edit/Write/Bash but still gates MCP calls like `mcp__gsd-workflow__*`,
+    // surfacing "This command requires approval" on every GSD action (#4099).
+    const allowedTools = mcpServers
+        ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`)
+        : [];
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,

package/dist/resources/extensions/gsd/auto/loop.js

@@ -13,69 +13,6 @@ import { runPreDispatch, runDispatch, runGuards, runUnitPhase, runFinalize, } fr
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterMs, COOLDOWN_FALLBACK_WAIT_MS, MAX_COOLDOWN_RETRIES } from "./infra-errors.js";
 import { resolveEngine } from "../engine-resolver.js";
-import { logWarning } from "../workflow-logger.js";
-import { gsdRoot } from "../paths.js";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-// ── Stuck detection persistence (#3704) ──────────────────────────────────
-// Persist stuck detection state to disk so it survives session restarts.
-// Without this, restarting auto-mode resets all counters, allowing the
-// same blocked unit to burn a full retry budget each session.
-function stuckStatePath(basePath) {
-    return join(gsdRoot(basePath), "runtime", "stuck-state.json");
-}
-function loadStuckState(basePath) {
-    try {
-        const data = JSON.parse(readFileSync(stuckStatePath(basePath), "utf-8"));
-        return {
-            recentUnits: Array.isArray(data.recentUnits) ? data.recentUnits : [],
-            stuckRecoveryAttempts: typeof data.stuckRecoveryAttempts === "number" ? data.stuckRecoveryAttempts : 0,
-        };
-    }
-    catch (err) {
-        debugLog("autoLoop", { phase: "load-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
-        return { recentUnits: [], stuckRecoveryAttempts: 0 };
-    }
-}
-function saveStuckState(basePath, state) {
-    try {
-        const filePath = stuckStatePath(basePath);
-        mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
-        writeFileSync(filePath, JSON.stringify({
-            recentUnits: state.recentUnits.slice(-20), // keep last 20 entries
-            stuckRecoveryAttempts: state.stuckRecoveryAttempts,
-            updatedAt: new Date().toISOString(),
-        }) + "\n");
-    }
-    catch (err) {
-        debugLog("autoLoop", { phase: "save-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
-    }
-}
-// ── Memory pressure monitoring (#3331) ──────────────────────────────────
-// Check heap usage every N iterations and trigger graceful shutdown before
-// the OS OOM killer sends SIGKILL. The threshold is 90% of the V8 heap
-// limit (--max-old-space-size or default ~1.5-4GB depending on platform).
-const MEMORY_CHECK_INTERVAL = 5; // check every 5 iterations
-const MEMORY_PRESSURE_THRESHOLD = 0.85; // 85% of heap limit
-function checkMemoryPressure() {
-    const mem = process.memoryUsage();
-    // v8.getHeapStatistics() gives heap_size_limit but requires import
-    // Use a conservative estimate: RSS > 3GB is danger zone on most systems
-    const heapMB = Math.round(mem.heapUsed / 1024 / 1024);
-    const rssMB = Math.round(mem.rss / 1024 / 1024);
-    // Try to get the actual V8 heap limit
-    let limitMB = 4096; // conservative default
-    try {
-        const v8 = require("node:v8");
-        const stats = v8.getHeapStatistics();
-        limitMB = Math.round(stats.heap_size_limit / 1024 / 1024);
-    }
-    catch {
-        limitMB = 4096; /* v8 stats unavailable — use conservative default */
-    }
-    const pct = heapMB / limitMB;
-    return { pressured: pct > MEMORY_PRESSURE_THRESHOLD, heapMB, limitMB, pct };
-}
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
@@ -87,13 +24,7 @@ function checkMemoryPressure() {
 export async function autoLoop(ctx, pi, s, deps) {
     debugLog("autoLoop", { phase: "enter" });
     let iteration = 0;
-    // Load persisted stuck state so counters survive session restarts (#3704)
-    const persisted = loadStuckState(s.basePath);
-    const loopState = {
-        recentUnits: persisted.recentUnits,
-        stuckRecoveryAttempts: persisted.stuckRecoveryAttempts,
-        consecutiveFinalizeTimeouts: 0,
-    };
+    const loopState = { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
     let consecutiveErrors = 0;
     let consecutiveCooldowns = 0;
     const recentErrorMessages = [];
@@ -113,19 +44,6 @@ export async function autoLoop(ctx, pi, s, deps) {
             await deps.stopAuto(ctx, pi, `Safety: loop exceeded ${MAX_LOOP_ITERATIONS} iterations — possible runaway`);
             break;
         }
-        // ── Memory pressure check (#3331) ──
-        // Graceful shutdown before OOM killer sends SIGKILL.
-        if (iteration % MEMORY_CHECK_INTERVAL === 0) {
-            const mem = checkMemoryPressure();
-            debugLog("autoLoop", { phase: "memory-check", ...mem });
-            if (mem.pressured) {
-                logWarning("dispatch", `Memory pressure: ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%) — stopping auto-mode to prevent OOM kill`);
-                await deps.stopAuto(ctx, pi, `Memory pressure: heap at ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%). ` +
-                    `Stopping gracefully to prevent OOM kill after ${iteration} iterations. ` +
-                    `Resume with /gsd auto to continue from where you left off.`);
-                break;
-            }
-        }
         if (!s.cmdCtx) {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
             break;
@@ -244,7 +162,6 @@ export async function autoLoop(ctx, pi, s, deps) {
                 consecutiveCooldowns = 0;
                 recentErrorMessages.length = 0;
                 deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
-                saveStuckState(s.basePath, loopState); // persist across session restarts (#3704)
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
                 if (reconcileResult.outcome === "milestone-complete") {
                     await deps.stopAuto(ctx, pi, "Workflow complete");

package/dist/resources/extensions/gsd/auto-observability.js

@@ -0,0 +1,54 @@
+/**
+ * Pre-dispatch observability checks for auto-mode units.
+ * Validates plan/summary file quality and builds repair instructions
+ * for the agent to fix gaps before proceeding with the unit.
+ */
+import { validatePlanBoundary, validateExecuteBoundary, validateCompleteBoundary, formatValidationIssues, } from "./observability-validator.js";
+import { parseUnitId } from "./unit-id.js";
+export async function collectObservabilityWarnings(ctx, basePath, unitType, unitId) {
+    // Hook units have custom artifacts — skip standard observability checks
+    if (unitType.startsWith("hook/"))
+        return [];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid)
+        return [];
+    let issues = [];
+    if (unitType === "plan-slice") {
+        issues = await validatePlanBoundary(basePath, mid, sid);
+    }
+    else if (unitType === "execute-task" && tid) {
+        issues = await validateExecuteBoundary(basePath, mid, sid, tid);
+    }
+    else if (unitType === "complete-slice") {
+        issues = await validateCompleteBoundary(basePath, mid, sid);
+    }
+    if (issues.length > 0) {
+        ctx.ui.notify(`Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`, "warning");
+    }
+    return issues;
+}
+export function buildObservabilityRepairBlock(issues) {
+    if (issues.length === 0)
+        return "";
+    const items = issues.map(issue => {
+        const fileName = issue.file.split("/").pop() || issue.file;
+        let line = `- **${fileName}**: ${issue.message}`;
+        if (issue.suggestion)
+            line += ` → ${issue.suggestion}`;
+        return line;
+    });
+    return [
+        "",
+        "---",
+        "",
+        "## Pre-flight: Observability gaps to fix FIRST",
+        "",
+        "The following issues were detected in plan/summary files for this unit.",
+        "**Read each flagged file, apply the fix described, then proceed with the unit.**",
+        "",
+        ...items,
+        "",
+        "---",
+        "",
+    ].join("\n");
+}

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -16,7 +16,6 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
-import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
@@ -289,11 +288,6 @@ export async function postUnitPreVerification(pctx, opts) {
                 debugLog("postUnit", { phase: "browser-teardown", status: "closed" });
             }
         });
-        // Keep the on-disk STATE.md aligned with the live derived state after
-        // ordinary unit completion, before any worktree state is synced back.
-        await runSafely("postUnit", "state-rebuild", async () => {
-            await rebuildState(s.basePath);
-        });
         // Sync worktree state back to project root (skipped for lightweight sidecars)
         if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
             await runSafely("postUnit", "worktree-sync", () => {

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

@@ -425,13 +425,9 @@ function cleanupAfterLoopExit(ctx) {
         /* best-effort — mirror stopAuto cleanup */
         logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
-    // A transient provider-error pause intentionally leaves the paused badge
-    // visible so the user still has a resumable auto-mode signal on screen.
-    if (!s.paused) {
-        ctx.ui.setStatus("gsd-auto", undefined);
-        ctx.ui.setWidget("gsd-progress", undefined);
-        ctx.ui.setFooter(undefined);
-    }
+    ctx.ui.setStatus("gsd-auto", undefined);
+    ctx.ui.setWidget("gsd-progress", undefined);
+    ctx.ui.setFooter(undefined);
     // Restore CWD out of worktree back to original project root
     if (s.originalBasePath) {
         s.basePath = s.originalBasePath;
@@ -533,22 +529,7 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
         }
-        // ── Step 5: Rebuild state while DB is still open (#3599) ──
-        // rebuildState() calls deriveState() which needs the DB for authoritative
-        // state. Previously this ran after closeDatabase(), forcing a filesystem
-        // fallback that could disagree with the DB-backed dispatch decisions —
-        // a split-brain where dispatch says "blocked" but STATE.md shows work.
-        if (s.basePath) {
-            try {
-                await rebuildState(s.basePath);
-            }
-            catch (e) {
-                debugLog("stop-rebuild-state-failed", {
-                    error: e instanceof Error ? e.message : String(e),
-                });
-            }
-        }
-        // ── Step 6: DB cleanup ──
+        // ── Step 5: DB cleanup ──
         if (isDbAvailable()) {
             try {
                 const { closeDatabase } = await import("./gsd-db.js");
@@ -560,7 +541,7 @@ export async function stopAuto(ctx, pi, reason) {
                 });
             }
         }
-        // ── Step 7: Restore basePath and chdir ──
+        // ── Step 6: Restore basePath and chdir ──
         try {
             if (s.originalBasePath) {
                 s.basePath = s.originalBasePath;
@@ -576,7 +557,7 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
         }
-        // ── Step 8: Ledger notification ──
+        // ── Step 7: Ledger notification ──
         try {
             const ledger = getLedger();
             if (ledger && ledger.units.length > 0) {
@@ -590,6 +571,17 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-ledger", { error: e instanceof Error ? e.message : String(e) });
         }
+        // ── Step 8: Rebuild state ──
+        if (s.basePath) {
+            try {
+                await rebuildState(s.basePath);
+            }
+            catch (e) {
+                debugLog("stop-rebuild-state-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
         // ── Step 9: Cmux sidebar / event log ──
         try {
             clearCmuxSidebar(loadedPreferences);
@@ -1302,6 +1294,8 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     pi.sendMessage({ customType: "gsd-auto", content: hookPrompt, display: true }, { triggerTurn: true });
     return true;
 }
+// Direct phase dispatch → auto-direct-dispatch.ts
+export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 // Re-export recovery functions for external consumers
 export { buildLoopRemediationSteps, } from "./auto-recovery.js";
 export { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -172,10 +172,14 @@ export function registerHooks(pi) {
         // Only gate-shaped ask_user_questions calls should block execution.
         // The gate stays pending until the user selects the approval option.
         if (event.toolName === "ask_user_questions") {
-            const questions = event.input?.questions ?? [];
-            const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
-            if (typeof questionId === "string") {
-                setPendingGate(questionId);
+            const milestoneId = getDiscussionMilestoneId(discussionBasePath);
+            const inDiscussion = milestoneId !== null || isQueuePhaseActive();
+            if (inDiscussion) {
+                const questions = event.input?.questions ?? [];
+                const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
+                if (typeof questionId === "string") {
+                    setPendingGate(questionId);
+                }
             }
         }
         // ── Discussion gate enforcement: block tool calls while gate is pending ──
@@ -257,6 +261,8 @@ export function registerHooks(pi) {
             return;
         const milestoneId = getDiscussionMilestoneId(process.cwd());
         const queueActive = isQueuePhaseActive();
+        if (!milestoneId && !queueActive)
+            return;
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
         // If the result is cancelled or has no response, the pending gate stays active
@@ -287,16 +293,12 @@ export function registerHooks(pi) {
                 // Only unlock the gate if the user selected the first option (confirmation).
                 // Cross-references against the question's defined options to reject free-form "Other" text.
                 const answer = details.response?.answers?.[question.id];
-                const inferredMilestoneId = extractDepthVerificationMilestoneId(question.id) ?? milestoneId;
                 if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
-                    markDepthVerified(inferredMilestoneId);
-                    clearPendingGate();
+                    markDepthVerified(extractDepthVerificationMilestoneId(question.id) ?? milestoneId);
                 }
                 break;
             }
         }
-        if (!milestoneId && !queueActive)
-            return;
         if (!milestoneId)
             return;
         const basePath = process.cwd();

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -61,9 +61,6 @@ export function parseDoctorArgs(args) {
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
     return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
 }
-export function isDoctorHealActionable(issue) {
-    return issue.fixable && issue.severity !== "info";
-}
 export async function handleDoctor(args, ctx, pi) {
     const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
@@ -91,7 +88,7 @@ export async function handleDoctor(args, ctx, pi) {
             scope: effectiveScope,
             includeWarnings: true,
         });
-        const actionable = unresolved.filter(isDoctorHealActionable);
+        const actionable = unresolved.filter(issue => issue.severity === "error");
         if (actionable.length === 0) {
             ctx.ui.notify("Doctor heal found nothing actionable to hand off to the LLM.", "info");
             return;

package/dist/resources/extensions/gsd/context-injector.js

@@ -14,7 +14,7 @@
  */
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, sep } from "node:path";
-import { readFrozenDefinition } from "./definition-io.js";
+import { readFrozenDefinition } from "./custom-workflow-engine.js";
 /** Maximum characters per artifact to prevent context window blowout. */
 const MAX_CONTEXT_CHARS = 10_000;
 /**

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -13,13 +13,17 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
-import { readFrozenDefinition } from "./definition-io.js";
 import { parseUnitId } from "./unit-id.js";
 import { withFileLock } from "./file-lock.js";
-// Re-export for downstream consumers
-export { readFrozenDefinition } from "./definition-io.js";
+/** Read and parse the frozen DEFINITION.yaml from a run directory. */
+export function readFrozenDefinition(runDir) {
+    const defPath = join(runDir, "DEFINITION.yaml");
+    const raw = readFileSync(defPath, "utf-8");
+    return parse(raw, { schema: "core" });
+}
 export class CustomWorkflowEngine {
     engineId = "custom";
     runDir;

package/dist/resources/extensions/gsd/file-watcher.js

@@ -0,0 +1,80 @@
+import { relative } from "node:path";
+let watcher = null;
+let pending = new Map();
+const EVENT_MAP = {
+    "settings.json": "settings-changed",
+    "auth.json": "auth-changed",
+    "models.json": "models-changed",
+};
+const EXTENSIONS_DIR = "extensions";
+const IGNORED_PATTERNS = [
+    "**/sessions/**",
+    "**/*.tmp",
+    "**/*.swp",
+    "**/*~",
+    "**/.DS_Store",
+];
+const DEBOUNCE_MS = 300;
+/**
+ * Start watching `agentDir` (e.g. `~/.gsd/agent/`) for config changes.
+ * Emits events on the supplied EventBus when watched files are modified.
+ */
+export async function startFileWatcher(agentDir, eventBus) {
+    if (watcher) {
+        await watcher.close();
+    }
+    const { watch } = await import("chokidar");
+    pending = new Map();
+    function debounceEmit(event) {
+        const existing = pending.get(event);
+        if (existing)
+            clearTimeout(existing);
+        pending.set(event, setTimeout(() => {
+            pending.delete(event);
+            eventBus.emit(event, { timestamp: Date.now() });
+        }, DEBOUNCE_MS));
+    }
+    function resolveEvent(filePath) {
+        const rel = relative(agentDir, filePath);
+        if (rel.startsWith(".."))
+            return null;
+        // Check direct file matches
+        for (const [file, event] of Object.entries(EVENT_MAP)) {
+            if (rel === file)
+                return event;
+        }
+        // Check extensions directory
+        if (rel.startsWith(EXTENSIONS_DIR + "/") || rel === EXTENSIONS_DIR) {
+            return "extensions-changed";
+        }
+        return null;
+    }
+    watcher = watch(agentDir, {
+        ignoreInitial: true,
+        depth: 2,
+        ignored: IGNORED_PATTERNS,
+    });
+    for (const eventType of ["add", "change", "unlink"]) {
+        watcher.on(eventType, (filePath) => {
+            const event = resolveEvent(filePath);
+            if (event)
+                debounceEmit(event);
+        });
+    }
+    // Wait for watcher to be ready
+    await new Promise((resolve) => {
+        watcher.on("ready", resolve);
+    });
+}
+/**
+ * Stop the file watcher and clean up resources.
+ */
+export async function stopFileWatcher() {
+    for (const timer of pending.values())
+        clearTimeout(timer);
+    pending.clear();
+    if (watcher) {
+        await watcher.close();
+        watcher = null;
+    }
+}