maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

package/node_modules/@maka/core/dist/tool-ledger-scanner.js

@@ -27,11 +27,11 @@ import { canonicalToolArgsHash } from './tool-args-identity.js';
  * at `running` with no terminal event at all (#2234). This error is always a
  * producer bug: something emitted a fact the ledger's invariants forbid.
  *
- * It deliberately does NOT cover a ledger that is already corrupt. That refusal
- * rejects well-formed candidates because of damage elsewhere in the workspace,
- * so "the store is healthy" is false and the run must keep failing closed —
- * see `ToolLedgerCorruptionError`, which is a plain durability failure and is
- * classified as one.
+ * It deliberately does NOT cover a ledger dependency closure that is already
+ * corrupt. That refusal rejects well-formed candidates because of damage in
+ * the facts they depend on, so "the store is healthy for this run" is false and
+ * the run must keep failing closed — see `ToolLedgerCorruptionError`, which is
+ * a plain durability failure and is classified as one.
  */
 export class ToolLedgerRejectionError extends Error {
     code;
@@ -44,10 +44,11 @@ export class ToolLedgerRejectionError extends Error {
     }
 }
 /**
- * The ledger the store already holds is corrupt, so it refuses writes that have
- * nothing wrong with them. Unlike `ToolLedgerRejectionError` this is not a
- * producer bug and the store is not usable: nothing the run emits next can be
- * trusted to land, so it stays on the fail-closed path.
+ * The selected tool dependency closure is already corrupt, so it refuses a
+ * candidate that has nothing wrong with it. Unlike `ToolLedgerRejectionError`
+ * this is not a producer bug. The affected run stays on the fail-closed path;
+ * unrelated closures remain writable and explicit full-ledger audit owns
+ * discovery outside the active closure.
  */
 export class ToolLedgerCorruptionError extends Error {
     code;
@@ -59,6 +60,23 @@ export class ToolLedgerCorruptionError extends Error {
         this.eventId = eventId;
     }
 }
+/** Operation identities whose invocation closure must accompany these facts. */
+export function referencedToolOperationIds(events) {
+    const operationIds = new Set();
+    for (const event of events) {
+        const dispatchOperationId = event.actions?.toolDispatch?.operationId;
+        const recoveryOperationId = event.actions?.toolRecovery?.payload.operationId;
+        if (dispatchOperationId)
+            operationIds.add(dispatchOperationId);
+        if (recoveryOperationId)
+            operationIds.add(recoveryOperationId);
+        if (event.refs?.operationId)
+            operationIds.add(event.refs.operationId);
+        if (event.refs?.parentOperationId)
+            operationIds.add(event.refs.parentOperationId);
+    }
+    return operationIds;
+}
 /**
  * Enforces the semantic boundary for durable tool-ledger facts.
  *
@@ -113,95 +131,153 @@ export function validateGenericToolLedgerAppend(event) {
  * before committing its candidate events.
  */
 export function validateToolLedgerTransition(input) {
-    const existing = scanToolLedger(input.existingEvents);
-    if (existing.hasCorruption)
-        return issueValidation(existing.issues[0]);
-    const existingById = new Map(input.existingEvents.map((event) => [event.id, event]));
-    const candidates = [];
-    for (const candidate of input.candidateEvents) {
-        const prior = existingById.get(candidate.id);
-        if (!prior) {
-            candidates.push(candidate);
-            continue;
-        }
-        if (!nodeUtil.isDeepStrictEqual(prior, candidate)) {
-            return { ok: false, code: 'duplicate_event_id', eventId: candidate.id };
-        }
+    const reducer = new ToolLedgerReducer(input.existingEvents);
+    const validation = validateIncrementalToolLedgerTransition({
+        reducer,
+        candidateEvents: input.candidateEvents,
+        expectedTransition: input.expectedTransition,
+    });
+    if (validation.ok) {
+        reducer.commit(validation.checkpoint);
+        return { ok: true };
     }
-    const shape = validateTransitionShape(candidates, input.expectedTransition);
-    if (!shape.ok)
-        return shape;
-    const prospective = scanToolLedger([...input.existingEvents, ...candidates]);
-    if (prospective.hasCorruption)
-        return issueValidation(prospective.issues[0]);
-    return { ok: true };
+    const { source: _source, ...failure } = validation;
+    return failure;
 }
 /**
- * Scans immutable RuntimeEvents once, in physical ledger order. It owns the
- * duplicate/order/identity interpretation shared by Resolver and projection
- * rebuild; neither consumer may rebuild these maps independently.
+ * Stateful interpretation of an immutable RuntimeEvent prefix.
+ *
+ * Candidate appends mutate the reducer behind a checkpoint. The caller either
+ * commits that checkpoint after durable transaction commit or rolls it back.
+ * Rollback records only the fields touched by the candidate batch, so a small
+ * append does not clone maps proportional to the full checked prefix.
  */
-export function scanToolLedger(events) {
-    const operations = [];
-    const issues = [];
-    const seenEventIds = new Set();
-    const byToolCall = new Map();
-    const byOperation = new Map();
-    const invocationSpines = new Map();
-    const addIssue = (operation, issue) => {
-        issues.push(issue);
-        operation?.issues.push(issue);
-    };
-    for (const event of events) {
-        if (seenEventIds.has(event.id)) {
-            addIssue(undefined, { code: 'duplicate_event_id', eventId: event.id });
-            continue;
+export class ToolLedgerReducer {
+    operations = [];
+    issues = [];
+    eventsById = new Map();
+    byToolCall = new Map();
+    byOperation = new Map();
+    invocationSpines = new Map();
+    undoLog = [];
+    recordUndo = false;
+    constructor(events = []) {
+        this.consume(events, false);
+    }
+    scan() {
+        const dependencyIssues = this.toolDependencyIssues();
+        if (dependencyIssues.length === 0) {
+            return {
+                operations: this.operations,
+                issues: this.issues,
+                hasCorruption: this.issues.length > 0,
+            };
+        }
+        const issuesByOperation = new Map();
+        for (const { operation, issue } of dependencyIssues) {
+            const issues = issuesByOperation.get(operation);
+            if (issues)
+                issues.push(issue);
+            else
+                issuesByOperation.set(operation, [issue]);
         }
-        seenEventIds.add(event.id);
+        return {
+            operations: this.operations.map((operation) => {
+                const dependency = issuesByOperation.get(operation);
+                return dependency
+                    ? { ...operation, issues: [...operation.issues, ...dependency] }
+                    : operation;
+            }),
+            issues: [...this.issues, ...dependencyIssues.map(({ issue }) => issue)],
+            hasCorruption: true,
+        };
+    }
+    event(eventId) {
+        return this.eventsById.get(eventId);
+    }
+    checkpoint() {
+        return this.undoLog.length;
+    }
+    append(events) {
+        this.consume(events, true);
+    }
+    rollback(checkpoint) {
+        this.assertCheckpoint(checkpoint);
+        for (let index = this.undoLog.length - 1; index >= checkpoint; index -= 1) {
+            this.undoLog[index]();
+        }
+        this.undoLog.length = checkpoint;
+    }
+    commit(checkpoint) {
+        this.assertCheckpoint(checkpoint);
+        this.undoLog.length = checkpoint;
+    }
+    assertCheckpoint(checkpoint) {
+        if (!Number.isSafeInteger(checkpoint) || checkpoint < 0 || checkpoint > this.undoLog.length) {
+            throw new RangeError('Invalid tool ledger reducer checkpoint');
+        }
+    }
+    consume(events, recordUndo) {
+        const previous = this.recordUndo;
+        this.recordUndo = recordUndo;
+        try {
+            for (const event of events)
+                this.consumeEvent(event);
+        }
+        finally {
+            this.recordUndo = previous;
+        }
+    }
+    consumeEvent(event) {
+        if (this.eventsById.has(event.id)) {
+            this.addIssue(undefined, { code: 'duplicate_event_id', eventId: event.id });
+            return;
+        }
+        this.setMap(this.eventsById, event.id, event);
         const spine = JSON.stringify([event.sessionId, event.runId, event.turnId]);
-        const existingSpine = invocationSpines.get(event.invocationId);
+        const existingSpine = this.invocationSpines.get(event.invocationId);
         if (existingSpine !== undefined && existingSpine !== spine) {
-            addIssue(undefined, {
+            this.addIssue(undefined, {
                 code: 'invocation_identity_conflict',
                 eventId: event.id,
             });
         }
         else {
-            invocationSpines.set(event.invocationId, spine);
+            this.setMap(this.invocationSpines, event.invocationId, spine);
         }
         const lane = validateToolLedgerEventLane(event);
         if (!lane.ok) {
-            addIssue(undefined, { code: lane.code, eventId: lane.eventId });
-            continue;
+            this.addIssue(undefined, { code: lane.code, eventId: lane.eventId });
+            return;
         }
         if (event.partial)
-            continue;
+            return;
         if (lane.lane === 'function_call') {
             const content = event.content;
             if (content?.kind !== 'function_call')
-                continue;
+                return;
             const toolCallKey = toolCallIdentity(event.invocationId, content.id);
-            const existing = byToolCall.get(toolCallKey);
+            const existing = this.byToolCall.get(toolCallKey);
             if (existing) {
                 if (!existing.callEvent) {
-                    existing.callEvent = event;
+                    this.setOperationField(existing, 'callEvent', event);
                     if (existing.toolName !== content.name) {
-                        addIssue(existing, {
+                        this.addIssue(existing, {
                             code: 'identity_conflict',
                             eventId: event.id,
                             toolCallId: content.id,
                             ...(existing.operationId ? { operationId: existing.operationId } : {}),
                         });
                     }
-                    continue;
+                    return;
                 }
-                addIssue(existing, {
+                this.addIssue(existing, {
                     code: 'duplicate_call',
                     eventId: event.id,
                     toolCallId: content.id,
                     ...(existing.operationId ? { operationId: existing.operationId } : {}),
                 });
-                continue;
+                return;
             }
             const operation = {
                 toolCallId: content.id,
@@ -211,16 +287,16 @@ export function scanToolLedger(events) {
                 decisionEvents: [],
                 issues: [],
             };
-            byToolCall.set(toolCallKey, operation);
-            operations.push(operation);
-            continue;
+            this.setMap(this.byToolCall, toolCallKey, operation);
+            this.push(this.operations, operation);
+            return;
         }
         if (lane.lane === 'tool_dispatch') {
             const dispatch = event.actions?.toolDispatch;
             if (!dispatch)
-                continue;
+                return;
             const toolCallKey = toolCallIdentity(event.invocationId, dispatch.providerToolCallId);
-            let operation = byToolCall.get(toolCallKey);
+            let operation = this.byToolCall.get(toolCallKey);
             if (!operation) {
                 operation = {
                     toolCallId: dispatch.providerToolCallId,
@@ -231,9 +307,9 @@ export function scanToolLedger(events) {
                     decisionEvents: [],
                     issues: [],
                 };
-                byToolCall.set(toolCallKey, operation);
-                operations.push(operation);
-                addIssue(operation, {
+                this.setMap(this.byToolCall, toolCallKey, operation);
+                this.push(this.operations, operation);
+                this.addIssue(operation, {
                     code: 'event_order_conflict',
                     eventId: event.id,
                     operationId: dispatch.operationId,
@@ -241,15 +317,15 @@ export function scanToolLedger(events) {
                 });
             }
             else if (operation.dispatchEvent) {
-                addIssue(operation, {
+                this.addIssue(operation, {
                     code: 'duplicate_dispatch',
                     eventId: event.id,
                     operationId: dispatch.operationId,
                     toolCallId: dispatch.providerToolCallId,
                 });
-                continue;
+                return;
             }
-            const existingOperation = byOperation.get(dispatch.operationId);
+            const existingOperation = this.byOperation.get(dispatch.operationId);
             if (existingOperation && existingOperation !== operation) {
                 const issue = {
                     code: 'duplicate_operation',
@@ -257,19 +333,20 @@ export function scanToolLedger(events) {
                     operationId: dispatch.operationId,
                     toolCallId: dispatch.providerToolCallId,
                 };
-                issues.push(issue);
-                existingOperation.issues.push(issue);
-                operation.issues.push(issue);
-                continue;
+                this.push(this.issues, issue);
+                this.push(existingOperation.issues, issue);
+                this.push(operation.issues, issue);
+                return;
             }
-            operation.operationId = dispatch.operationId;
-            operation.dispatchEvent = event;
-            byOperation.set(dispatch.operationId, operation);
+            this.setOperationField(operation, 'operationId', dispatch.operationId);
+            this.setOperationField(operation, 'dispatchEvent', event);
+            this.setMap(this.byOperation, dispatch.operationId, operation);
             if (operation.toolName !== dispatch.toolName ||
                 event.refs?.operationId !== dispatch.operationId ||
                 event.refs?.toolCallId !== dispatch.providerToolCallId ||
-                (operation.callEvent !== undefined && !sameExecutionIdentity(operation.callEvent, event))) {
-                addIssue(operation, {
+                (operation.callEvent !== undefined && !sameExecutionIdentity(operation.callEvent, event)) ||
+                callRefsConflict(operation.callEvent, event)) {
+                this.addIssue(operation, {
                     code: 'identity_conflict',
                     eventId: event.id,
                     operationId: dispatch.operationId,
@@ -286,7 +363,7 @@ export function scanToolLedger(events) {
                     // A provider call that is not strict JSON cannot authenticate T1.
                 }
                 if (canonicalArgsHash !== dispatch.canonicalArgsHash) {
-                    addIssue(operation, {
+                    this.addIssue(operation, {
                         code: 'canonical_args_hash_conflict',
                         eventId: event.id,
                         operationId: dispatch.operationId,
@@ -295,7 +372,7 @@ export function scanToolLedger(events) {
                 }
             }
             if (operation.responseEvent) {
-                addIssue(operation, {
+                this.addIssue(operation, {
                     code: 'event_order_conflict',
                     eventId: event.id,
                     operationId: dispatch.operationId,
@@ -304,7 +381,7 @@ export function scanToolLedger(events) {
                 if (operation.responseEvent.refs?.operationId !== dispatch.operationId ||
                     operation.responseEvent.refs?.toolCallId !== dispatch.providerToolCallId ||
                     !sameExecutionIdentity(event, operation.responseEvent)) {
-                    addIssue(operation, {
+                    this.addIssue(operation, {
                         code: 'identity_conflict',
                         eventId: operation.responseEvent.id,
                         operationId: dispatch.operationId,
@@ -312,14 +389,14 @@ export function scanToolLedger(events) {
                     });
                 }
             }
-            continue;
+            return;
         }
         if (lane.lane === 'function_response') {
             const content = event.content;
             if (content?.kind !== 'function_response')
-                continue;
+                return;
             const toolCallKey = toolCallIdentity(event.invocationId, content.id);
-            const operation = byToolCall.get(toolCallKey);
+            const operation = this.byToolCall.get(toolCallKey);
             if (!operation) {
                 const orphan = {
                     toolCallId: content.id,
@@ -329,60 +406,229 @@ export function scanToolLedger(events) {
                     decisionEvents: [],
                     issues: [],
                 };
-                operations.push(orphan);
-                byToolCall.set(toolCallKey, orphan);
-                addIssue(orphan, {
+                this.push(this.operations, orphan);
+                this.setMap(this.byToolCall, toolCallKey, orphan);
+                this.addIssue(orphan, {
                     code: 'orphan_response',
                     eventId: event.id,
                     toolCallId: content.id,
                 });
-                continue;
+                return;
             }
             if (operation.responseEvent) {
-                addIssue(operation, {
+                this.addIssue(operation, {
                     code: 'duplicate_response',
                     eventId: event.id,
                     toolCallId: content.id,
                     ...(operation.operationId ? { operationId: operation.operationId } : {}),
                 });
-                continue;
+                return;
             }
-            operation.responseEvent = event;
+            this.setOperationField(operation, 'responseEvent', event);
             if (operation.toolName !== content.name ||
                 !sameExecutionIdentity(operation.callEvent, event) ||
                 (operation.operationId !== undefined &&
                     (event.refs?.operationId !== operation.operationId ||
                         event.refs.toolCallId !== operation.toolCallId))) {
-                addIssue(operation, {
+                this.addIssue(operation, {
                     code: 'identity_conflict',
                     eventId: event.id,
                     toolCallId: content.id,
                     ...(operation.operationId ? { operationId: operation.operationId } : {}),
                 });
             }
-            continue;
+            return;
         }
         if (lane.lane === 'reconcile_result' || lane.lane === 'recovery_decision') {
             const fact = event.actions?.toolRecovery;
             if (!fact)
-                continue;
-            const operation = byOperation.get(fact.payload.operationId);
+                return;
+            const operation = this.byOperation.get(fact.payload.operationId);
             if (!operation) {
-                addIssue(undefined, {
+                this.addIssue(undefined, {
                     code: 'event_order_conflict',
                     eventId: event.id,
                     operationId: fact.payload.operationId,
                     ...(event.refs?.toolCallId ? { toolCallId: event.refs.toolCallId } : {}),
                 });
-                continue;
+                return;
             }
             if (lane.lane === 'reconcile_result')
-                operation.reconcileEvents.push(event);
+                this.push(operation.reconcileEvents, event);
             else
-                operation.decisionEvents.push(event);
+                this.push(operation.decisionEvents, event);
         }
     }
-    return { operations, issues, hasCorruption: issues.length > 0 };
+    addIssue(operation, issue) {
+        this.push(this.issues, issue);
+        if (operation)
+            this.push(operation.issues, issue);
+    }
+    push(values, value) {
+        const length = values.length;
+        this.undo(() => {
+            values.length = length;
+        });
+        values.push(value);
+    }
+    setMap(values, key, value) {
+        const had = values.has(key);
+        const previous = values.get(key);
+        this.undo(() => {
+            if (had)
+                values.set(key, previous);
+            else
+                values.delete(key);
+        });
+        values.set(key, value);
+    }
+    setOperationField(operation, key, value) {
+        const had = Object.hasOwn(operation, key);
+        const previous = operation[key];
+        this.undo(() => {
+            if (had)
+                operation[key] = previous;
+            else
+                delete operation[key];
+        });
+        operation[key] = value;
+    }
+    undo(operation) {
+        if (this.recordUndo)
+            this.undoLog.push(operation);
+    }
+    toolDependencyIssues() {
+        const result = [];
+        const parents = new Map();
+        for (const operation of this.operations) {
+            const dispatch = operation.dispatchEvent;
+            const parentOperationId = dispatch?.refs?.parentOperationId;
+            const parentToolCallId = dispatch?.refs?.parentToolCallId;
+            if (!dispatch || !parentOperationId || !parentToolCallId)
+                continue;
+            const parent = this.byOperation.get(parentOperationId);
+            if (!parent) {
+                result.push({
+                    operation,
+                    issue: {
+                        code: 'parent_operation_missing',
+                        eventId: dispatch.id,
+                        ...(operation.operationId ? { operationId: operation.operationId } : {}),
+                        toolCallId: operation.toolCallId,
+                    },
+                });
+                continue;
+            }
+            if (parent.toolCallId !== parentToolCallId) {
+                result.push({
+                    operation,
+                    issue: {
+                        code: 'parent_identity_conflict',
+                        eventId: dispatch.id,
+                        ...(operation.operationId ? { operationId: operation.operationId } : {}),
+                        toolCallId: operation.toolCallId,
+                    },
+                });
+                continue;
+            }
+            parents.set(operation, parent);
+        }
+        const state = new Map();
+        const stack = [];
+        const stackIndex = new Map();
+        const cyclic = new Set();
+        const visit = (operation) => {
+            if (state.get(operation) === 'visited')
+                return;
+            state.set(operation, 'visiting');
+            stackIndex.set(operation, stack.length);
+            stack.push(operation);
+            const parent = parents.get(operation);
+            if (parent) {
+                const parentState = state.get(parent);
+                if (parentState === 'visiting') {
+                    const index = stackIndex.get(parent);
+                    if (index !== undefined) {
+                        for (let cursor = index; cursor < stack.length; cursor += 1)
+                            cyclic.add(stack[cursor]);
+                    }
+                }
+                else if (parentState !== 'visited') {
+                    visit(parent);
+                }
+            }
+            stack.pop();
+            stackIndex.delete(operation);
+            state.set(operation, 'visited');
+        };
+        for (const operation of parents.keys())
+            visit(operation);
+        for (const operation of this.operations) {
+            if (!cyclic.has(operation) || !operation.dispatchEvent)
+                continue;
+            result.push({
+                operation,
+                issue: {
+                    code: 'parent_dependency_cycle',
+                    eventId: operation.dispatchEvent.id,
+                    ...(operation.operationId ? { operationId: operation.operationId } : {}),
+                    toolCallId: operation.toolCallId,
+                },
+            });
+        }
+        return result;
+    }
+}
+/**
+ * Applies one prospective writer batch to a checked prefix. A successful call
+ * leaves the candidate delta applied until the caller commits or rolls back the
+ * returned checkpoint. A rejected candidate restores the reducer immediately.
+ */
+export function validateIncrementalToolLedgerTransition(input) {
+    const existing = input.reducer.scan();
+    if (existing.hasCorruption) {
+        return { source: 'existing', ...issueValidation(existing.issues[0]) };
+    }
+    const candidates = [];
+    for (const candidate of input.candidateEvents) {
+        const prior = input.reducer.event(candidate.id);
+        if (!prior) {
+            candidates.push(candidate);
+            continue;
+        }
+        if (!nodeUtil.isDeepStrictEqual(prior, candidate)) {
+            return {
+                ok: false,
+                source: 'candidate',
+                code: 'duplicate_event_id',
+                eventId: candidate.id,
+            };
+        }
+    }
+    const shape = validateTransitionShape(candidates, input.expectedTransition);
+    if (!shape.ok)
+        return { source: 'candidate', ...shape };
+    const checkpoint = input.reducer.checkpoint();
+    try {
+        input.reducer.append(candidates);
+    }
+    catch (error) {
+        input.reducer.rollback(checkpoint);
+        throw error;
+    }
+    const issue = input.reducer.scan().issues[0];
+    if (issue) {
+        input.reducer.rollback(checkpoint);
+        return { source: 'candidate', ...issueValidation(issue) };
+    }
+    return { ok: true, checkpoint, appendedEvents: candidates.length };
+}
+/**
+ * Scans immutable RuntimeEvents once, in physical ledger order. Resolver,
+ * projection rebuild and incremental writers all use the same reducer rules.
+ */
+export function scanToolLedger(events) {
+    return new ToolLedgerReducer(events).scan();
 }
 function matchesLaneEnvelope(event, lane) {
     if (event.partial || event.status !== undefined || event.branch !== undefined)
@@ -472,6 +718,21 @@ function sameExecutionIdentity(first, second) {
         first.runId === second.runId &&
         first.turnId === second.turnId);
 }
+function callRefsConflict(call, dispatch) {
+    if (!call?.refs)
+        return false;
+    const expected = dispatch.actions?.toolDispatch;
+    if (!expected)
+        return false;
+    if ((call.refs.operationId !== undefined && call.refs.operationId !== expected.operationId) ||
+        (call.refs.toolCallId !== undefined && call.refs.toolCallId !== expected.providerToolCallId)) {
+        return true;
+    }
+    const callHasParent = call.refs.parentOperationId !== undefined || call.refs.parentToolCallId !== undefined;
+    return (callHasParent &&
+        (call.refs.parentOperationId !== dispatch.refs?.parentOperationId ||
+            call.refs.parentToolCallId !== dispatch.refs?.parentToolCallId));
+}
 function hasOnlyKeys(value, expected) {
     if (!value)
         return false;

package/node_modules/@maka/core/dist/turn-origin.js

@@ -25,6 +25,20 @@ const AGENT_GRAPH_ORIGIN_SHAPE = defineObjectShape()(['kind', 'graphId', 'wakeId
 export function decodeTurnOrigin(value) {
     if (!isRecord(value))
         return undefined;
+    if (value.kind === 'workhub_result') {
+        const keys = ['kind', 'eventId', 'actionId', 'delegationId', 'targetSessionId', 'targetTurnId'];
+        if (Object.keys(value).length !== keys.length ||
+            !keys.every((key) => typeof value[key] === 'string' && value[key].length > 0 && value[key].length <= 256))
+            return undefined;
+        return {
+            kind: 'workhub_result',
+            eventId: value.eventId,
+            actionId: value.actionId,
+            delegationId: value.delegationId,
+            targetSessionId: value.targetSessionId,
+            targetTurnId: value.targetTurnId,
+        };
+    }
     if (hasExactShape(value, SCHEDULED_TASK_ORIGIN_SHAPE) &&
         value.kind === 'scheduled_task' &&
         typeof value.scheduledTaskId === 'string') {