@a5c-ai/babysitter-sdk 0.0.186 → 0.0.187-staging.02a0ee21

package/dist/harness/openclaw.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * OpenClaw harness adapter.
+ *
+ * Centralizes all OpenClaw-specific behaviors:
+ *   - Session ID resolution (BABYSITTER_SESSION_ID, OPENCLAW_SHELL context)
+ *   - State directory conventions (global state dir by default)
+ *   - Session binding (run:create -> state file with run association)
+ *   - No stop hook (OpenClaw is a daemon with no stop-hook model)
+ *   - Session-start hook handler (baseline state file + skill discovery context)
+ *
+ * OpenClaw characteristics:
+ *   - Daemon/gateway model, CLI command: `openclaw`
+ *   - Env vars: OPENCLAW_SHELL, OPENCLAW_HOME
+ *   - Sessions use composite keys: `agent:<agentId>:<channel>:<type>:<id>`
+ *   - NO stop-hook model — hooks are registered programmatically
+ *   - Capabilities: SessionBinding, Mcp, HeadlessPrompt (NOT StopHook, NOT Programmatic)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenClawAdapter = createOpenClawAdapter;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const session_1 = require("../session");
+const types_1 = require("./types");
+const context_1 = require("../prompts/context");
+const config_1 = require("../config");
+const discovery_1 = require("./discovery");
+const installSupport_1 = require("./installSupport");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const HARNESS_NAME = "openclaw";
+function createHookLogger(hookName) {
+    const logDir = (0, config_1.getGlobalLogDir)();
+    const logFile = logDir ? path.join(logDir, `${hookName}.log`) : null;
+    const context = {};
+    if (logFile) {
+        try {
+            (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    function write(level, message) {
+        if (!logFile)
+            return;
+        const ts = new Date().toISOString();
+        const ctxParts = Object.entries(context).map(([k, v]) => `${k}=${v}`);
+        const ctxStr = ctxParts.length > 0 ? ` [${ctxParts.join(" ")}]` : "";
+        const line = `[${level}] ${ts}${ctxStr} ${message}\n`;
+        try {
+            (0, node_fs_1.appendFileSync)(logFile, line);
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    return {
+        info: (msg) => write("INFO", msg),
+        warn: (msg) => write("WARN", msg),
+        error: (msg) => write("ERROR", msg),
+        setContext: (key, value) => {
+            context[key] = value;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// State directory resolution
+// ---------------------------------------------------------------------------
+function resolveStateDirInternal(args) {
+    if (args.stateDir)
+        return path.resolve(args.stateDir);
+    return (0, config_1.getGlobalStateDir)();
+}
+// ---------------------------------------------------------------------------
+// Session ID resolution
+// ---------------------------------------------------------------------------
+function resolveSessionIdInternal(parsed) {
+    // 1. Explicit arg (highest priority)
+    if (parsed.sessionId)
+        return parsed.sessionId;
+    // 2. Cross-harness standard env var
+    if (process.env.BABYSITTER_SESSION_ID)
+        return process.env.BABYSITTER_SESSION_ID;
+    // 3. OpenClaw shell context — composite key provided by the gateway
+    if (process.env.OPENCLAW_SHELL)
+        return process.env.OPENCLAW_SHELL;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Stop hook handler (no-op — OpenClaw has no stop-hook model)
+// ---------------------------------------------------------------------------
+function writeNoopHookResult() {
+    process.stdout.write("{}\n");
+}
+// ---------------------------------------------------------------------------
+// SessionStart hook handler
+// ---------------------------------------------------------------------------
+async function handleSessionStartHookImpl(args) {
+    const { verbose } = args;
+    const log = createHookLogger("babysitter-openclaw-session-start-hook");
+    log.info("handleSessionStartHook started (openclaw)");
+    // OpenClaw is a daemon — session IDs come from the gateway env, not stdin.
+    const sessionId = process.env.BABYSITTER_SESSION_ID || process.env.OPENCLAW_SHELL || "";
+    if (!sessionId) {
+        log.info("No session ID — skipping state file creation");
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    log.setContext("session", sessionId);
+    log.info(`Session ID: ${sessionId}`);
+    // Resolve state directory and create baseline session file
+    const stateDir = resolveStateDirInternal(args);
+    log.info(`Resolved stateDir: ${stateDir}`);
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    try {
+        if (!(await (0, session_1.sessionFileExists)(filePath))) {
+            const nowTs = (0, session_1.getCurrentTimestamp)();
+            const state = {
+                active: true,
+                iteration: 1,
+                maxIterations: 256,
+                runId: "",
+                startedAt: nowTs,
+                lastIterationAt: nowTs,
+                iterationTimes: [],
+            };
+            await (0, session_1.writeSessionFile)(filePath, state, "");
+            log.info(`Created session state: ${filePath}`);
+            if (verbose) {
+                process.stderr.write(`[hook:run session-start] Created session state: ${filePath}\n`);
+            }
+        }
+        else {
+            log.info(`Session state already exists: ${filePath}`);
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Failed to create session state: ${msg}`);
+        if (verbose) {
+            process.stderr.write(`[hook:run session-start] Failed to create session state: ${msg}\n`);
+        }
+    }
+    // Output empty object
+    process.stdout.write("{}\n");
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Session binding (run:create flow)
+// ---------------------------------------------------------------------------
+async function bindSessionImpl(opts) {
+    const { sessionId, runId, maxIterations = 256, prompt, verbose } = opts;
+    // Resolve state directory
+    const stateDir = resolveStateDirInternal({
+        stateDir: opts.stateDir,
+        pluginRoot: opts.pluginRoot,
+    });
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    // Check for existing session (prevent re-entrant runs)
+    if (await (0, session_1.sessionFileExists)(filePath)) {
+        try {
+            const existing = await (0, session_1.readSessionFile)(filePath);
+            if (existing.state.runId && existing.state.runId !== runId) {
+                return {
+                    harness: HARNESS_NAME,
+                    sessionId,
+                    stateFile: filePath,
+                    error: `Session already associated with run: ${existing.state.runId}`,
+                };
+            }
+            // Update existing session with run ID
+            await (0, session_1.updateSessionState)(filePath, { runId, active: true }, { state: existing.state, prompt: existing.prompt });
+            if (verbose) {
+                process.stderr.write(`[run:create] Updated existing session ${sessionId} with run ${runId}\n`);
+            }
+            return { harness: HARNESS_NAME, sessionId, stateFile: filePath };
+        }
+        catch {
+            // Corrupted state file — overwrite
+        }
+    }
+    // Create new session state with run associated
+    const nowTs = (0, session_1.getCurrentTimestamp)();
+    const state = {
+        active: true,
+        iteration: 1,
+        maxIterations,
+        runId,
+        startedAt: nowTs,
+        lastIterationAt: nowTs,
+        iterationTimes: [],
+    };
+    try {
+        await (0, session_1.writeSessionFile)(filePath, state, prompt);
+    }
+    catch (e) {
+        return {
+            harness: HARNESS_NAME,
+            sessionId,
+            error: `Failed to write session state: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+    if (verbose) {
+        process.stderr.write(`[run:create] Session ${sessionId} initialized and bound to run ${runId}\n`);
+    }
+    return { harness: HARNESS_NAME, sessionId, stateFile: filePath };
+}
+// ---------------------------------------------------------------------------
+// Adapter factory
+// ---------------------------------------------------------------------------
+function createOpenClawAdapter() {
+    return {
+        name: HARNESS_NAME,
+        isActive() {
+            return !!(process.env.OPENCLAW_SHELL || process.env.OPENCLAW_HOME);
+        },
+        autoResolvesSessionId() {
+            return true;
+        },
+        getMissingSessionIdHint() {
+            return ("Session ID is provided by the OpenClaw gateway. " +
+                "Ensure you're running inside an OpenClaw agent session.");
+        },
+        supportsHookType(hookType) {
+            // OpenClaw hooks are registered programmatically via the daemon.
+            // Only session-start is supported via the SDK hook:run path.
+            return hookType === "session-start";
+        },
+        getUnsupportedHookMessage(hookType) {
+            if (hookType === "stop") {
+                return ("OpenClaw does not support a blocking stop hook. " +
+                    "The daemon manages agent lifecycle via agent_end signals. " +
+                    "Use the OpenClaw gateway API instead.");
+            }
+            return `Hook type "${hookType}" is not supported by the OpenClaw adapter. OpenClaw hooks are registered programmatically.`;
+        },
+        getCapabilities() {
+            return [
+                types_1.HarnessCapability.SessionBinding,
+                types_1.HarnessCapability.Mcp,
+                types_1.HarnessCapability.HeadlessPrompt,
+            ];
+        },
+        resolveSessionId(parsed) {
+            return resolveSessionIdInternal(parsed);
+        },
+        resolveStateDir(args) {
+            return resolveStateDirInternal(args);
+        },
+        resolvePluginRoot(_args) {
+            // OpenClaw has no OPENCLAW_PLUGIN_ROOT env var.
+            return undefined;
+        },
+        bindSession(opts) {
+            return bindSessionImpl(opts);
+        },
+        handleStopHook(_args) {
+            // No-op: OpenClaw has no stop-hook model.
+            writeNoopHookResult();
+            return Promise.resolve(0);
+        },
+        handleSessionStartHook(args) {
+            return handleSessionStartHookImpl(args);
+        },
+        findHookDispatcherPath(_startCwd) {
+            // OpenClaw hooks are registered programmatically via the daemon.
+            return null;
+        },
+        async isCliInstalled() {
+            const result = await (0, discovery_1.checkCliAvailable)("openclaw");
+            return result.available;
+        },
+        async getCliInfo() {
+            const result = await (0, discovery_1.checkCliAvailable)("openclaw");
+            return {
+                command: "openclaw",
+                version: result.version,
+                path: result.path,
+            };
+        },
+        installHarness(options) {
+            return (0, installSupport_1.installCliViaNpm)({
+                harness: HARNESS_NAME,
+                cliCommand: "openclaw",
+                packageName: "openclaw",
+                summary: "Install the OpenClaw CLI globally via npm.",
+                options,
+            });
+        },
+        installPlugin(options) {
+            return (0, installSupport_1.installCliViaNpm)({
+                harness: HARNESS_NAME,
+                cliCommand: "openclaw",
+                packageName: "@a5c-ai/babysitter-openclaw",
+                summary: "Install the Babysitter OpenClaw plugin package, then register it via `openclaw plugin install babysitter-openclaw`.",
+                options,
+            });
+        },
+        getPromptContext(opts) {
+            return (0, context_1.createOpenClawContext)(opts);
+        },
+    };
+}

package/dist/harness/opencode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/harness/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAkBH,OAAO,KAAK,EACV,cAAc,EAMf,MAAM,SAAS,CAAC;AA+fjB,wBAAgB,qBAAqB,IAAI,cAAc,CAsHtD"}
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/harness/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAmBH,OAAO,KAAK,EACV,cAAc,EAMf,MAAM,SAAS,CAAC;AA4iBjB,wBAAgB,qBAAqB,IAAI,cAAc,CAkJtD"}

package/dist/harness/opencode.js

@@ -60,6 +60,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenCodeAdapter = createOpenCodeAdapter;
 const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
 const node_fs_1 = require("node:fs");
 const journal_1 = require("../storage/journal");
 const runFiles_1 = require("../storage/runFiles");
@@ -73,7 +74,7 @@ const config_1 = require("../config");
 // ---------------------------------------------------------------------------
 const HARNESS_NAME = "opencode";
 function createHookLogger(hookName) {
-    const logDir = process.env.BABYSITTER_LOG_DIR || ".a5c/logs";
+    const logDir = (0, config_1.getGlobalLogDir)();
     const logFile = logDir ? path.join(logDir, `${hookName}.log`) : null;
     const context = {};
     if (logFile) {
@@ -445,6 +446,7 @@ async function bindSessionImpl(opts) {
     }
     // Create new session state with run associated
     const nowTs = (0, session_1.getCurrentTimestamp)();
+    const accomplishTaskId = process.env.ACCOMPLISH_TASK_ID;
     const state = {
         active: true,
         iteration: 1,
@@ -453,6 +455,7 @@ async function bindSessionImpl(opts) {
         startedAt: nowTs,
         lastIterationAt: nowTs,
         iterationTimes: [],
+        ...(accomplishTaskId ? { metadata: { accomplishTaskId } } : {}),
     };
     try {
         await (0, session_1.writeSessionFile)(filePath, state, prompt);
@@ -482,6 +485,45 @@ function installOpenCodePlugin(_options) {
     };
 }
 // ---------------------------------------------------------------------------
+// Accomplish AI data directory resolution
+// ---------------------------------------------------------------------------
+/**
+ * Returns candidate Accomplish AI data directories for the current platform.
+ *
+ * Accomplish is an Electron desktop app that spawns OpenCode as a subprocess.
+ * When running inside Accomplish, plugin bundles are stored under the
+ * platform-specific application data directory.
+ */
+function getAccomplishDataDirs() {
+    const dirs = [];
+    // Derive from OPENCODE_CONFIG_DIR if set (parent is the Accomplish data dir)
+    const configDir = process.env.OPENCODE_CONFIG_DIR;
+    if (configDir) {
+        const parent = path.dirname(configDir);
+        if (parent && parent !== configDir) {
+            dirs.push(parent);
+        }
+    }
+    const home = os.homedir();
+    const platform = process.platform;
+    if (platform === "darwin") {
+        dirs.push(path.join(home, "Library", "Application Support", "Accomplish"));
+    }
+    else if (platform === "win32") {
+        if (process.env.APPDATA) {
+            dirs.push(path.join(process.env.APPDATA, "Accomplish"));
+        }
+        if (process.env.LOCALAPPDATA) {
+            dirs.push(path.join(process.env.LOCALAPPDATA, "Accomplish"));
+        }
+    }
+    else {
+        // Linux and other Unix-like
+        dirs.push(path.join(home, ".config", "Accomplish"));
+    }
+    return dirs;
+}
+// ---------------------------------------------------------------------------
 // Adapter factory
 // ---------------------------------------------------------------------------
 function createOpenCodeAdapter() {
@@ -491,8 +533,10 @@ function createOpenCodeAdapter() {
             // OpenCode does NOT inject distinctive env vars into plugin subprocesses.
             // The babysitter plugin's shell.env hook self-injects BABYSITTER_SESSION_ID.
             // OPENCODE_CONFIG is a real OpenCode env var that indicates OpenCode context.
+            // ACCOMPLISH_TASK_ID is set when running inside the Accomplish AI desktop app.
             return !!(process.env.BABYSITTER_SESSION_ID ||
-                process.env.OPENCODE_CONFIG);
+                process.env.OPENCODE_CONFIG ||
+                process.env.ACCOMPLISH_TASK_ID);
         },
         autoResolvesSessionId() {
             // OpenCode does not natively inject session IDs — the babysitter
@@ -539,9 +583,27 @@ function createOpenCodeAdapter() {
             return resolveStateDirInternal(args);
         },
         resolvePluginRoot(args) {
-            const root = args.pluginRoot ||
-                process.env.OPENCODE_PLUGIN_ROOT;
-            return root ? path.resolve(root) : undefined;
+            // 1. Explicit arg (highest priority)
+            if (args.pluginRoot)
+                return path.resolve(args.pluginRoot);
+            // 2. OPENCODE_PLUGIN_ROOT env var
+            if (process.env.OPENCODE_PLUGIN_ROOT) {
+                return path.resolve(process.env.OPENCODE_PLUGIN_ROOT);
+            }
+            // 3. OPENCODE_CONFIG_DIR env var → <configDir>/plugins/babysitter/
+            const configDir = process.env.OPENCODE_CONFIG_DIR;
+            if (configDir) {
+                const candidate = path.resolve(configDir, "plugins", "babysitter");
+                if ((0, node_fs_1.existsSync)(candidate))
+                    return candidate;
+            }
+            // 4. Platform-specific Accomplish data dirs → <dataDir>/opencode/plugins/babysitter/
+            for (const dataDir of getAccomplishDataDirs()) {
+                const candidate = path.join(dataDir, "opencode", "plugins", "babysitter");
+                if ((0, node_fs_1.existsSync)(candidate))
+                    return candidate;
+            }
+            return undefined;
         },
         bindSession(opts) {
             return bindSessionImpl(opts);
@@ -566,6 +628,14 @@ function createOpenCodeAdapter() {
                     return tsCandidate;
                 current = path.dirname(current);
             }
+            // Fallback: check Accomplish AI data directories
+            // Derive from OPENCODE_CONFIG_DIR first, then platform-specific paths
+            const accomplishDirs = getAccomplishDataDirs();
+            for (const dataDir of accomplishDirs) {
+                const candidate = path.join(dataDir, "opencode", "plugins", "babysitter", "index.js");
+                if ((0, node_fs_1.existsSync)(candidate))
+                    return candidate;
+            }
             return null;
         },
         installPlugin(options) {

package/dist/harness/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/harness/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAiC9C;;;GAGG;AACH,wBAAgB,aAAa,IAAI,cAAc,CAK9C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAKpE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAQD;;GAEG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAK3C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/harness/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAmC9C;;;GAGG;AACH,wBAAgB,aAAa,IAAI,cAAc,CAK9C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAKpE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAQD;;GAEG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAK3C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC"}

package/dist/harness/registry.js

@@ -22,6 +22,7 @@ const internal_1 = require("./internal");
 const cursor_1 = require("./cursor");
 const githubCopilot_1 = require("./githubCopilot");
 const opencode_1 = require("./opencode");
+const openclaw_1 = require("./openclaw");
 const customAdapter_1 = require("./customAdapter");
 // ---------------------------------------------------------------------------
 // Registry of known adapters (ordered by priority)
@@ -31,6 +32,7 @@ const knownAdapters = [
     (0, ohMyPi_1.createOhMyPiAdapter)(),
     (0, internal_1.createInternalAdapter)(),
     (0, pi_1.createPiAdapter)(),
+    (0, openclaw_1.createOpenClawAdapter)(),
     (0, opencode_1.createOpenCodeAdapter)(),
     (0, claudeCode_1.createClaudeCodeAdapter)(),
     (0, geminiCli_1.createGeminiCliAdapter)(),

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/index.d.ts

@@ -13,5 +13,6 @@ export * from "./plugins";
 export * from "./interaction";
 export * from "./prompts";
 export * from "./logging";
+export * from "./cost/index";
 export * as anycli from "./anycli/index";
 //# sourceMappingURL=index.d.ts.map