botmux 2.33.0 → 2.33.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/workflows/definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAMzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;EAErB,CAAC;AACZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,sEAAsE;AACtE,eAAO,MAAM,iBAAiB;;;;;;IAA6C,CAAC;AAC5E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAanD,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAIxD,eAAO,MAAM,kBAAkB,wCAAwB,CAAC;AAwBxD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAd7B;;;;;;;;;;OAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBH,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAnCjC;;;;;;;;;;OAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BH,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAIpD,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAhE7B;;;;;;;;;;OAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAVH;;;;;;;;;;OAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyDH,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,QAAsB,CAAC;AAMnD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAS/B;;;;;;;;;WASG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QApGP;;;;;;;;;;WAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAVH;;;;;;;;;;WAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+FH,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D;AAaD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAKjE;AAID;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CAIxE;AAiFD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,EAAE,CA0BlE"}

package/dist/workflows/definition.js

@@ -0,0 +1,334 @@
+/**
+ * WorkflowDefinition — canonical JSON shape for v0 workflows
+ * (see /tmp/wf-ui-v0.md §3 for the spec).
+ *
+ * Two node types:
+ *   - subagent     — runtime spawns the bot's worker, feeds `prompt`,
+ *                    collects `output` JSON.
+ *   - hostExecutor — runtime calls the executor registered by `executor`.
+ *
+ * The schema enforces shape; cross-field invariants (deps reachability,
+ * no cycles) are checked by `parseWorkflowDefinition`.  The `revisionId`
+ * helper computes a content hash over canonical JSON so semantically
+ * equal definitions get identical ids regardless of key ordering.
+ */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+// ─── Field schemas ─────────────────────────────────────────────────────────
+export const ParamDefSchema = z.object({
+    type: z.enum(['string', 'number', 'boolean', 'object', 'array']),
+    format: z.string().optional(),
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    description: z.string().optional(),
+});
+export const RetryPolicySchema = z.object({
+    maxAttempts: z.number().int().positive(),
+    backoff: z.enum(['fixed', 'exponential']),
+    baseMs: z.number().int().positive(),
+    factor: z.number().positive().optional(),
+    jitter: z.boolean().optional(),
+});
+/**
+ * Output binding — `{ "$ref": "<nodeId>.output.<path>" }` references the
+ * `output` of another node's most recent successful work activity.
+ *
+ * Hard constraints (all enforced at parse time):
+ *   - Object MUST be exactly one key (`$ref`), strict — no extra fields.
+ *     Half-parsed mixed objects are a footgun: callers might forget the
+ *     `$ref` key and silently get a literal object instead of resolved data.
+ *   - `$ref` must be a non-empty string; runtime `resolveRef` then enforces
+ *     the `.output.` separator + path-segment safety (no `__proto__` etc).
+ */
+export const OutputRefSpecSchema = z.object({
+    $ref: z.string().min(1),
+}).strict();
+/** A string field that may either be a literal or a single `$ref`. */
+export const BoundStringSchema = z.union([z.string(), OutputRefSpecSchema]);
+/**
+ * Recursive JSON allowing `OutputRefSpec` to appear at any leaf or sub-tree.
+ *
+ * Refusal rule for non-strict `$ref`-bearing objects: an object that has a
+ * `$ref` key MUST be an exact strict `OutputRefSpec`.  Mixing `$ref` with
+ * other keys is rejected at parse time to keep `$ref` a reserved form.
+ */
+export const BoundJsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    OutputRefSpecSchema,
+    z.array(BoundJsonValueSchema),
+    z.record(BoundJsonValueSchema).refine((obj) => !Object.prototype.hasOwnProperty.call(obj, '$ref'), { message: '`$ref` must appear in an exact `{ "$ref": <string> }` object — no extra keys allowed' }),
+]));
+export const HumanGateSchema = z.object({
+    // v0 only supports 'before'.  after-step gate would need a different
+    // dispatch model (suspend post-success); deferred to v1+.
+    stage: z.literal('before'),
+    prompt: BoundStringSchema,
+    approvers: z.array(z.string()).optional(),
+    deadlineMs: z.number().int().positive().optional(),
+    onTimeout: z.enum(['fail', 'success']).optional(),
+});
+// JSON Schema is opaque to us — workflow author owns validation rules,
+// runtime just feeds the schema to Ajv when validating output.
+export const OutputSchemaSchema = z.record(z.unknown());
+const NodeBaseShape = {
+    description: z.string().optional(),
+    depends: z.array(z.string()).optional(),
+    humanGate: HumanGateSchema.optional(),
+    retryPolicy: RetryPolicySchema.optional(),
+    timeoutMs: z.number().int().positive().optional(),
+    maxOutputBytes: z.number().int().positive().optional(),
+    outputSchema: OutputSchemaSchema.optional(),
+    /**
+     * Opt-in escape hatch for a side-effect hostExecutor node that *must* run
+     * without a humanGate (e.g. a system-internal cron tick, an explicitly
+     * batched send-all script).  Default is unset / false → validator rejects
+     * ungated side-effect executors at parse time (`SIDE_EFFECT_EXECUTORS`).
+     *
+     * Setting this to `true` is the workflow author's audit-trail: "I know
+     * this node sends a message / writes to repo / schedules a cron with no
+     * human approval — accept the risk."  Prefer `humanGate` whenever the
+     * intent is "let an operator confirm before this fires."
+     */
+    unsafeAllowUngated: z.boolean().optional(),
+};
+export const SubagentNodeSchema = z.object({
+    ...NodeBaseShape,
+    type: z.literal('subagent'),
+    bot: z.string().min(1),
+    prompt: BoundStringSchema,
+    workingDir: z.string().optional(),
+    modelOverrides: z
+        .object({
+        model: z.string().optional(),
+        reasoningEffort: z.string().optional(),
+    })
+        .optional(),
+    toolPolicy: z
+        .object({
+        allow: z.array(z.string()).optional(),
+        deny: z.array(z.string()).optional(),
+    })
+        .optional(),
+});
+export const HostExecutorNodeSchema = z.object({
+    ...NodeBaseShape,
+    type: z.literal('hostExecutor'),
+    executor: z.string().min(1),
+    input: BoundJsonValueSchema,
+});
+/**
+ * Executors that produce externally-visible side effects: sending a Feishu
+ * message, scheduling a botmux cron task, etc.  Validator requires a
+ * `humanGate.stage='before'` on any node using one of these executors, or
+ * an explicit `unsafeAllowUngated: true` opt-in (see NodeBaseShape).
+ *
+ * Add new executors here as they're registered with the dispatch table —
+ * keep this list in lockstep with `runtime.ts`'s side-effect executor
+ * registrations.  Read-only / pure-computation executors do NOT belong
+ * here; only ones whose execution is observable outside the workflow.
+ */
+export const SIDE_EFFECT_EXECUTORS = new Set([
+    'feishu-send',
+    'feishu-reply',
+    'botmux-schedule',
+]);
+export function isSideEffectExecutor(executor) {
+    return SIDE_EFFECT_EXECUTORS.has(executor);
+}
+export const WorkflowNodeSchema = z.discriminatedUnion('type', [
+    SubagentNodeSchema,
+    HostExecutorNodeSchema,
+]);
+/**
+ * Node id constraint: safe path segment for use in activityId and the
+ * artifact sidecar path (UI doc §A: `runs/<runId>/attempts/<activityId>/...`).
+ * Disallow `/`, `..`, whitespace, etc. so a maliciously authored or
+ * imported workflow cannot escape the run directory.
+ */
+export const NODE_ID_PATTERN = /^[A-Za-z0-9_.-]+$/;
+const NodeIdSchema = z.string().regex(NODE_ID_PATTERN, 'nodeId must match [A-Za-z0-9_.-]+ (no path separators or whitespace)');
+export const WorkflowDefinitionSchema = z.object({
+    workflowId: z.string().min(1),
+    version: z.number().int().positive(),
+    params: z.record(ParamDefSchema).optional(),
+    defaults: z
+        .object({
+        retryPolicy: RetryPolicySchema.optional(),
+        timeoutMs: z.number().int().positive().optional(),
+        maxOutputBytes: z.number().int().positive().optional(),
+        /**
+         * Cap on concurrent dispatch actions (dispatchGate + dispatchWork)
+         * within a single runLoop tick.  v0.1.3 first-cut parallelism defaults
+         * to 4 — small enough that a wide fan-out won't immediately exhaust
+         * worker / OOM headroom, large enough that ~typical 2-3 branch DAGs
+         * fully parallelize.  Set higher on workflows that want more throughput.
+         *
+         * Per-bot serialization is independent of this cap; same-bot siblings
+         * still get dispatched one-per-tick regardless of the limit.
+         */
+        maxConcurrency: z.number().int().positive().optional(),
+    })
+        .optional(),
+    nodes: z.record(NodeIdSchema, WorkflowNodeSchema),
+});
+// ─── Canonical JSON stringify ──────────────────────────────────────────────
+/**
+ * Canonical JSON: object keys sorted recursively, arrays preserved in
+ * order, compact (no extra whitespace).  Defined this way so that any
+ * authoring-tool round-trip (YAML→JSON, TS builder→JSON) produces an
+ * identical string when the underlying data is the same.
+ *
+ * Numbers are emitted via JSON.stringify so NaN/Infinity (illegal in
+ * JSON) round-trip to errors — caller should reject those in schema.
+ */
+export function canonicalJsonStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    const obj = value;
+    const sorted = {};
+    for (const k of Object.keys(obj).sort())
+        sorted[k] = canonicalize(obj[k]);
+    return sorted;
+}
+// ─── revisionId ────────────────────────────────────────────────────────────
+/**
+ * revisionId = sha256(canonicalJsonStringify(def)).
+ * Use the `version` field for human-readable semantic versions.
+ */
+export function computeRevisionId(def) {
+    return ('sha256:' +
+        createHash('sha256').update(canonicalJsonStringify(def)).digest('hex'));
+}
+// ─── Validation ────────────────────────────────────────────────────────────
+/**
+ * Schema parse + cross-field invariants:
+ *   1. every `depends` entry references an existing node
+ *   2. graph is acyclic
+ *   3. at least one root node (no deps)
+ *
+ * Throws on any failure.  Use `WorkflowDefinitionSchema.safeParse(...)`
+ * directly if you only need shape checks (no graph validation).
+ */
+export function parseWorkflowDefinition(raw) {
+    const def = WorkflowDefinitionSchema.parse(raw);
+    validateGraph(def);
+    return def;
+}
+function validateGraph(def) {
+    const ids = Object.keys(def.nodes);
+    if (ids.length === 0) {
+        throw new Error('Workflow must declare at least one node');
+    }
+    for (const nodeId of ids) {
+        // Defense-in-depth alongside NODE_ID_PATTERN: the regex permits `.`
+        // for compound names like `node.v2`, but standalone `.` or `..` —
+        // and any segment with `..` — must be banned to keep the artifact
+        // sidecar path (`runs/<runId>/attempts/<activityId>/...`) inside
+        // the run directory.
+        if (nodeId === '.' || nodeId === '..' || nodeId.includes('..')) {
+            throw new Error(`nodeId '${nodeId}' rejected: path-traversal style ids are not allowed`);
+        }
+    }
+    for (const [nodeId, node] of Object.entries(def.nodes)) {
+        for (const dep of node.depends ?? []) {
+            if (!def.nodes[dep]) {
+                throw new Error(`Node '${nodeId}' depends on unknown node '${dep}'`);
+            }
+            if (dep === nodeId) {
+                throw new Error(`Node '${nodeId}' depends on itself`);
+            }
+        }
+        // Safe-by-default: a hostExecutor node that runs a side-effect executor
+        // must either declare `humanGate.stage='before'` or opt into the audit
+        // trail via `unsafeAllowUngated: true`.  Catches ungated `feishu-send`
+        // and friends at parse time instead of relying on author discipline.
+        if (node.type === 'hostExecutor' &&
+            isSideEffectExecutor(node.executor) &&
+            !node.humanGate &&
+            !node.unsafeAllowUngated) {
+            throw new Error(`Node '${nodeId}' runs side-effect executor '${node.executor}' without ` +
+                `a humanGate. Add humanGate.stage='before' for human approval, or set ` +
+                `unsafeAllowUngated: true to acknowledge the risk explicitly.`);
+        }
+    }
+    detectCycle(def);
+    const hasRoot = ids.some((id) => (def.nodes[id].depends ?? []).length === 0);
+    if (!hasRoot) {
+        throw new Error('Workflow has no root node (every node has dependencies)');
+    }
+}
+function detectCycle(def) {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = new Map();
+    const ids = Object.keys(def.nodes);
+    ids.forEach((id) => color.set(id, WHITE));
+    const path = [];
+    const visit = (id) => {
+        const c = color.get(id);
+        if (c === BLACK)
+            return;
+        if (c === GRAY) {
+            const start = path.indexOf(id);
+            const cycle = [...path.slice(start), id].join(' → ');
+            throw new Error(`Workflow has cycle: ${cycle}`);
+        }
+        color.set(id, GRAY);
+        path.push(id);
+        for (const dep of def.nodes[id].depends ?? [])
+            visit(dep);
+        path.pop();
+        color.set(id, BLACK);
+    };
+    for (const id of ids)
+        visit(id);
+}
+// ─── Topological order ────────────────────────────────────────────────────
+/**
+ * Kahn's algorithm.  Returns nodeIds in dispatch-safe order (deps before
+ * dependents).  Ties broken by `Object.keys(nodes)` insertion order so
+ * the result is deterministic for a given workflow JSON.
+ *
+ * Assumes the graph is valid (no cycles); call `parseWorkflowDefinition`
+ * first or pass a definition that already came from there.
+ */
+export function topologicalOrder(def) {
+    const ids = Object.keys(def.nodes);
+    const indeg = new Map();
+    const children = new Map();
+    ids.forEach((id) => {
+        indeg.set(id, 0);
+        children.set(id, []);
+    });
+    for (const [id, node] of Object.entries(def.nodes)) {
+        for (const dep of node.depends ?? []) {
+            indeg.set(id, (indeg.get(id) ?? 0) + 1);
+            children.get(dep).push(id);
+        }
+    }
+    const queue = [];
+    for (const id of ids)
+        if ((indeg.get(id) ?? 0) === 0)
+            queue.push(id);
+    const order = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        order.push(id);
+        for (const child of children.get(id)) {
+            indeg.set(child, (indeg.get(child) ?? 0) - 1);
+            if ((indeg.get(child) ?? 0) === 0)
+                queue.push(child);
+        }
+    }
+    return order;
+}
+//# sourceMappingURL=definition.js.map

package/dist/workflows/definition.js.map

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

package/dist/workflows/effect-input.d.ts

@@ -0,0 +1,4 @@
+import type { EventLog } from './events/append.js';
+export declare function writeEffectInputSidecar(log: EventLog, activityId: string, attemptId: string, input: unknown): Promise<string>;
+export declare function loadEffectInputSidecar(log: EventLog, activityId: string, attemptId: string): Promise<unknown>;
+//# sourceMappingURL=effect-input.d.ts.map

package/dist/workflows/effect-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-input.d.ts","sourceRoot":"","sources":["../../src/workflows/effect-input.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAGlB"}

package/dist/workflows/effect-input.js

@@ -0,0 +1,18 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+export async function writeEffectInputSidecar(log, activityId, attemptId, input) {
+    const dir = await effectInputDir(log, activityId, attemptId);
+    const path = join(dir, 'effect-input.json');
+    await fs.writeFile(path, JSON.stringify(input, null, 2), 'utf-8');
+    return path;
+}
+export async function loadEffectInputSidecar(log, activityId, attemptId) {
+    const path = join(log.runDir, 'attempts', activityId, attemptId, 'effect-input.json');
+    return JSON.parse(await fs.readFile(path, 'utf-8'));
+}
+async function effectInputDir(log, activityId, attemptId) {
+    const dir = join(log.runDir, 'attempts', activityId, attemptId);
+    await fs.mkdir(dir, { recursive: true });
+    return dir;
+}
+//# sourceMappingURL=effect-input.js.map

package/dist/workflows/effect-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-input.js","sourceRoot":"","sources":["../../src/workflows/effect-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,GAAa,EACb,UAAkB,EAClB,SAAiB,EACjB,KAAc;IAEd,MAAM,GAAG,GAAG,MAAM,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;IAC7D,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,mBAAmB,CAAC,CAAC;IAC5C,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAClE,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,GAAa,EACb,UAAkB,EAClB,SAAiB;IAEjB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,mBAAmB,CAAC,CAAC;IACtF,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACtD,CAAC;AAED,KAAK,UAAU,cAAc,CAC3B,GAAa,EACb,UAAkB,EAClB,SAAiB;IAEjB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;IAChE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/workflows/events/append.d.ts

@@ -0,0 +1,77 @@
+import { INLINE_PAYLOAD_MAX_BYTES, PayloadRefSchema } from './schema.js';
+import type { WorkflowEvent } from './schema.js';
+/**
+ * What the runtime supplies to `append`.  The append path fills in
+ * `eventId` and `schemaVersion`.  Callers must supply `runId`, `type`,
+ * `actor`, `payload`, and may optionally pass `timestamp` (defaults to
+ * Date.now()) and/or `payloadHash` (only when payload is a ref — see
+ * events doc §1.1).
+ *
+ * The discriminated union over WorkflowEvent distributes through Omit, so
+ * each event type's payload shape is preserved at the call site.
+ */
+export type EventDraft = Omit<WorkflowEvent, 'eventId' | 'schemaVersion' | 'timestamp'> & {
+    timestamp?: number;
+};
+export declare class EventLog {
+    readonly runId: string;
+    readonly runDir: string;
+    readonly eventsFile: string;
+    readonly blobDir: string;
+    private seq;
+    private seqLoaded;
+    private cachedMtimeMs;
+    private cachedSize;
+    constructor(runId: string, baseDir: string);
+    /**
+     * Append one event.  Atomic across:
+     *   1. all EventLog instances for the same runId in this process
+     *      (module-level mutex map), and
+     *   2. other OS processes touching the same events file
+     *      (`withFileLock` over `events.ndjson.lock`).
+     *
+     * Codex round 4 finding 1: payload envelope MUST be inline.  Large
+     * business data goes through `OutputRef`-shaped fields (e.g.
+     * `runCreated.inputRef`, `activitySucceeded.outputRef`); the caller is
+     * responsible for writing the blob and passing a fully-formed
+     * `OutputRef` inline.  The append path no longer auto-spills payloads —
+     * doing so silently broke replay for any ref-payload event because the
+     * existing replay projection unconditionally skipped the ref branch.
+     *
+     * Payload-ref payloads (`{ ref, bytes, schemaVersion }`) are still
+     * supported for callers who genuinely need to ref-out the envelope
+     * payload (e.g. a custom dashboard projection), but the caller must
+     * supply both the blob and `payloadHash` upfront; this path is not
+     * exercised by the v0 runtime.
+     */
+    append(draft: EventDraft): Promise<WorkflowEvent>;
+    private appendLocked;
+    /**
+     * Read all events in append order.  Used by replay (events doc §5.2)
+     * and seq recovery on restart.  Returns [] if the log doesn't exist
+     * yet.
+     *
+     * Throws if any line fails schema validation — events doc treats the
+     * log as authoritative and corruption should fail loud, not silently
+     * skip lines.
+     */
+    readAll(): Promise<WorkflowEvent[]>;
+    /**
+     * Read the blob referenced by a ref-payload event.  Used when a caller
+     * elected to spill their own OutputRef payload to disk; not used by
+     * envelope-payload paths since v0.1.2 round-4 disallows envelope spill.
+     */
+    readBlob(ref: string): Promise<Buffer>;
+    /** Current seq counter — exposed for tests / dashboard. */
+    currentSeq(): Promise<number>;
+    /**
+     * Refresh `this.seq` if the events file has changed since we last loaded.
+     * Stat is cheap; full re-scan only fires when the cached mtime/size differ
+     * from disk — protects against another process having appended since our
+     * last write.
+     */
+    private refreshSeqIfStale;
+}
+export { PayloadRefSchema, INLINE_PAYLOAD_MAX_BYTES };
+export type { WorkflowEvent };
+//# sourceMappingURL=append.d.ts.map

package/dist/workflows/events/append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../../src/workflows/events/append.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,wBAAwB,EACxB,gBAAgB,EAGjB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA6CjD;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,eAAe,GAAG,WAAW,CAAC,GAAG;IACxF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAIF,qBAAa,QAAQ;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAGzB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAAK;gBAEX,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAW1C;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC;YAMzC,YAAY;IA+C1B;;;;;;;;OAQG;IACG,OAAO,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAsBzC;;;;OAIG;IACG,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI5C,2DAA2D;IACrD,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IASnC;;;;;OAKG;YACW,iBAAiB;CAgChC;AAID,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,CAAC"}