@a5c-ai/babysitter-sdk 0.0.187-staging.38eafc19 → 0.0.187-staging.457841d2

package/dist/cli/commands/harnessPhase2.js

@@ -126,22 +126,22 @@ async function resolveEffect(action, harnessName, options, piSession, discovered
         if (piSession) {
             const bashCommand = [command, ...shellArgs.map(harnessUtils_1.shellQuoteArg)].join(" ");
             const bashResult = await piSession.executeBash(bashCommand);
+            const ok = bashResult.exitCode === 0;
             return {
-                status: bashResult.exitCode === 0 ? "ok" : "error",
-                value: bashResult.exitCode === 0 ? bashResult.output : undefined,
-                error: bashResult.exitCode === 0
-                    ? undefined
-                    : new Error(`Shell command exited with code ${bashResult.exitCode ?? "null"}: ${bashResult.output}`),
+                status: "ok",
+                value: ok
+                    ? bashResult.output
+                    : { success: false, exitCode: bashResult.exitCode ?? 1, stdout: bashResult.output, stderr: "", error: `Shell command exited with code ${bashResult.exitCode ?? "null"}: ${bashResult.output}` },
                 stdout: bashResult.output,
             };
         }
         const shellResult = await (0, harnessPhase1_1.execShellEffect)(command, shellArgs, cwd);
+        const shellOk = shellResult.exitCode === 0;
         return {
-            status: shellResult.exitCode === 0 ? "ok" : "error",
-            value: shellResult.exitCode === 0 ? shellResult.stdout : undefined,
-            error: shellResult.exitCode === 0
-                ? undefined
-                : new Error(`Shell command exited with code ${shellResult.exitCode}: ${shellResult.stderr}`),
+            status: "ok",
+            value: shellOk
+                ? shellResult.stdout
+                : { success: false, exitCode: shellResult.exitCode, stdout: shellResult.stdout, stderr: shellResult.stderr, error: `Shell command exited with code ${shellResult.exitCode}: ${shellResult.stderr}` },
             stdout: shellResult.stdout,
             stderr: shellResult.stderr,
         };

package/dist/hooks/dispatcher.d.ts

@@ -3,6 +3,15 @@
  * Executes shell hooks from Node.js
  */
 import type { HookDispatcherOptions, HookResult } from "./types";
+export interface DiscoveredHook {
+    path: string;
+    name: string;
+    location: "per-repo" | "per-user";
+}
+/**
+ * Discover hook scripts for a given hook type from project and user directories.
+ */
+export declare function discoverHooks(hookType: string, cwd: string, homeDir?: string): Promise<DiscoveredHook[]>;
 /**
  * Find `plugins/babysitter/hooks/hook-dispatcher.sh` by walking up from cwd.
  * This allows running from nested projects/fixtures inside a mono-repo.

package/dist/hooks/dispatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../src/hooks/dispatcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EACV,qBAAqB,EACrB,UAAU,EAEX,MAAM,SAAS,CAAC;AAIjB;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAetE;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,UAAU,CAAC,CAoHrB"}
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../src/hooks/dispatcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EACV,qBAAqB,EACrB,UAAU,EAEX,MAAM,SAAS,CAAC;AAMjB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,UAAU,CAAC;CACnC;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAqB,GAC7B,OAAO,CAAC,cAAc,EAAE,CAAC,CAmC3B;AAkED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAetE;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,UAAU,CAAC,CAyHrB"}

package/dist/hooks/dispatcher.js

@@ -37,13 +37,102 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverHooks = discoverHooks;
 exports.findHookDispatcherPath = findHookDispatcherPath;
 exports.callHook = callHook;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
+const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const defaults_1 = require("../config/defaults");
 const harness_1 = require("../harness");
+const HOOK_SCRIPT_EXTENSIONS = new Set([".sh", ".js", ".ts", ".py", ".bash"]);
+/**
+ * Discover hook scripts for a given hook type from project and user directories.
+ */
+async function discoverHooks(hookType, cwd, homeDir = os.homedir()) {
+    const projectHookDir = path.join(cwd, ".a5c", "hooks", hookType);
+    const userHookDir = path.join(homeDir, ".a5c", "hooks", hookType);
+    async function readHooksFromDir(dir, location) {
+        try {
+            const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true });
+            return entries
+                .filter((entry) => {
+                if (!entry.isFile())
+                    return false;
+                const ext = path.extname(entry.name);
+                return HOOK_SCRIPT_EXTENSIONS.has(ext);
+            })
+                .map((entry) => ({
+                path: path.join(dir, entry.name),
+                name: entry.name,
+                location,
+            }));
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return [];
+            }
+            throw err;
+        }
+    }
+    const [projectHooks, userHooks] = await Promise.all([
+        readHooksFromDir(projectHookDir, "per-repo"),
+        readHooksFromDir(userHookDir, "per-user"),
+    ]);
+    return [...projectHooks, ...userHooks];
+}
+/**
+ * Execute discovered hook scripts sequentially, passing payload as stdin JSON.
+ * @internal
+ */
+async function executeDiscoveredHooks(hooks, payload, hookType, cwd, timeout) {
+    const payloadJson = JSON.stringify(payload);
+    const executedHooks = [];
+    for (const hook of hooks) {
+        const result = await new Promise((resolve) => {
+            const child = (0, node_child_process_1.spawn)("bash", [hook.path], {
+                cwd,
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout,
+            });
+            child.stdin.write(payloadJson);
+            child.stdin.end();
+            let timedOut = false;
+            const timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+            }, timeout);
+            child.on("error", () => {
+                clearTimeout(timeoutHandle);
+                resolve({ success: false, exitCode: null });
+            });
+            child.on("close", (exitCode) => {
+                clearTimeout(timeoutHandle);
+                if (timedOut) {
+                    resolve({ success: false, exitCode: null });
+                }
+                else {
+                    resolve({ success: exitCode === 0, exitCode });
+                }
+            });
+        });
+        executedHooks.push({
+            hookPath: hook.path,
+            hookName: hook.name,
+            hookLocation: hook.location,
+            status: result.success ? "success" : "failed",
+            exitCode: result.exitCode ?? undefined,
+        });
+    }
+    const allSucceeded = executedHooks.every((h) => h.status === "success");
+    return {
+        hookType,
+        success: allSucceeded,
+        error: allSucceeded ? undefined : `One or more discovered hooks failed for ${hookType}`,
+        executedHooks,
+    };
+}
 /**
  * Find `plugins/babysitter/hooks/hook-dispatcher.sh` by walking up from cwd.
  * This allows running from nested projects/fixtures inside a mono-repo.
@@ -78,6 +167,11 @@ async function callHook(options) {
     const { hookType, payload, cwd = process.cwd(), timeout = defaults_1.DEFAULTS.hookTimeout, throwOnFailure = false, } = options;
     const dispatcherPath = findHookDispatcherPath(cwd);
     if (!dispatcherPath) {
+        // Fall back to filesystem-discovered hooks
+        const discoveredHooks = await discoverHooks(hookType, cwd);
+        if (discoveredHooks.length > 0) {
+            return executeDiscoveredHooks(discoveredHooks, payload, hookType, cwd, timeout);
+        }
         return {
             hookType,
             success: false,

package/dist/hooks/index.d.ts

@@ -2,7 +2,8 @@
  * Hook System API
  * Public interface for calling hooks from process files
  */
-export { callHook, } from "./dispatcher";
+export { callHook, discoverHooks, } from "./dispatcher";
+export type { DiscoveredHook } from "./dispatcher";
 export type { HookType, HookResult, HookExecutionResult, HookPayload, HookDispatcherOptions, OnRunStartPayload, OnRunCompletePayload, OnRunFailPayload, OnTaskStartPayload, OnTaskCompletePayload, OnStepDispatchPayload, OnIterationStartPayload, OnIterationEndPayload, OnBreakpointPayload, PreCommitPayload, PreBranchPayload, PostPlanningPayload, OnScorePayload, } from "./types";
 /**
  * Helper function to create hook payloads with proper typing

package/dist/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,QAAQ,GACT,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,QAAQ,EACR,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,GACf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC9D,OAAO,EAAE,CAAC,GACT,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAK3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,QAAQ,EACR,aAAa,GACd,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,YAAY,EACV,QAAQ,EACR,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,GACf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC9D,OAAO,EAAE,CAAC,GACT,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAK3B"}

package/dist/hooks/index.js

@@ -4,10 +4,11 @@
  * Public interface for calling hooks from process files
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callHook = void 0;
+exports.discoverHooks = exports.callHook = void 0;
 exports.createHookPayload = createHookPayload;
 var dispatcher_1 = require("./dispatcher");
 Object.defineProperty(exports, "callHook", { enumerable: true, get: function () { return dispatcher_1.callHook; } });
+Object.defineProperty(exports, "discoverHooks", { enumerable: true, get: function () { return dispatcher_1.discoverHooks; } });
 /**
  * Helper function to create hook payloads with proper typing
  */

package/dist/prompts/templates/intent-fidelity-checks.md

@@ -6,7 +6,9 @@ Before calling `run:create`, verify and document in your working notes:
 2. The process structure follows library style/composition patterns rather than
    a one-off minimal flow.
 3. Quality gates exist (verification/refinement loops, integration checks,
-   and/or breakpoints appropriate for the task).
+   and/or breakpoints appropriate for the task). Objectively verifiable checks
+   (compilation, linting, tests, grep, dependencies) use `kind: 'shell'` with
+   `expectedExitCode`, not `kind: 'agent'`.
 4. Any scope reduction, simplification, or recovery tradeoff is explicitly
    approved by the user before execution.
 

package/dist/prompts/templates/process-creation.md

@@ -55,7 +55,14 @@ After the process is created and before creating the run:
 - wrong: skipping repo/process-library research before writing the process
 - wrong: bypassing the orchestration model with helper scripts or inline logic
 - wrong: using `kind: 'node'` in generated tasks
-- correct: use `agent` or `skill` tasks for reasoning work, with `shell` only
-  for existing CLIs, tests, linters, git, or builds
+- wrong: using `kind: 'agent'` for deterministic verification (compilation,
+  linting, test execution, grep checks, dependency validation) -- these MUST
+  use `kind: 'shell'` with `expectedExitCode` for binary pass/fail enforcement
+- correct: use `agent` or `skill` tasks for reasoning work (planning, code
+  review, architecture assessment, subjective evaluation)
+- correct: use `shell` tasks for all objectively verifiable checks (tsc, eslint,
+  vitest, grep, dependency imports, runtime smoke tests)
 - correct: include verification loops, refinement loops, quality gates, and
   breakpoints where appropriate
+- correct: pair shell verification gates with agent analysis tasks (shell runs
+  the check, agent interprets failures and suggests fixes)

package/dist/prompts/templates/process-guidelines.md

@@ -75,8 +75,11 @@ specified:
   - Integrate/link the main pages (or entry points) with functionality created
     for every phase of the development process
   - Quality gated iterative and convergent development/refinement loops
-  - Test driven -- where quality gates can use executable tools, scripts, and
-    tests to verify accuracy and completeness
+  - Test driven -- where quality gates use `kind: 'shell'` tasks with
+    `expectedExitCode` for deterministic verification (compilation, linting,
+    test suites, grep checks, dependency availability, runtime smoke tests).
+    Reserve `kind: 'agent'` for subjective assessment only (code review,
+    architecture evaluation, UX quality)
   - Integration phases for each new functionality in every milestone
   - Where relevant -- beautiful and polished UX with pixel-perfect verification
   - Accurate and complete implementation of the user request

package/dist/prompts/templates/task-examples.md

@@ -37,6 +37,53 @@ export const agentTask = defineTask('agent-scorer', (args, taskCtx) => ({
 }));
 ```
 
+### Shell Verification Task Example
+
+Use shell tasks for all deterministic verification gates. Shell tasks produce
+binary pass/fail results via exit codes that cannot be bypassed by agent
+reasoning.
+
+```javascript
+// Grep-based integration check
+export const grepCheckTask = defineTask('grep-integration-check', (args, taskCtx) => ({
+  kind: 'shell',
+  title: 'Verify integration points exist',
+  shell: {
+    command: `cd ${args.projectDir || '.'} && grep -q "${args.pattern}" ${args.file}`,
+    expectedExitCode: 0,
+    timeout: 10000
+  },
+  io: {
+    inputJsonPath: `tasks/${taskCtx.effectId}/input.json`,
+    outputJsonPath: `tasks/${taskCtx.effectId}/output.json`
+  }
+}));
+
+// Multi-check verification gate
+export const verificationGateTask = defineTask('verification-gate', (args, taskCtx) => ({
+  kind: 'shell',
+  title: 'Deterministic verification gate',
+  shell: {
+    command: [
+      `cd ${args.projectDir || '.'}`,
+      'npx tsc --noEmit',
+      'npx eslint src/ --max-warnings=0',
+      'npx vitest run --reporter=verbose'
+    ].join(' && '),
+    expectedExitCode: 0,
+    timeout: 300000
+  },
+  io: {
+    inputJsonPath: `tasks/${taskCtx.effectId}/input.json`,
+    outputJsonPath: `tasks/${taskCtx.effectId}/output.json`
+  }
+}));
+```
+
+Use `library/processes/shared/deterministic-quality-gate.js` for composable
+preset gates (createGrepCheck, createCompilationGate, createTestSuiteGate,
+createRuntimeSmokeTest).
+
 ### Skill Task Example
 
 Important: Check which skills are actually available before assigning the skill

package/dist/prompts/templates/task-kinds.md

@@ -10,12 +10,54 @@ build tools), `breakpoint` (human approval), and `sleep` (time gates).
 | Kind | Description | Executor | When to use |
 |------|-------------|----------|-------------|
 | ~~`node`~~ | ~~Node.js script~~ | ~~Local node process~~ | **NEVER -- forbidden. Convert to `agent` or `skill`.** |
-| `shell` | Shell command | Local shell process | Only for running existing CLI tools, test suites, git, linters, builds. The orchestrating agent must execute it intentionally and post the result |
-| `agent` | LLM agent | Agent runtime | **Default for all tasks** -- planning, implementation, analysis, verification, scoring, debugging, code writing, research |
+| `shell` | Shell command | Local shell process | **Deterministic verification** (compilation, linting, tests, grep, dependency checks, smoke tests) AND running existing CLI tools, git, builds. The orchestrating agent must execute it intentionally and post the result |
+| `agent` | LLM agent | Agent runtime | **Default for reasoning tasks** -- planning, implementation, analysis, scoring, debugging, code writing, research. Also for **subjective verification** (code review, architecture assessment, UX evaluation) |
 | `skill` | {{skillSystemLabel}} | Skill system | When a matching installed skill exists (preferred over agent when available) |
 | `breakpoint` | Human approval | UI/CLI | Decision gates requiring user input |
 | `sleep` | Time gate | Scheduler | Time-based pauses |
 
+### Shell vs Agent for Verification Tasks
+
+**CRITICAL:** Verification tasks that produce deterministic, binary pass/fail
+results MUST use `kind: 'shell'` with `expectedExitCode`, NOT `kind: 'agent'`.
+Agent-interpreted verification creates soft gates where an LLM subjectively
+assesses pass/fail -- this is unreliable for objectively testable checks.
+
+| Verification type | Correct kind | Why |
+|-------------------|-------------|-----|
+| Compilation (tsc, gcc) | `shell` | Exit code is deterministic pass/fail |
+| Linting (eslint, ruff) | `shell` | Exit code is deterministic pass/fail |
+| Test suites (vitest, jest) | `shell` | Exit code is deterministic pass/fail |
+| Grep/pattern checks | `shell` | Pattern exists or it doesn't |
+| Dependency availability | `shell` | `node -e "require('pkg')"` succeeds or fails |
+| Runtime smoke tests | `shell` | Start, curl, check status code, stop |
+| Code review / design quality | `agent` | Requires subjective judgment |
+| Architecture assessment | `agent` | Requires reasoning about tradeoffs |
+| UX evaluation | `agent` | Subjective quality assessment |
+
+**Anti-pattern (wrong):**
+```javascript
+// BAD: agent-interpreted verification -- the agent can say "looks good" without running anything
+const verifyTask = defineTask('verify-compilation', (args, taskCtx) => ({
+  kind: 'agent',
+  title: 'Verify TypeScript compiles',
+  agent: { prompt: { instructions: ['Run tsc and check it passes'] } }
+}));
+```
+
+**Correct pattern:**
+```javascript
+// GOOD: deterministic shell gate -- exit code cannot be negotiated
+const verifyTask = defineTask('verify-compilation', (args, taskCtx) => ({
+  kind: 'shell',
+  title: 'TypeScript compilation check',
+  shell: { command: 'npx tsc --noEmit', expectedExitCode: 0, timeout: 120000 }
+}));
+```
+
+Use `library/processes/shared/deterministic-quality-gate.js` for composable
+preset gates (grep checks, compilation, test suites, runtime smoke tests).
+
 ### Effect Execution Hints
 
 Tasks can include an `execution` field to express preferences about how the effect should be executed:

package/dist/runtime/intrinsics/breakpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAmC,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1H,OAAO,EAAoB,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAkChE,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,OAAO,EAChD,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,iBAAiB,GAAG,wBAAwB,GACrD,OAAO,CAAC,gBAAgB,CAAC,CA+B3B"}
+{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/breakpoint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAmC,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1H,OAAO,EAAoB,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAkChE,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,OAAO,EAChD,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,iBAAiB,GAAG,wBAAwB,GACrD,OAAO,CAAC,gBAAgB,CAAC,CAiD3B"}

package/dist/runtime/intrinsics/breakpoint.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runBreakpointIntrinsic = runBreakpointIntrinsic;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const task_1 = require("./task");
 const journal_1 = require("../../storage/journal");
 const BREAKPOINT_TASK_ID = "__sdk.breakpoint";
@@ -28,10 +33,24 @@ function runBreakpointIntrinsic(payload, context, options) {
     const ctx = context;
     if (ctx.nonInteractive) {
         const bpLabel = options?.label ?? "unnamed";
+        let logSeq;
+        if (ctx.logSeq !== undefined && ctx.recordedLogSeqs !== undefined) {
+            logSeq = ++ctx.logSeq;
+            if (ctx.recordedLogSeqs.has(logSeq)) {
+                return Promise.resolve({ approved: true, response: "Auto-approved (non-interactive mode)" });
+            }
+            ctx.recordedLogSeqs.add(logSeq);
+            void node_fs_1.promises.appendFile(node_path_1.default.join(context.runDir, "state", "logSeqs.txt"), `${logSeq}\n`).catch(() => {
+                // Never let logging break orchestration.
+            });
+        }
+        else {
+            logSeq = -1;
+        }
         void (0, journal_1.appendEvent)({
             runDir: context.runDir,
             eventType: "PROCESS_LOG",
-            event: { logSeq: -1, label: "breakpoint:skipped", message: `Breakpoint '${bpLabel}' auto-approved (non-interactive mode)` },
+            event: { logSeq, label: "breakpoint:skipped", message: `Breakpoint '${bpLabel}' auto-approved (non-interactive mode)` },
         }).catch(() => {
             // Never let logging break orchestration.
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5c-ai/babysitter-sdk",
-  "version": "0.0.187-staging.38eafc19",
+  "version": "0.0.187-staging.457841d2",
   "description": "Storage and run-registry primitives for event-sourced babysitter workflows.",
   "license": "UNLICENSED",
   "type": "commonjs",