botmux 2.33.0 → 2.34.0

package/dist/workflows/spawn-bot.d.ts

@@ -0,0 +1,165 @@
+/**
+ * WorkerSpawnFn factories for workflow subagent dispatch.
+ *
+ * Two layers:
+ *
+ *   1. **Output protocol** — agent-facing convention for delivering the
+ *      structured output a workflow step needs.  The agent emits a
+ *      well-known marker block in its final assistant message; the
+ *      workflow runtime parses the marker and extracts JSON.
+ *
+ *   2. **Factories** —
+ *        - `createStubSpawnFn(handler)`: dev / test seam.  Wraps a
+ *          user-supplied `(input) => Promise<output>` so tests can
+ *          drive the orchestrator/loop end-to-end without spinning up
+ *          a real worker.
+ *        - `createDaemonSpawnFn(deps)`: real daemon-backed spawn.
+ *          v0 ships the signature + a TODO body; the daemon wiring
+ *          (worker-pool fork, transcript capture, kill on timeout)
+ *          lands as a Slice D follow-up.  The interface is stable so
+ *          the orchestrator and loop don't have to change when the
+ *          live spawner lands.
+ *
+ * Why a marker block instead of "last JSON message wins": the agent
+ * naturally produces conversational prose plus tool calls plus a final
+ * answer; a marker is the only thing that survives prose around it
+ * cleanly.  The marker matches what the planned `botmux-workflow` skill
+ * (UI doc §9) will inject as a tool wrapper.
+ */
+import type { BotSnapshot } from './events/payloads.js';
+import type { WorkerSpawnFn, WorkerSpawnInput, WorkerSessionInfo } from './runtime.js';
+export declare const WORKFLOW_OUTPUT_BEGIN = "<WORKFLOW_OUTPUT>";
+export declare const WORKFLOW_OUTPUT_END = "</WORKFLOW_OUTPUT>";
+/**
+ * Augment a step's prompt with the output-protocol footer.  Callers
+ * should prepend / replace the agent prompt with this so the agent
+ * knows how to deliver structured output.  Idempotent: re-applying
+ * doesn't double-stack the footer.
+ */
+export declare function withWorkflowOutputProtocol(prompt: string): string;
+export type ParseWorkflowOutputResult = {
+    ok: true;
+    value: unknown;
+    raw: string;
+} | {
+    ok: false;
+    reason: 'no-marker' | 'unclosed-marker' | 'invalid-json';
+    detail?: string;
+};
+/**
+ * Extract structured JSON from an agent's final transcript.
+ *
+ * Strategy — anchored from the **last** `</WORKFLOW_OUTPUT>` (END)
+ * marker:
+ *   - find the most recent END
+ *   - find the latest BEGIN that precedes that END
+ *   - everything between is the "final" block
+ *   - parse as JSON
+ *
+ * Why anchor from the end: real LLM transcripts often include earlier
+ * draft markers (the agent revises mid-stream).  A naive
+ * "first BEGIN → next END" scan can splice across a malformed early
+ * block.  Anchoring from the END gives us the last *complete* block.
+ *
+ * Failure modes:
+ *   - no BEGIN anywhere → `no-marker`
+ *   - BEGIN(s) but no END → `unclosed-marker`
+ *   - block exists but content isn't JSON → `invalid-json` + parser msg
+ */
+export declare function parseWorkflowOutput(text: string): ParseWorkflowOutputResult;
+export type StubSpawnHandler = (input: WorkerSpawnInput) => Promise<unknown> | unknown;
+/**
+ * Wrap a plain handler so it satisfies `WorkerSpawnFn`.  Always
+ * returns success; the handler's return value is treated as the
+ * structured output.  Use for tests / dev where you just need a
+ * deterministic answer.
+ *
+ * NB: this factory is a structured-output shortcut.  It does NOT
+ * simulate the agent-side marker protocol — the handler receives the
+ * raw `WorkerSpawnInput` (not the prompt-with-protocol-footer) and
+ * returns the output value directly.  Tests that want to exercise
+ * `parseWorkflowOutput` should call `createDaemonSpawnFn` with a
+ * `runOneShot` that fakes the transcript.
+ */
+export declare function createStubSpawnFn(handler: StubSpawnHandler): WorkerSpawnFn;
+/**
+ * Input the daemon's one-shot worker invocation needs from the
+ * workflow runtime.  Carries the FULL frozen-identity + execution-
+ * policy contract through — `botSnapshot` is what `runCreated`
+ * froze, not whatever bot-registry currently says.  Per UI doc §3.4,
+ * mutating bots.json after a run starts must not change execution.
+ */
+export type DaemonRunOneShotInput = {
+    botName: string;
+    botSnapshot?: BotSnapshot;
+    prompt: string;
+    workingDir?: string;
+    modelOverrides?: {
+        model?: string;
+        reasoningEffort?: string;
+    };
+    toolPolicy?: {
+        allow?: string[];
+        deny?: string[];
+    };
+    timeoutMs?: number;
+    /** Run/node/activity context — daemon may use to mint a worker id or
+     *  tag sidecar artifacts.  Required so the daemon never has to
+     *  back-resolve identity from globals. */
+    runId: string;
+    nodeId: string;
+    activityId: string;
+    attemptId: string;
+    /** Conventional per-attempt execution log path. */
+    attemptLogPath?: string;
+    /**
+     * Cooperative cancel handle (v0.1.4-a slice 2).  When `aborted` fires,
+     * the daemon-backed runOneShot sends the worker a close message + SIGINT
+     * for a graceful shutdown, then escalates to SIGKILL after `cancelGraceMs`.
+     * Resolves the outer Promise via `WorkflowSpawnCancelledError` so
+     * `createDaemonSpawnFn` can map it to `{ kind: 'cancelled', cancelOriginEventId }`.
+     */
+    cancelSignal?: AbortSignal;
+};
+/**
+ * Sentinel error class used by `runOneShot` to signal cancel — caught by
+ * `createDaemonSpawnFn` and translated into a `WorkerSpawnResult` of
+ * `kind: 'cancelled'`.  Keeping it a distinct class (instead of e.g. a
+ * `result.cancelled?` field) lets test stubs reject with it without
+ * needing to know the `DaemonRunOneShotResult` shape.
+ */
+export declare class WorkflowSpawnCancelledError extends Error {
+    readonly cancelOriginEventId: string;
+    readonly session?: WorkerSessionInfo;
+    constructor(cancelOriginEventId: string, session?: WorkerSessionInfo);
+}
+export type DaemonRunOneShotResult = {
+    finalTranscript: string;
+    session: WorkerSessionInfo;
+};
+/**
+ * Hooks the workflow runtime needs from the daemon to spawn real
+ * workers.  Caller (daemon startup) builds an instance of this shape
+ * and passes it to `createDaemonSpawnFn`.
+ *
+ * v0 ships only the type; the runtime can keep going with stub spawns
+ * while the daemon wiring lands.  The split lets us land workflow
+ * runtime + cards + loop without blocking on worker.ts integration.
+ */
+export type DaemonSpawnDeps = {
+    /**
+     * Fork a worker bound to the named bot, hand it the prompt, and
+     * resolve with the worker's final transcript text (or reject on
+     * crash / timeout).  Implementation reuses
+     * `src/core/worker-pool.ts forkWorker` + a transient root id.
+     */
+    runOneShot(input: DaemonRunOneShotInput): Promise<DaemonRunOneShotResult>;
+};
+/**
+ * Compose a `WorkerSpawnFn` that uses real daemon hooks.  The hooks
+ * are injected so the workflows package doesn't pull in daemon
+ * internals.  v0 placeholder is documented; the daemon integration
+ * lands as a follow-up.
+ */
+export declare function createDaemonSpawnFn(deps: DaemonSpawnDeps): WorkerSpawnFn;
+//# sourceMappingURL=spawn-bot.d.ts.map

package/dist/workflows/spawn-bot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-bot.d.ts","sourceRoot":"","sources":["../../src/workflows/spawn-bot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAItB,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AACzD,eAAO,MAAM,mBAAmB,uBAAuB,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGjE;AAED,MAAM,MAAM,yBAAyB,GACjC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,GAAG,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,yBAAyB,CAsB3E;AAiBD,MAAM,MAAM,gBAAgB,GAAG,CAC7B,KAAK,EAAE,gBAAgB,KACpB,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEhC;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,aAAa,CAc1E;AAID;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9D,UAAU,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;8CAE0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;gBACzB,mBAAmB,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB;CAMrE;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;CAC3E,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,aAAa,CAmDxE"}

package/dist/workflows/spawn-bot.js

@@ -0,0 +1,215 @@
+/**
+ * WorkerSpawnFn factories for workflow subagent dispatch.
+ *
+ * Two layers:
+ *
+ *   1. **Output protocol** — agent-facing convention for delivering the
+ *      structured output a workflow step needs.  The agent emits a
+ *      well-known marker block in its final assistant message; the
+ *      workflow runtime parses the marker and extracts JSON.
+ *
+ *   2. **Factories** —
+ *        - `createStubSpawnFn(handler)`: dev / test seam.  Wraps a
+ *          user-supplied `(input) => Promise<output>` so tests can
+ *          drive the orchestrator/loop end-to-end without spinning up
+ *          a real worker.
+ *        - `createDaemonSpawnFn(deps)`: real daemon-backed spawn.
+ *          v0 ships the signature + a TODO body; the daemon wiring
+ *          (worker-pool fork, transcript capture, kill on timeout)
+ *          lands as a Slice D follow-up.  The interface is stable so
+ *          the orchestrator and loop don't have to change when the
+ *          live spawner lands.
+ *
+ * Why a marker block instead of "last JSON message wins": the agent
+ * naturally produces conversational prose plus tool calls plus a final
+ * answer; a marker is the only thing that survives prose around it
+ * cleanly.  The marker matches what the planned `botmux-workflow` skill
+ * (UI doc §9) will inject as a tool wrapper.
+ */
+// ─── Output protocol ──────────────────────────────────────────────────────
+export const WORKFLOW_OUTPUT_BEGIN = '<WORKFLOW_OUTPUT>';
+export const WORKFLOW_OUTPUT_END = '</WORKFLOW_OUTPUT>';
+/**
+ * Augment a step's prompt with the output-protocol footer.  Callers
+ * should prepend / replace the agent prompt with this so the agent
+ * knows how to deliver structured output.  Idempotent: re-applying
+ * doesn't double-stack the footer.
+ */
+export function withWorkflowOutputProtocol(prompt) {
+    if (prompt.includes(WORKFLOW_OUTPUT_BEGIN))
+        return prompt;
+    return `${prompt}\n\n---\nWhen you finish, emit your final structured output between the markers below as a single valid JSON value.  Do not include anything else inside the markers.\n\n${WORKFLOW_OUTPUT_BEGIN}\n{"...your JSON output..."}\n${WORKFLOW_OUTPUT_END}\n`;
+}
+/**
+ * Extract structured JSON from an agent's final transcript.
+ *
+ * Strategy — anchored from the **last** `</WORKFLOW_OUTPUT>` (END)
+ * marker:
+ *   - find the most recent END
+ *   - find the latest BEGIN that precedes that END
+ *   - everything between is the "final" block
+ *   - parse as JSON
+ *
+ * Why anchor from the end: real LLM transcripts often include earlier
+ * draft markers (the agent revises mid-stream).  A naive
+ * "first BEGIN → next END" scan can splice across a malformed early
+ * block.  Anchoring from the END gives us the last *complete* block.
+ *
+ * Failure modes:
+ *   - no BEGIN anywhere → `no-marker`
+ *   - BEGIN(s) but no END → `unclosed-marker`
+ *   - block exists but content isn't JSON → `invalid-json` + parser msg
+ */
+export function parseWorkflowOutput(text) {
+    const lastEnd = text.lastIndexOf(WORKFLOW_OUTPUT_END);
+    if (lastEnd < 0) {
+        return text.includes(WORKFLOW_OUTPUT_BEGIN)
+            ? { ok: false, reason: 'unclosed-marker' }
+            : { ok: false, reason: 'no-marker' };
+    }
+    const beginBeforeEnd = text.lastIndexOf(WORKFLOW_OUTPUT_BEGIN, lastEnd);
+    if (beginBeforeEnd < 0) {
+        return { ok: false, reason: 'no-marker' };
+    }
+    const rawBlock = text.slice(beginBeforeEnd + WORKFLOW_OUTPUT_BEGIN.length, lastEnd).trim();
+    const block = sanitizeWorkflowOutputBlock(rawBlock);
+    try {
+        return { ok: true, value: JSON.parse(block), raw: block };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: 'invalid-json',
+            detail: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function sanitizeWorkflowOutputBlock(block) {
+    // PTY fallback transcripts can include terminal control sequences and
+    // hard-wrapped CR/LF bytes inside an otherwise valid one-line JSON block.
+    // Agent transcript files remain preferred when available; this keeps the
+    // fallback from rejecting clean model output just because the terminal view
+    // polluted it.
+    return block
+        .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, '')
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+        .replace(/[\u0000-\u001f\u007f]/g, '')
+        .trim();
+}
+/**
+ * Wrap a plain handler so it satisfies `WorkerSpawnFn`.  Always
+ * returns success; the handler's return value is treated as the
+ * structured output.  Use for tests / dev where you just need a
+ * deterministic answer.
+ *
+ * NB: this factory is a structured-output shortcut.  It does NOT
+ * simulate the agent-side marker protocol — the handler receives the
+ * raw `WorkerSpawnInput` (not the prompt-with-protocol-footer) and
+ * returns the output value directly.  Tests that want to exercise
+ * `parseWorkflowOutput` should call `createDaemonSpawnFn` with a
+ * `runOneShot` that fakes the transcript.
+ */
+export function createStubSpawnFn(handler) {
+    return async (input) => {
+        const startedAt = Date.now();
+        const output = await Promise.resolve(handler(input));
+        const session = {
+            sessionId: `stub-${input.activityId}-${input.attemptId}`,
+            botName: input.botName,
+            cliId: input.botSnapshot?.cliId,
+            workingDir: input.workingDir,
+            startedAt,
+            endedAt: Date.now(),
+        };
+        return { kind: 'success', output, session };
+    };
+}
+/**
+ * Sentinel error class used by `runOneShot` to signal cancel — caught by
+ * `createDaemonSpawnFn` and translated into a `WorkerSpawnResult` of
+ * `kind: 'cancelled'`.  Keeping it a distinct class (instead of e.g. a
+ * `result.cancelled?` field) lets test stubs reject with it without
+ * needing to know the `DaemonRunOneShotResult` shape.
+ */
+export class WorkflowSpawnCancelledError extends Error {
+    cancelOriginEventId;
+    session;
+    constructor(cancelOriginEventId, session) {
+        super('workflow spawn cancelled');
+        this.name = 'WorkflowSpawnCancelledError';
+        this.cancelOriginEventId = cancelOriginEventId;
+        this.session = session;
+    }
+}
+/**
+ * Compose a `WorkerSpawnFn` that uses real daemon hooks.  The hooks
+ * are injected so the workflows package doesn't pull in daemon
+ * internals.  v0 placeholder is documented; the daemon integration
+ * lands as a follow-up.
+ */
+export function createDaemonSpawnFn(deps) {
+    return async (input) => {
+        const prompt = withWorkflowOutputProtocol(input.prompt);
+        let oneShot;
+        try {
+            oneShot = await deps.runOneShot({
+                botName: input.botName,
+                botSnapshot: input.botSnapshot,
+                prompt,
+                workingDir: input.workingDir,
+                modelOverrides: input.modelOverrides,
+                toolPolicy: input.toolPolicy,
+                runId: input.runId,
+                nodeId: input.nodeId,
+                activityId: input.activityId,
+                attemptId: input.attemptId,
+                attemptLogPath: input.attemptLogPath,
+                cancelSignal: input.cancelSignal,
+            });
+        }
+        catch (err) {
+            // Translate the sentinel cancel error into a cancelled spawn result.
+            if (err instanceof WorkflowSpawnCancelledError) {
+                return {
+                    kind: 'cancelled',
+                    cancelOriginEventId: err.cancelOriginEventId,
+                    session: err.session,
+                };
+            }
+            return {
+                kind: 'failure',
+                errorCode: 'WorkerCrashed',
+                errorClass: 'retryable',
+                errorMessage: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const parsed = parseWorkflowOutput(oneShot.finalTranscript);
+        if (!parsed.ok) {
+            return {
+                kind: 'failure',
+                errorCode: 'OutputSchemaViolation',
+                errorClass: 'manual',
+                errorMessage: formatParseFailure(parsed, oneShot.finalTranscript),
+                session: oneShot.session,
+            };
+        }
+        return {
+            kind: 'success',
+            output: parsed.value,
+            session: oneShot.session,
+        };
+    };
+}
+function formatParseFailure(parsed, transcript) {
+    // Truncate so log lines don't blow up — full transcript still lives
+    // in the worker's terminal log / session sidecar for debugging.
+    const SNIPPET_MAX = 240;
+    const snippet = transcript.length > SNIPPET_MAX
+        ? transcript.slice(0, SNIPPET_MAX) + '…(truncated)'
+        : transcript;
+    const detail = parsed.detail ? `: ${parsed.detail}` : '';
+    return (`Worker output did not contain a parseable ` +
+        `${WORKFLOW_OUTPUT_BEGIN}…${WORKFLOW_OUTPUT_END} block ` +
+        `(${parsed.reason}${detail}).  Transcript: ${JSON.stringify(snippet)}`);
+}
+//# sourceMappingURL=spawn-bot.js.map

package/dist/workflows/spawn-bot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-bot.js","sourceRoot":"","sources":["../../src/workflows/spawn-bot.ts"],"names":[],"mappings":"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"}

package/dist/workflows/system.d.ts

@@ -0,0 +1,49 @@
+/**
+ * System / recovery boundary host API (events doc v0.1.2 §2.6, Step 10
+ * of 10).
+ *
+ * Step 10 deliverables (paired with Step 7 resume + Step 9 cancel):
+ *   - `reportWorkerLost` — write `workerLost { workerId, lostActivityIds }`.
+ *     Resume already handles the consequence (Step 7):
+ *       * for each lost activity with dangling effectAttempted → run
+ *         the reconcile decision tree;
+ *       * for each lost activity without effectAttempted → write
+ *         activityFailed { WorkerCrashed, retryable };
+ *       * dangling waits stay alone (worker death is not a wait
+ *         resolution).
+ *     So this module only adds the host-side writer; the recovery
+ *     loop is already in place.
+ *
+ * Note on the cancel fan-out (also Step 10): the fan-out lives in
+ * replay (not here) — it's a deterministic projection of node/run
+ * cancel onto in-flight activities, not a new event-writing path.
+ */
+import type { EventLog } from './events/append.js';
+import type { WorkerLostEvent } from './events/types.js';
+export type ReportWorkerLostInput = {
+    /** Identifier of the worker that timed out / disconnected. */
+    workerId: string;
+    /**
+     * Activities the runtime registry believes the worker held leases
+     * for at the moment of detection.  Resume walks these alongside the
+     * generic dangling-set fallback — supplying them here lets the
+     * runtime tag the event with audit-grade evidence even if the
+     * dangling set picks up additional activities later.
+     */
+    lostActivityIds: string[];
+};
+/**
+ * Record a worker timeout / heartbeat loss.  Spec §2.6 v0.1.1: this is
+ * the system-fault path; explicitly NOT cancel.  Resume's recovery
+ * loop (Step 7) reads dangling state, not this event — workerLost is
+ * primarily an audit trail.  Writing it before resume runs is the
+ * recommended ordering so the audit reflects why recovery fired.
+ *
+ * Returns the appended event (with eventId etc).
+ *
+ * Throws if `lostActivityIds` is empty (spec mandates min 1; an empty
+ * list means "worker lost but had no work" which is a no-op the
+ * runtime should detect before writing this event).
+ */
+export declare function reportWorkerLost(log: EventLog, input: ReportWorkerLostInput): Promise<WorkerLostEvent>;
+//# sourceMappingURL=system.d.ts.map

package/dist/workflows/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/workflows/system.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,MAAM,qBAAqB,GAAG;IAClC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,eAAe,CAAC,CAe1B"}

package/dist/workflows/system.js

@@ -0,0 +1,48 @@
+/**
+ * System / recovery boundary host API (events doc v0.1.2 §2.6, Step 10
+ * of 10).
+ *
+ * Step 10 deliverables (paired with Step 7 resume + Step 9 cancel):
+ *   - `reportWorkerLost` — write `workerLost { workerId, lostActivityIds }`.
+ *     Resume already handles the consequence (Step 7):
+ *       * for each lost activity with dangling effectAttempted → run
+ *         the reconcile decision tree;
+ *       * for each lost activity without effectAttempted → write
+ *         activityFailed { WorkerCrashed, retryable };
+ *       * dangling waits stay alone (worker death is not a wait
+ *         resolution).
+ *     So this module only adds the host-side writer; the recovery
+ *     loop is already in place.
+ *
+ * Note on the cancel fan-out (also Step 10): the fan-out lives in
+ * replay (not here) — it's a deterministic projection of node/run
+ * cancel onto in-flight activities, not a new event-writing path.
+ */
+/**
+ * Record a worker timeout / heartbeat loss.  Spec §2.6 v0.1.1: this is
+ * the system-fault path; explicitly NOT cancel.  Resume's recovery
+ * loop (Step 7) reads dangling state, not this event — workerLost is
+ * primarily an audit trail.  Writing it before resume runs is the
+ * recommended ordering so the audit reflects why recovery fired.
+ *
+ * Returns the appended event (with eventId etc).
+ *
+ * Throws if `lostActivityIds` is empty (spec mandates min 1; an empty
+ * list means "worker lost but had no work" which is a no-op the
+ * runtime should detect before writing this event).
+ */
+export async function reportWorkerLost(log, input) {
+    if (input.lostActivityIds.length === 0) {
+        throw new Error(`reportWorkerLost(${input.workerId}): lostActivityIds is empty — the runtime should skip writing workerLost when the worker held no leases.`);
+    }
+    return (await log.append({
+        runId: log.runId,
+        type: 'workerLost',
+        actor: 'system',
+        payload: {
+            workerId: input.workerId,
+            lostActivityIds: input.lostActivityIds,
+        },
+    }));
+}
+//# sourceMappingURL=system.js.map

package/dist/workflows/system.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.js","sourceRoot":"","sources":["../../src/workflows/system.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAkBH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,GAAa,EACb,KAA4B;IAE5B,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,oBAAoB,KAAK,CAAC,QAAQ,0GAA0G,CAC7I,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,MAAM,GAAG,CAAC,MAAM,CAAC;QACvB,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,IAAI,EAAE,YAAY;QAClB,KAAK,EAAE,QAAQ;QACf,OAAO,EAAE;YACP,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,eAAe,EAAE,KAAK,CAAC,eAAe;SACvC;KACF,CAAC,CAAoB,CAAC;AACzB,CAAC"}

package/dist/workflows/trigger-run.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Shared workflow trigger — used by the dashboard catalog `POST .../run`
+ * route on the daemon side.  Wraps the load/coerce/createRun/drive sequence
+ * with injectable deps so the orchestration can be unit-tested without the
+ * full daemon process.
+ *
+ * IM `/workflow run` still goes through `executeWorkflowCommand`; this helper
+ * is the dashboard-trigger path that consumes pre-decoded JSON params and
+ * fires the workflow loop in the background.
+ */
+import { type RawParamInput } from './params.js';
+import { EventLog } from './events/append.js';
+import { type BotResolver } from './run-init.js';
+import type { WorkflowDefinition } from './definition.js';
+import type { WorkflowRuntimeContext, WorkerSpawnFn } from './runtime.js';
+export type TriggerInput = {
+    workflowId: string;
+    rawParams: Record<string, RawParamInput>;
+    chatBinding: {
+        chatId: string;
+        larkAppId: string;
+    };
+    initiator: string;
+};
+export type TriggerDeps = {
+    spawnSubagent: WorkerSpawnFn;
+    botResolver: BotResolver;
+    /** Build the ctx scaffolding (hostExecutors, reconcilers, loadEffectInput). */
+    makeRuntimeContext: (log: EventLog, def: WorkflowDefinition, spawnSubagent: WorkerSpawnFn) => WorkflowRuntimeContext;
+    /** Daemon side registers the ctx so future cancel/approve can find it. */
+    attachRuntime: (runId: string, ctx: WorkflowRuntimeContext) => {
+        ready?: Promise<unknown>;
+    };
+    /** Fire-and-forget loop drive — daemon owns the actual scheduling. */
+    driveRun: (runId: string) => void;
+    /** Test seam: override the file lookup. */
+    loadWorkflowDefinition?: (workflowId: string) => Promise<WorkflowDefinition>;
+    /** Test seam: deterministic run id. */
+    makeRunId?: (def: WorkflowDefinition) => string;
+    /** Test seam: explicit runs dir override. */
+    makeEventLog?: (runId: string) => EventLog;
+};
+export type TriggerSuccess = {
+    ok: true;
+    runId: string;
+    workflowId: string;
+    status: string;
+    lastSeq: number;
+};
+export type TriggerFailure = {
+    ok: false;
+    error: 'unknown_workflow';
+    message: string;
+} | {
+    ok: false;
+    error: 'invalid_params';
+    message: string;
+    issues: Array<{
+        path: string[];
+        code: string;
+        message: string;
+    }>;
+} | {
+    ok: false;
+    error: 'load_definition_failed' | 'internal_error';
+    message: string;
+};
+export type TriggerResult = TriggerSuccess | TriggerFailure;
+export declare function triggerWorkflowRun(input: TriggerInput, deps: TriggerDeps): Promise<TriggerResult>;
+//# sourceMappingURL=trigger-run.d.ts.map

package/dist/workflows/trigger-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-run.d.ts","sourceRoot":"","sources":["../../src/workflows/trigger-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAC3F,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAG9C,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE1E,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACzC,WAAW,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;IACzB,+EAA+E;IAC/E,kBAAkB,EAAE,CAClB,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,kBAAkB,EACvB,aAAa,EAAE,aAAa,KACzB,sBAAsB,CAAC;IAC5B,0EAA0E;IAC1E,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,sBAAsB,KAAK;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;IAC5F,sEAAsE;IACtE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,2CAA2C;IAC3C,sBAAsB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC7E,uCAAuC;IACvC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,MAAM,CAAC;IAChD,6CAA6C;IAC7C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,QAAQ,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB;IACE,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,kBAAkB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,gBAAgB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClE,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,wBAAwB,GAAG,gBAAgB,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEN,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,cAAc,CAAC;AAE5D,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,aAAa,CAAC,CAmExB"}

package/dist/workflows/trigger-run.js

@@ -0,0 +1,88 @@
+/**
+ * Shared workflow trigger — used by the dashboard catalog `POST .../run`
+ * route on the daemon side.  Wraps the load/coerce/createRun/drive sequence
+ * with injectable deps so the orchestration can be unit-tested without the
+ * full daemon process.
+ *
+ * IM `/workflow run` still goes through `executeWorkflowCommand`; this helper
+ * is the dashboard-trigger path that consumes pre-decoded JSON params and
+ * fires the workflow loop in the background.
+ */
+import { coerceWorkflowParams, ParamCoerceFailure } from './params.js';
+import { EventLog } from './events/append.js';
+import { loadWorkflowDefinition as defaultLoadWorkflowDefinition } from './loader.js';
+import { mintWorkflowRunId } from './run-id.js';
+import { createRun } from './run-init.js';
+import { replay } from './events/replay.js';
+import { getRunsDir } from './runs-dir.js';
+export async function triggerWorkflowRun(input, deps) {
+    const loadDef = deps.loadWorkflowDefinition ?? defaultLoadWorkflowDefinition;
+    let def;
+    try {
+        def = await loadDef(input.workflowId);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith(`Workflow '${input.workflowId}' not found`)) {
+            return { ok: false, error: 'unknown_workflow', message };
+        }
+        return { ok: false, error: 'load_definition_failed', message };
+    }
+    let coerced;
+    try {
+        coerced = coerceWorkflowParams(def, input.rawParams);
+    }
+    catch (err) {
+        if (err instanceof ParamCoerceFailure) {
+            return {
+                ok: false,
+                error: 'invalid_params',
+                message: err.message,
+                issues: err.issues.map((i) => ({
+                    path: i.name ? [i.name] : [],
+                    code: i.code,
+                    message: i.message,
+                })),
+            };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: 'internal_error', message };
+    }
+    try {
+        const runId = (deps.makeRunId ?? ((d) => mintWorkflowRunId(d.workflowId, Date.now())))(def);
+        const log = deps.makeEventLog ? deps.makeEventLog(runId) : new EventLog(runId, getRunsDir());
+        const ctx = deps.makeRuntimeContext(log, def, deps.spawnSubagent);
+        await createRun(log, {
+            def,
+            params: coerced,
+            initiator: input.initiator,
+            botResolver: deps.botResolver,
+            chatBinding: input.chatBinding,
+        });
+        const watcher = deps.attachRuntime(runId, ctx);
+        if (watcher.ready) {
+            try {
+                await watcher.ready;
+            }
+            catch {
+                // watcher start failures are logged by the daemon; the run is still
+                // valid and will keep producing events the watcher can re-pick on
+                // restart, so don't abort the trigger here.
+            }
+        }
+        deps.driveRun(runId);
+        const snapshot = replay(await log.readAll());
+        return {
+            ok: true,
+            runId,
+            workflowId: def.workflowId,
+            status: snapshot.run.status,
+            lastSeq: snapshot.lastSeq,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: 'internal_error', message };
+    }
+}
+//# sourceMappingURL=trigger-run.js.map