@jungjaehoon/mama-core 2.4.0 → 4.0.0

package/dist/{model-runs/store.js → runtime/model-run-store.js}

@@ -3,17 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.beginModelRunInAdapter = beginModelRunInAdapter;
-exports.commitModelRunInAdapter = commitModelRunInAdapter;
-exports.failModelRunInAdapter = failModelRunInAdapter;
-exports.getModelRunInAdapter = getModelRunInAdapter;
 exports.beginModelRun = beginModelRun;
 exports.commitModelRun = commitModelRun;
 exports.failModelRun = failModelRun;
 exports.getModelRun = getModelRun;
+exports.listModelRunNativeInputs = listModelRunNativeInputs;
 const node_crypto_1 = __importDefault(require("node:crypto"));
-const db_manager_js_1 = require("../db-manager.js");
-const types_js_1 = require("./types.js");
+const model_run_types_js_1 = require("./model-run-types.js");
 const BEGIN_REPLAY_FIELDS = [
     'model_id',
     'model_provider',
@@ -73,6 +69,14 @@ function requireTimestamp(value, field, modelRunId) {
 function normalizeNumber(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : fallback;
 }
+function requireTokenCount(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error('model_runs.token_count must be a non-negative safe integer');
+    }
+    return value;
+}
 function normalizeCost(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
@@ -125,7 +129,7 @@ function parseInputRefs(row) {
     }
     throw new Error(`Invalid model_runs.input_refs_json for ${row.model_run_id}: expected object`);
 }
-const MODEL_RUN_STATUS_SET = new Set(types_js_1.MODEL_RUN_STATUSES);
+const MODEL_RUN_STATUS_SET = new Set(model_run_types_js_1.MODEL_RUN_STATUSES);
 function requireModelRunStatus(value, modelRunId) {
     if (typeof value === 'string' && MODEL_RUN_STATUS_SET.has(value)) {
         return value;
@@ -167,10 +171,6 @@ function mapModelRunRow(row) {
             : null,
     };
 }
-async function initializedAdapter() {
-    await (0, db_manager_js_1.initDB)();
-    return (0, db_manager_js_1.getAdapter)();
-}
 function selectModelRun(adapter, id) {
     const row = adapter
         .prepare(`
@@ -329,11 +329,15 @@ function isDuplicateModelRunError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /UNIQUE constraint failed: model_runs\.model_run_id|PRIMARY KEY constraint failed/i.test(message);
 }
-function resolveExistingCommittedRun(existing, summary) {
+function resolveExistingCommittedRun(existing, summary, tokenCount) {
     if (existing.status === 'committed') {
-        if (existing.completion_summary === summary) {
+        if (existing.completion_summary === summary &&
+            (tokenCount === undefined || existing.token_count === tokenCount)) {
             return existing;
         }
+        if (tokenCount !== undefined && existing.token_count !== tokenCount) {
+            throw new Error(`Model run already committed with different token_count: ${existing.model_run_id}`);
+        }
         throw new Error(`Model run already committed with different completion_summary: ${existing.model_run_id}`);
     }
     if (existing.status === 'failed') {
@@ -341,11 +345,15 @@ function resolveExistingCommittedRun(existing, summary) {
     }
     throw new Error(`Cannot commit model run in ${existing.status} status: ${existing.model_run_id}`);
 }
-function resolveExistingFailedRun(existing, errorSummary) {
+function resolveExistingFailedRun(existing, errorSummary, tokenCount) {
     if (existing.status === 'failed') {
-        if (existing.error_summary === errorSummary) {
+        if (existing.error_summary === errorSummary &&
+            (tokenCount === undefined || existing.token_count === tokenCount)) {
             return existing;
         }
+        if (tokenCount !== undefined && existing.token_count !== tokenCount) {
+            throw new Error(`Model run already failed with different token_count: ${existing.model_run_id}`);
+        }
         throw new Error(`Model run already failed with different error_summary: ${existing.model_run_id}`);
     }
     if (existing.status === 'committed') {
@@ -353,7 +361,7 @@ function resolveExistingFailedRun(existing, errorSummary) {
     }
     throw new Error(`Cannot fail model run in ${existing.status} status: ${existing.model_run_id}`);
 }
-function beginModelRunInAdapter(adapter, input) {
+function beginModelRun(adapter, input) {
     const id = nullableString(input.model_run_id) ?? modelRunId();
     const createdAt = normalizeTimestamp(input.created_at);
     const status = normalizeBeginStatus(input.status, id);
@@ -391,11 +399,12 @@ function beginModelRunInAdapter(adapter, input) {
     }
     return requireModelRun(adapter, id);
 }
-function commitModelRunInAdapter(adapter, modelRunId, summary) {
+function commitModelRun(adapter, modelRunId, summary, tokenCount) {
     const summaryValue = nullableString(summary);
+    const measuredTokens = requireTokenCount(tokenCount);
     const existing = requireModelRun(adapter, modelRunId);
     if (existing.status !== 'running') {
-        return resolveExistingCommittedRun(existing, summaryValue);
+        return resolveExistingCommittedRun(existing, summaryValue, measuredTokens);
     }
     const completedAt = Date.now();
     const result = adapter
@@ -404,20 +413,22 @@ function commitModelRunInAdapter(adapter, modelRunId, summary) {
         SET status = 'committed',
             completion_summary = ?,
             error_summary = NULL,
+            token_count = ?,
             completed_at = ?
         WHERE model_run_id = ? AND status = 'running'
       `)
-        .run(summaryValue, completedAt, modelRunId);
+        .run(summaryValue, measuredTokens ?? existing.token_count, completedAt, modelRunId);
     if (result.changes === 0) {
-        return resolveExistingCommittedRun(requireModelRun(adapter, modelRunId), summaryValue);
+        return resolveExistingCommittedRun(requireModelRun(adapter, modelRunId), summaryValue, measuredTokens);
     }
     return requireModelRun(adapter, modelRunId);
 }
-function failModelRunInAdapter(adapter, modelRunId, errorSummary) {
+function failModelRun(adapter, modelRunId, errorSummary, tokenCount) {
     const errorSummaryValue = nullableString(errorSummary);
+    const measuredTokens = requireTokenCount(tokenCount);
     const existing = requireModelRun(adapter, modelRunId);
     if (existing.status !== 'running') {
-        return resolveExistingFailedRun(existing, errorSummaryValue);
+        return resolveExistingFailedRun(existing, errorSummaryValue, measuredTokens);
     }
     const completedAt = Date.now();
     const result = adapter
@@ -426,32 +437,61 @@ function failModelRunInAdapter(adapter, modelRunId, errorSummary) {
         SET status = 'failed',
             completion_summary = NULL,
             error_summary = ?,
+            token_count = ?,
             completed_at = ?
         WHERE model_run_id = ? AND status = 'running'
       `)
-        .run(errorSummaryValue, completedAt, modelRunId);
+        .run(errorSummaryValue, measuredTokens ?? existing.token_count, completedAt, modelRunId);
     if (result.changes === 0) {
-        return resolveExistingFailedRun(requireModelRun(adapter, modelRunId), errorSummaryValue);
+        return resolveExistingFailedRun(requireModelRun(adapter, modelRunId), errorSummaryValue, measuredTokens);
     }
     return requireModelRun(adapter, modelRunId);
 }
-function getModelRunInAdapter(adapter, modelRunId) {
+function getModelRun(adapter, modelRunId) {
     return selectModelRun(adapter, modelRunId);
 }
-async function beginModelRun(input) {
-    const adapter = await initializedAdapter();
-    return beginModelRunInAdapter(adapter, input);
-}
-async function commitModelRun(modelRunId, summary) {
-    const adapter = await initializedAdapter();
-    return commitModelRunInAdapter(adapter, modelRunId, summary);
-}
-async function failModelRun(modelRunId, errorSummary) {
-    const adapter = await initializedAdapter();
-    return failModelRunInAdapter(adapter, modelRunId, errorSummary);
-}
-async function getModelRun(modelRunId) {
-    const adapter = await initializedAdapter();
-    return getModelRunInAdapter(adapter, modelRunId);
+/** Read one run's native input cohort without copying payloads or inventing legacy principals. */
+function listModelRunNativeInputs(adapter, modelRunId, principalId, options = {}) {
+    requireString(principalId, 'principal_id');
+    const run = requireModelRun(adapter, modelRunId);
+    if (run.input_refs?.principalId !== principalId ||
+        !((typeof run.input_refs.nativeInputId === 'string' && run.input_refs.nativeInputId.trim()) ||
+            (typeof run.input_refs.sourceMessageRef === 'string' &&
+                run.input_refs.sourceMessageRef.trim()))) {
+        throw new Error('Model run has no matching principal-bound native input');
+    }
+    const afterId = options.afterId ?? 0;
+    const limit = options.limit ?? 25;
+    if (!Number.isSafeInteger(afterId) || afterId < 0) {
+        throw new Error('Model run native input cursor must be a non-negative integer');
+    }
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
+        throw new Error('Model run native input page limit must be 1 to 100');
+    }
+    const rows = adapter
+        .prepare(`SELECT input_id, stimulus_id, kind, principal_id, channel_key,
+              occurred_at, status, native_state
+       FROM model_run_native_inputs
+       WHERE model_run_id=? AND principal_id=? AND input_id>?
+       ORDER BY input_id LIMIT ?`)
+        .all(modelRunId, principalId, afterId, limit + 1);
+    if (afterId === 0 && rows.length === 0) {
+        throw new Error('Model run has no accepted native turn receipt');
+    }
+    const page = rows.slice(0, limit);
+    return {
+        runStatus: run.status,
+        items: page.map((row) => ({
+            inputId: row.input_id,
+            stimulusId: row.stimulus_id,
+            kind: row.kind,
+            principalId: row.principal_id,
+            channelKey: row.channel_key,
+            occurredAt: row.occurred_at,
+            status: row.status,
+            nativeState: row.native_state,
+        })),
+        nextCursor: rows.length > limit ? page[page.length - 1].input_id : null,
+    };
 }
-//# sourceMappingURL=store.js.map
+//# sourceMappingURL=model-run-store.js.map

package/dist/runtime/model-run-types.d.ts

@@ -0,0 +1,132 @@
+export declare const MODEL_RUN_STATUSES: readonly ["running", "committed", "failed", "legacy"];
+export type ModelRunStatus = (typeof MODEL_RUN_STATUSES)[number];
+export interface BeginModelRunInput {
+    model_run_id?: string;
+    model_id?: string | null;
+    model_provider?: string | null;
+    prompt_version?: string | null;
+    tool_manifest_version?: string | null;
+    output_schema_version?: string | null;
+    agent_id?: string | null;
+    instance_id?: string | null;
+    envelope_hash?: string | null;
+    parent_model_run_id?: string | null;
+    input_snapshot_ref?: string | null;
+    input_refs?: Record<string, unknown> | null;
+    input_refs_json?: string | null;
+    status?: ModelRunStatus;
+    error_summary?: string | null;
+    token_count?: number | null;
+    cost_estimate?: number | null;
+    created_at?: number;
+}
+export interface ModelRunRecord {
+    model_run_id: string;
+    model_id: string | null;
+    model_provider: string | null;
+    prompt_version: string | null;
+    tool_manifest_version: string | null;
+    output_schema_version: string | null;
+    agent_id: string | null;
+    instance_id: string | null;
+    envelope_hash: string | null;
+    parent_model_run_id: string | null;
+    input_snapshot_ref: string | null;
+    input_refs_json: string | null;
+    input_refs: Record<string, unknown> | null;
+    completion_summary: string | null;
+    status: ModelRunStatus;
+    error_summary: string | null;
+    token_count: number;
+    cost_estimate: number | null;
+    created_at: number;
+    completed_at: number | null;
+}
+/** Fields shared by model-backed and service-operation trace appends. */
+interface AppendToolTraceCommon {
+    /** Host-derived access scope; legacy rows remain unscoped. */
+    owner_scope?: string | null;
+    project_id?: string | null;
+    channel_id?: string | null;
+    diagnostic_json?: string | null;
+    evidence_json?: string | null;
+    catalog_revision?: string | null;
+    trace_id?: string;
+    gateway_call_id?: string | null;
+    tool_name: string;
+    input_summary?: string | null;
+    output_summary?: string | null;
+    execution_status?: string | null;
+    duration_ms?: number | null;
+    envelope_hash?: string | null;
+    /** Thrower's closed cause (e.g. envelope_missing). Carried, never invented. */
+    failure_code?: string | null;
+    created_at?: number;
+}
+/**
+ * Model-backed append. `model_run_id` names the authorizing model run and stays
+ * required: the existing gateway/tracing callers are unchanged.
+ */
+export interface AppendToolTraceInput extends AppendToolTraceCommon {
+    model_run_id: string;
+}
+/**
+ * Service/CLI operation append. A truthful host operation traces itself without
+ * inventing a model run: the row is anchored by a nonempty `operation_id` and
+ * `actor_principal_id`, which stay required.
+ *
+ * `model_run_id` is OPTIONAL causal provenance: when a real completed model run
+ * caused this operation observation, its id may be carried so the association is
+ * queryable (the `model_runs` FK validates that the reference is real). It is
+ * never fabricated, never invented, and never serves as execution authorization
+ * - an operation without a causing run simply omits it and the column stays NULL.
+ */
+export interface AppendOperationToolTraceInput extends AppendToolTraceCommon {
+    operation_id: string;
+    actor_principal_id: string;
+    /** Optional real causal model run. Stored when supplied; absent stays NULL. */
+    model_run_id?: string | null;
+}
+export interface ToolTraceRecord {
+    /** Host-derived access scope; legacy rows remain unscoped. */
+    owner_scope?: string | null;
+    project_id?: string | null;
+    channel_id?: string | null;
+    diagnostic_json?: string | null;
+    evidence_json?: string | null;
+    catalog_revision?: string | null;
+    trace_id: string;
+    /** NULL only for a service/operation-origin trace; legacy rows keep their model id. */
+    model_run_id: string | null;
+    /** Set (with actor_principal_id) exactly when this is an operation-origin trace. */
+    operation_id: string | null;
+    actor_principal_id: string | null;
+    gateway_call_id: string | null;
+    tool_name: string;
+    input_summary: string | null;
+    output_summary: string | null;
+    execution_status: string | null;
+    duration_ms: number;
+    envelope_hash: string | null;
+    failure_code: string | null;
+    created_at: number;
+}
+export interface ToolTraceScope {
+    owner_scope: string;
+    project_id: string;
+    channel_id?: string;
+}
+export interface ListToolTracesInput extends ToolTraceScope {
+    evidence_only?: boolean;
+    model_run_id?: string;
+    tool_name?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface ToolTracePage {
+    /** Metadata only: evidence_json is null. Read a scoped trace for details. */
+    traces: ToolTraceRecord[];
+    next_cursor: string | null;
+}
+export {};
+//# sourceMappingURL=model-run-types.d.ts.map

package/dist/{model-runs/types.js → runtime/model-run-types.js}

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MODEL_RUN_STATUSES = void 0;
 exports.MODEL_RUN_STATUSES = ['running', 'committed', 'failed', 'legacy'];
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=model-run-types.js.map

package/dist/runtime/native-effect-observer.d.ts

@@ -0,0 +1,22 @@
+/** Notifications are observations, not backend pre-execution authorization hooks. */
+export interface NativeEffectObserver {
+    started(name: string, input: Record<string, unknown>): void;
+    settled(name: string, toolUseId: string, isError: boolean, outcome?: 'unknown'): void;
+    interrupted(): void;
+    /** Settle the durable admission marker only after a clean run return. */
+    finished?(): void;
+}
+export declare function isDelegationToolName(name: string): boolean;
+export declare function isNativeToolName(name: string): boolean;
+/** TG-03/04/05/06: a completed shell invocation is still unsafe to replay. */
+export declare class NativeEffectReplayBoundary {
+    private readonly observer?;
+    private observed;
+    constructor(observer?: NativeEffectObserver | undefined);
+    private observe;
+    started(name: string, input: Record<string, unknown>): void;
+    settled(name: string, toolUseId: string, isError: boolean, outcome?: 'unknown'): void;
+    finished(): void;
+    failure(error: unknown, allowPreExecutionRecovery?: boolean): unknown;
+}
+//# sourceMappingURL=native-effect-observer.d.ts.map

package/dist/runtime/native-effect-observer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEffectReplayBoundary = void 0;
+exports.isDelegationToolName = isDelegationToolName;
+exports.isNativeToolName = isNativeToolName;
+const types_js_1 = require("./drivers/types.js");
+const NATIVE_EFFECT_NAMES = new Set([
+    'bash',
+    'write',
+    'edit',
+    'multiedit',
+    'apply_patch',
+    'exec_command',
+    'shell',
+    'shell_command',
+    'commandexecution',
+    'filechange',
+    'execute_command',
+    'write_to_file',
+    'replace_in_file',
+]);
+/**
+ * Delegation is an admission, not an effect. Spawning a native subagent (Claude `Agent`/
+ * `Task`, Codex `spawn_agent`/`send_input`/`resume_agent`) names nothing the replay gate
+ * can re-execute: every effect the child performs carries its own ledger row through the
+ * gateway. Measured 2026-09-10: a Claude `Agent` tool_use recorded as `native_tool`
+ * under the reused `workorder:board:full:repair` occurrence blocked every later board
+ * order ("owner effect requires reconciliation before replay", orders #4805-#4807).
+ * Codex spawns already bypass this boundary via `onSubagentStart`; the Claude spawn
+ * arrives as an ordinary tool_use, so the name set must not claim it.
+ */
+const DELEGATION_NAMES = new Set([
+    'agent',
+    'task',
+    'spawn_agent',
+    'collabagenttoolcall',
+    'send_input',
+    'resume_agent',
+]);
+function isDelegationToolName(name) {
+    return DELEGATION_NAMES.has(name.toLowerCase());
+}
+const NATIVE_READ_NAMES = new Set(['read', 'glob', 'grep', 'webfetch', 'websearch', 'web_search']);
+function isNativeToolName(name) {
+    return (NATIVE_EFFECT_NAMES.has(name.toLowerCase()) ||
+        NATIVE_READ_NAMES.has(name.toLowerCase()) ||
+        isDelegationToolName(name));
+}
+/** TG-03/04/05/06: a completed shell invocation is still unsafe to replay. */
+class NativeEffectReplayBoundary {
+    observer;
+    observed = false;
+    constructor(observer) {
+        this.observer = observer;
+    }
+    observe(callback) {
+        try {
+            callback();
+        }
+        catch {
+            // A trace sink is not an authorization hook; omit exception text (may contain input).
+            console.warn('[NativeEffectObserver] observation failed');
+        }
+    }
+    started(name, input) {
+        if (!isNativeToolName(name))
+            return;
+        if (NATIVE_EFFECT_NAMES.has(name.toLowerCase()))
+            this.observed = true;
+        this.observe(() => this.observer?.started(name, input));
+    }
+    settled(name, toolUseId, isError, outcome) {
+        if (!isNativeToolName(name))
+            return;
+        if (NATIVE_EFFECT_NAMES.has(name.toLowerCase()))
+            this.observed = true;
+        this.observe(() => this.observer?.settled(name, toolUseId, isError, outcome));
+    }
+    finished() {
+        this.observe(() => this.observer?.finished?.());
+    }
+    failure(error, allowPreExecutionRecovery = false) {
+        // Only AgentLoop's trusted recoverable-session predicate may permit a reset.
+        // Once a native effect is observed, even a session error cannot allow replay.
+        if (allowPreExecutionRecovery && !this.observed) {
+            this.observe(() => this.observer?.interrupted());
+            return error;
+        }
+        if (!this.observed) {
+            this.observe(() => this.observer?.interrupted());
+            return error;
+        }
+        try {
+            this.observer?.interrupted();
+        }
+        catch {
+            // The durable started reservation remains unresolved if settlement fails.
+        }
+        return new types_js_1.AgentError('Native run effect outcome is uncertain; reconcile effects before replaying the occurrence.', 'MUTATION_OUTCOME_UNKNOWN', error instanceof Error ? error : new Error(String(error)), false);
+    }
+}
+exports.NativeEffectReplayBoundary = NativeEffectReplayBoundary;
+//# sourceMappingURL=native-effect-observer.js.map

package/dist/runtime/native-input-journal.d.ts

@@ -0,0 +1,46 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { NativeInputDispatch, NativeInputReceipt } from './drivers/types.js';
+import type { NativeTurnResult } from './native-turn.js';
+import type { StimulusKind } from './mailbox.js';
+type NativeTurnResultPayload = Pick<NativeTurnResult, 'response' | 'turns' | 'totalUsage' | 'stopReason' | 'modelRunId' | 'modelRunProvenance' | 'stoppedBy'> & {
+    ownerJournalProvenance?: 'commit_failed';
+};
+export type NativeTurnResultRecord = NativeTurnResultPayload & {
+    primaryStimulusId: string;
+    /** Null only for historical results whose primary mailbox row was already pruned. */
+    primaryKind: StimulusKind | null;
+};
+export interface NativeDeliveryRecord {
+    invocationId: string | null;
+    state: 'prepared' | 'dispatching' | 'accepted' | 'settled' | 'uncertain';
+    dispatch: NativeInputDispatch | null;
+    receipt: NativeInputReceipt | null;
+    error: string | null;
+}
+/** One durable dispatch identity per accepted input. No task meaning or effect classification. */
+export declare class NativeInputJournal {
+    private readonly db;
+    private readonly now;
+    constructor(db: DatabaseAdapter, now?: () => number);
+    get(inputId: number): NativeDeliveryRecord | null;
+    /** Page the inputs that share one exact native receipt under one principal. */
+    listByReceipt(receipt: NativeInputReceipt, principalId: string, options?: {
+        afterId?: number;
+        limit?: number;
+    }): {
+        inputIds: number[];
+        nextCursor: number | null;
+    };
+    /** One immutable final result per native turn, written before any consumer reply. */
+    storeResult(inputId: number, result: NativeTurnResult): void;
+    /** A later accepted input can recover the one final result under its principal. */
+    resultForReceipt(receipt: NativeInputReceipt, principalId: string): NativeTurnResultRecord | null;
+    prepare(inputId: number): NativeDeliveryRecord;
+    dispatch(inputId: number, value: NativeInputDispatch): void;
+    accept(inputId: number, value: NativeInputReceipt): void;
+    settle(inputId: number, reconciled?: boolean): void;
+    uncertain(inputId: number, error: string): void;
+    pending(limit: number, afterId?: number): number[];
+}
+export {};
+//# sourceMappingURL=native-input-journal.d.ts.map