@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/runtime/approval.d.ts

@@ -0,0 +1,23 @@
+/** HITL approval (spec: 2026-08-26-plugin-trust-model-design.md): one handler
+ *  type, three resolution pipelines (tui overlay / print+json fail-closed /
+ *  rpc wire with deadline). */
+export interface ApprovalRequest {
+    readonly callId: string;
+    readonly toolName: string;
+    readonly input: unknown;
+    /** Who asked: "permission" (ask-mode gate) or "tool" (options.request). */
+    readonly source: "permission" | "tool";
+    readonly reason?: string;
+}
+export interface ApprovalDecision {
+    readonly decision: "allow" | "deny";
+    readonly reason?: string;
+}
+export type ApprovalHandler = (req: ApprovalRequest) => Promise<ApprovalDecision>;
+export declare const DEFAULT_APPROVAL_TIMEOUT_MS = 120000;
+export declare function approvalTimeoutMs(): number;
+/** Resolve with a deadline; a silent human fails closed (deny). 0 = wait. */
+export declare function withApprovalDeadline(p: Promise<ApprovalDecision>, timeoutMs: number): Promise<ApprovalDecision>;
+/** The fail-closed handler for headless one-shot modes (print/json). */
+export declare function denyAllApprovals(req: ApprovalRequest): Promise<ApprovalDecision>;
+//# sourceMappingURL=approval.d.ts.map

package/dist/core/runtime/approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/approval.ts"],"names":[],"mappings":"AAAA;;+BAE+B;AAE/B,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAElF,eAAO,MAAM,2BAA2B,SAAU,CAAC;AAEnD,wBAAgB,iBAAiB,IAAI,MAAM,CAI1C;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAC5B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,gBAAgB,CAAC,CAW3B;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAKhF"}

package/dist/core/runtime/approval.js

@@ -0,0 +1,25 @@
+/** HITL approval (spec: 2026-08-26-plugin-trust-model-design.md): one handler
+ *  type, three resolution pipelines (tui overlay / print+json fail-closed /
+ *  rpc wire with deadline). */
+export const DEFAULT_APPROVAL_TIMEOUT_MS = 120_000;
+export function approvalTimeoutMs() {
+    const raw = process.env.OMA_APPROVAL_TIMEOUT_MS;
+    const n = raw === undefined ? DEFAULT_APPROVAL_TIMEOUT_MS : Number(raw);
+    return Number.isFinite(n) && n >= 0 ? n : DEFAULT_APPROVAL_TIMEOUT_MS;
+}
+/** Resolve with a deadline; a silent human fails closed (deny). 0 = wait. */
+export function withApprovalDeadline(p, timeoutMs) {
+    if (timeoutMs === 0)
+        return p;
+    return Promise.race([
+        p,
+        new Promise((resolve) => setTimeout(() => resolve({ decision: "deny", reason: "approval deadline exceeded" }), timeoutMs)),
+    ]);
+}
+/** The fail-closed handler for headless one-shot modes (print/json). */
+export function denyAllApprovals(req) {
+    return Promise.resolve({
+        decision: "deny",
+        reason: `${req.toolName}: approval requested in non-interactive mode (fail-closed)`,
+    });
+}

package/dist/core/runtime/compaction.d.ts

@@ -0,0 +1,22 @@
+import type { Message } from "@chengchenccc/message";
+import type { SessionStore } from "../persistence/session-store.js";
+export interface CompactionResult {
+    readonly entryId: string;
+    readonly coveredIds: readonly string[];
+}
+/** Token budget used for compaction cut points. `estimate` is a per-message
+ *  token cost; `limit` is the target ceiling for the retained context. */
+export interface CompactionBudget {
+    estimate(message: Message): number;
+    limit: number;
+}
+/** Compact a session branch: summarize oldest entries, append CompactionEntry,
+ *  leave tail entries intact. Shared by threshold/manual/overflow triggers.
+ *
+ *  The summarizer receives full Message objects (including tool_use/tool_result
+ *  blocks) so tool semantics survive compaction. The AbortSignal lets stop()
+ *  cancel an in-flight summarizer; an aborted compaction writes nothing.
+ *  No-op when the context is already under budget (no summarizer call, no
+ *  CompactionEntry), and never writes an entry with empty coversEntryIds. */
+export declare function compactSession(store: SessionStore, sessionId: string, summarizer: (messages: readonly Message[], signal?: AbortSignal) => Promise<string>, signal?: AbortSignal, budget?: CompactionBudget): Promise<CompactionResult>;
+//# sourceMappingURL=compaction.d.ts.map

package/dist/core/runtime/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/compaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;0EAC0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf;AA6DD;;;;;;;6EAO6E;AAC7E,wBAAsB,cAAc,CAClC,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,EACnF,MAAM,CAAC,EAAE,WAAW,EACpB,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CAAC,gBAAgB,CAAC,CAsC3B"}

package/dist/core/runtime/compaction.js

@@ -0,0 +1,90 @@
+/** If the cut lands between an assistant tool_use and its tool_result,
+ *  move the cut before the assistant so the pair stays intact. */
+function adjustCutForToolPairs(messages, cutIdx) {
+    let cut = cutIdx;
+    while (cut < messages.length && messages[cut]?.type === "message") {
+        const first = messages[cut];
+        if (first.role !== "tool")
+            break;
+        const toolUseId = first.message?.blocks?.find((b) => b.type === "tool_result")?.tool_use_id;
+        if (!toolUseId)
+            break;
+        let assocIdx = -1;
+        for (let i = 0; i < cut; i++) {
+            const m = messages[i];
+            if (m.role === "assistant" &&
+                m.message?.blocks?.some((b) => b.type === "tool_use" && b.id === toolUseId)) {
+                assocIdx = i;
+            }
+        }
+        if (assocIdx === -1)
+            break;
+        cut = assocIdx;
+        break;
+    }
+    return cut;
+}
+/** Compute the compaction cut point. Always returns a value: without a budget
+ *  it uses a message-count heuristic; with a budget it accumulates tokens from
+ *  the oldest messages until the retained tail fits under the limit. When the
+ *  context is already under the limit, cutIdx is 0 (no compaction needed). */
+function findCut(messages, budget) {
+    if (!budget) {
+        return { cutIdx: Math.floor(messages.length * 0.6) };
+    }
+    const tokens = messages.map((m) => budget.estimate(m.message));
+    const tokensBefore = tokens.reduce((sum, t) => sum + t, 0);
+    if (tokensBefore <= budget.limit) {
+        return { cutIdx: 0, tokensBefore };
+    }
+    let remaining = tokensBefore;
+    let cutIdx = 0;
+    while (cutIdx < messages.length && remaining > budget.limit) {
+        remaining -= tokens[cutIdx];
+        cutIdx++;
+    }
+    return { cutIdx, tokensBefore };
+}
+/** Compact a session branch: summarize oldest entries, append CompactionEntry,
+ *  leave tail entries intact. Shared by threshold/manual/overflow triggers.
+ *
+ *  The summarizer receives full Message objects (including tool_use/tool_result
+ *  blocks) so tool semantics survive compaction. The AbortSignal lets stop()
+ *  cancel an in-flight summarizer; an aborted compaction writes nothing.
+ *  No-op when the context is already under budget (no summarizer call, no
+ *  CompactionEntry), and never writes an entry with empty coversEntryIds. */
+export async function compactSession(store, sessionId, summarizer, signal, budget) {
+    const branch = await store.readBranch(sessionId);
+    const messages = branch.filter((e) => e.type === "message");
+    if (messages.length < 4)
+        return { entryId: "", coveredIds: [] };
+    const { cutIdx: rawCutIdx, tokensBefore } = findCut(messages, budget);
+    let cutIdx = rawCutIdx;
+    cutIdx = adjustCutForToolPairs(messages, cutIdx);
+    // No compaction needed: nothing to cover (under budget or cut collapsed).
+    if (cutIdx <= 0)
+        return { entryId: "", coveredIds: [] };
+    const coveredEntries = messages.slice(0, cutIdx);
+    const coveredIds = coveredEntries.map((m) => m.entryId);
+    const retainedIds = messages.slice(cutIdx).map((m) => m.entryId);
+    const coveredMessages = coveredEntries.map((m) => m.message);
+    const summary = await summarizer(coveredMessages, signal);
+    // If aborted during summarization, do not write a CompactionEntry.
+    if (signal?.aborted)
+        return { entryId: "", coveredIds: [] };
+    const result = await store.appendBatch(sessionId, {
+        entries: [
+            {
+                type: "compaction",
+                summary,
+                coversEntryIds: coveredIds,
+                ...(budget ? { tokensBefore, retainedEntryIds: retainedIds } : {}),
+                createdAt: Date.now(),
+            },
+        ],
+    });
+    return {
+        entryId: result.appendedIds[0] ?? "",
+        coveredIds: coveredIds,
+    };
+}

package/dist/core/runtime/context-estimate.d.ts

@@ -0,0 +1,42 @@
+/** Context-token estimation helpers absorbed from oh-my-pi
+ * (packages/agent/src/harness/compaction/compaction.ts):
+ * usage-anchored estimation + silent-overflow detection. */
+/** Per-turn usage quartet (concrete, unlike the all-optional run Usage). */
+export interface TurnUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+}
+/** A real-usage anchor: `tokens` is a completed model call's own total
+ * (input + output + cache legs) and is authoritative for every entry
+ * persisted before `afterEntryId`; only entries AFTER it fall back to
+ * per-message estimation (chars/4). Falls back wholesale when the anchor
+ * entry no longer exists (post-compaction branch, resumed runs).
+ *
+ * ponytail: the anchor is in-memory per Run — pi persists usage on
+ * assistant messages and re-anchors after resume. Persist it onto the
+ * session file if follow-up Runs ever drift badly. */
+export interface UsageAnchor {
+    readonly afterEntryId: string | null;
+    readonly tokens: number;
+}
+export declare function usageTotalTokens(usage: TurnUsage): number;
+/** Context size estimate anchored on the last real usage: anchor tokens +
+ * per-entry estimates for entries persisted after the anchor boundary.
+ * Without an anchor (or when the boundary entry is gone) every entry is
+ * estimated — the pre-anchor behavior. */
+export declare function estimateContextTokens<T extends {
+    entryId: string;
+}>(entries: readonly T[], anchor: UsageAnchor | null, estimateEntry: (entry: T) => number): number;
+/** Silent context overflow (oh-my-pi isContextOverflow): some providers
+ * accept an oversized request instead of erroring.
+ * - zai-style: the input side exceeds the model window — never legitimate.
+ * - Xiaomi-style: input truncated to exactly fill the window, leaving zero
+ *   room to generate (length-stop with zero output). */
+export declare function isSilentContextOverflow(usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+} | undefined, stopReason: string | undefined, contextLimit: number): boolean;
+//# sourceMappingURL=context-estimate.d.ts.map

package/dist/core/runtime/context-estimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-estimate.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/context-estimate.ts"],"names":[],"mappings":"AAAA;;4DAE4D;AAE5D,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;sDAQsD;AACtD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAEzD;AAED;;;0CAG0C;AAC1C,wBAAgB,qBAAqB,CAAC,CAAC,SAAS;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EACjE,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,MAAM,EAAE,WAAW,GAAG,IAAI,EAC1B,aAAa,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,GAClC,MAAM,CAOR;AAED;;;;wDAIwD;AACxD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EAC5F,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,YAAY,EAAE,MAAM,GACnB,OAAO,CAQT"}

package/dist/core/runtime/context-estimate.js

@@ -0,0 +1,34 @@
+/** Context-token estimation helpers absorbed from oh-my-pi
+ * (packages/agent/src/harness/compaction/compaction.ts):
+ * usage-anchored estimation + silent-overflow detection. */
+export function usageTotalTokens(usage) {
+    return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+}
+/** Context size estimate anchored on the last real usage: anchor tokens +
+ * per-entry estimates for entries persisted after the anchor boundary.
+ * Without an anchor (or when the boundary entry is gone) every entry is
+ * estimated — the pre-anchor behavior. */
+export function estimateContextTokens(entries, anchor, estimateEntry) {
+    const fallback = () => entries.reduce((sum, e) => sum + estimateEntry(e), 0);
+    if (!anchor)
+        return fallback();
+    const idx = anchor.afterEntryId === null ? -1 : entries.findIndex((e) => e.entryId === anchor.afterEntryId);
+    if (anchor.afterEntryId !== null && idx === -1)
+        return fallback();
+    return anchor.tokens + entries.slice(idx + 1).reduce((sum, e) => sum + estimateEntry(e), 0);
+}
+/** Silent context overflow (oh-my-pi isContextOverflow): some providers
+ * accept an oversized request instead of erroring.
+ * - zai-style: the input side exceeds the model window — never legitimate.
+ * - Xiaomi-style: input truncated to exactly fill the window, leaving zero
+ *   room to generate (length-stop with zero output). */
+export function isSilentContextOverflow(usage, stopReason, contextLimit) {
+    if (!usage || contextLimit <= 0)
+        return false;
+    const input = (usage.inputTokens ?? 0) + (usage.cacheReadTokens ?? 0);
+    if (input <= 0)
+        return false;
+    if (input > contextLimit)
+        return true;
+    return (stopReason === "max_tokens" && (usage.outputTokens ?? 0) === 0 && input >= contextLimit * 0.99);
+}

package/dist/core/runtime/create-runtime.d.ts

@@ -0,0 +1,81 @@
+import type { BackendInputMessage, BackendRunInput, BackendRunSegment, ProjectedHistoryItem } from "@chengchenccc/agent-contract";
+import type { ModelRuntime } from "@chengchenccc/ai";
+import type { Message } from "@chengchenccc/message";
+import type { RunEventEnvelope } from "../../protocol/index.js";
+import { type MemoryLearnResult } from "../memory/autonomous-memory.js";
+import type { PluginMcpConfig } from "../plugins/plugin-resolve.js";
+import type { ApprovalHandler } from "./approval.js";
+import type { Plugin } from "./plugin.js";
+import type { ToolFilter } from "./tool-filter.js";
+/** The single Runtime assembly entry point for the Oma product.
+ *  Every mode (print / json / rpc / future TUI) builds the SAME runtime from
+ *  these options: fresh in-memory SessionStore per Runtime, no state shared
+ *  across Runtimes except the process-level Provider/ModelRuntime. */
+export interface CreateOmaRuntimeOptions {
+    runId: string;
+    /** Canonical `<provider>/<model>` id of the Run's model: the context
+     *  budget and summarizer bind to it. */
+    modelId: string;
+    workspaceRoot: string;
+    workspaceAccess: "read_only" | "read_write";
+    modelRuntime: ModelRuntime;
+    skillRoots: readonly string[];
+    /** The resumed CLI session transcript (ADR 0003 decision 6), validated
+     *  messages from the session file. Seeds the loop's store in place of the
+     *  retired wire `history` projection. Absent = fresh session. */
+    sessionTranscript?: readonly ProjectedHistoryItem[];
+    /** Called for every runtime event as a wire envelope (id/type/data), after
+     *  the in-process segment stream. Used by RPC mode to forward events to
+     *  stdout; print/json modes leave it unset. */
+    onEvent?: (envelope: RunEventEnvelope) => void;
+    /** Real-time session-file persistence: fired after every conversational
+     *  persist (pi appendMessage). When set, the caller owns writing these
+     *  messages to its session file as they happen. */
+    onPersistMessages?: (messages: readonly Message[]) => void;
+    /** --tools filter (CLI): applied to the final tool table. */
+    toolFilter?: ToolFilter;
+    /** Assembled plugin code components (from assemblePluginRuntime, mode
+     *  layer). The runtime mounts them; it never reads the registry. */
+    pluginComponents?: {
+        plugins: readonly Plugin[];
+        mcpServers?: readonly PluginMcpConfig[];
+    };
+    /** Frozen Run permissionMode; "deny" drops plugin code components. */
+    permissionMode?: "ask" | "auto" | "deny";
+    /** Standalone modes: gate the repo-controlled workspace .mcp.json behind
+     *  the trust record (spec follow-up #3). */
+    gateWorkspaceMcp?: boolean;
+    /** HITL approval pipeline; absent + ask = fail-closed. */
+    approvalHandler?: ApprovalHandler;
+}
+/** One Runtime = one Run. The loop runs directly in-process; steer injects
+ *  into the live loop; stop aborts it; close tears down MCP clients and the
+ *  SessionStore. */
+export interface OmaRuntime {
+    /** Start the Run's loop. Returns the segment whose outcome is the Run's
+     *  ONLY terminal result. A Runtime accepts exactly one run(). */
+    run(input: BackendRunInput<"oma">): Promise<BackendRunSegment<"oma">>;
+    /** Inject a steer input into the live loop. Throws when no loop is live. */
+    steer(input: BackendInputMessage): Promise<void>;
+    /** Request cancellation of the live loop. The segment's outcome still
+     *  resolves (aborted). Safe to call before run() starts the loop. */
+    stop(): Promise<void>;
+    /** Close MCP clients and the in-memory Store. Call after the run settles. */
+    close(): Promise<void>;
+    /** Compaction summaries from this run's loop; read before close(). */
+    compactions(): Promise<string[]>;
+    /** Estimated context footprint of the run's branch under the run model's
+     *  window — the same estimate/limit pair the compactor decides on. Read
+     *  before close(). */
+    contextUsage(): Promise<{
+        estimatedTokens: number;
+        limit: number;
+    } | undefined>;
+    /** The run's background memory-learn pass (omp AutoLearn analog).
+     * Present once the run completed; never rejects; resolves after close()
+     * too (inputs are captured up front). Surfaces use it for the "learn"
+     * indicator. */
+    memoryLearning(): Promise<MemoryLearnResult> | undefined;
+}
+export declare function createOmaRuntime(options: CreateOmaRuntimeOptions): Promise<OmaRuntime>;
+//# sourceMappingURL=create-runtime.d.ts.map

package/dist/core/runtime/create-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/create-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EAEf,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;sEAGsE;AACtE,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd;4CACwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,WAAW,GAAG,YAAY,CAAC;IAC5C,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B;;qEAEiE;IACjE,iBAAiB,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACpD;;mDAE+C;IAC/C,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC/C;;uDAEmD;IACnD,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,KAAK,IAAI,CAAC;IAC3D,6DAA6D;IAC7D,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;wEACoE;IACpE,gBAAgB,CAAC,EAAE;QACjB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;QAC3B,UAAU,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;KACzC,CAAC;IACF,sEAAsE;IACtE,cAAc,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IACzC;gDAC4C;IAC5C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0DAA0D;IAC1D,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED;;oBAEoB;AACpB,MAAM,WAAW,UAAU;IACzB;qEACiE;IACjE,GAAG,CAAC,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;IACtE,4EAA4E;IAC5E,KAAK,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD;yEACqE;IACrE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,6EAA6E;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,sEAAsE;IACtE,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACjC;;0BAEsB;IACtB,YAAY,IAAI,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC,CAAC;IAChF;;;oBAGgB;IAChB,cAAc,IAAI,OAAO,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC;CAC1D;AAuDD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC,CAiN5F"}

package/dist/core/runtime/create-runtime.js

@@ -0,0 +1,250 @@
+import { mapRunEvent } from "../../protocol/index.js";
+import { extractAutonomousMemory } from "../memory/autonomous-memory.js";
+import { assembleRunRuntime } from "./run-runtime.js";
+/** Add workflow (subagent) usage into a run's terminal usage. Missing
+ *  fields default to 0; an all-zero workflow side leaves the base alone. */
+function mergeWorkflowUsage(base, wf) {
+    const zero = (v) => v ?? 0;
+    const total = zero(wf?.inputTokens) +
+        zero(wf?.outputTokens) +
+        zero(wf?.cacheReadTokens) +
+        zero(wf?.cacheWriteTokens);
+    if (total === 0)
+        return base;
+    return {
+        inputTokens: zero(base?.inputTokens) + zero(wf?.inputTokens),
+        outputTokens: zero(base?.outputTokens) + zero(wf?.outputTokens),
+        cacheReadTokens: zero(base?.cacheReadTokens) + zero(wf?.cacheReadTokens),
+        cacheWriteTokens: zero(base?.cacheWriteTokens) + zero(wf?.cacheWriteTokens),
+    };
+}
+/** Attach the persisted message trail when present. A failed/aborted run
+ *  still surfaces what it did so the caller can persist it for the next
+ *  turn ("continue" resumes the context). */
+function withMessages(outcome, messages) {
+    return messages && messages.length > 0 ? { ...outcome, messages } : outcome;
+}
+function mapLoopResult(result) {
+    if (result.status === "completed") {
+        // No fabricated output: when the loop persisted no canonical messages,
+        // omit them rather than inventing an empty sequence.
+        return withMessages({
+            status: "completed",
+            ...(result.usage ? { usage: result.usage } : {}),
+            ...(result.title ? { title: result.title } : {}),
+        }, result.messages);
+    }
+    if (result.status === "stopped") {
+        return withMessages({ status: "aborted", error: result.error ?? "stopped by user" }, result.messages);
+    }
+    return withMessages({ status: "failed", error: result.error ?? "loop failed" }, result.messages);
+}
+export async function createOmaRuntime(options) {
+    const rt = await assembleRunRuntime({
+        workspaceRoot: options.workspaceRoot,
+        workspaceAccess: options.workspaceAccess,
+        runId: options.runId,
+        modelRuntime: options.modelRuntime,
+        modelId: options.modelId,
+        skillRoots: options.skillRoots,
+        ...(options.onPersistMessages ? { onPersistMessages: options.onPersistMessages } : {}),
+        ...(options.pluginComponents?.plugins.length
+            ? { codePlugins: options.pluginComponents.plugins }
+            : {}),
+        ...(options.gateWorkspaceMcp ? { gateWorkspaceMcp: true } : {}),
+        ...(options.approvalHandler ? { approvalHandler: options.approvalHandler } : {}),
+        ...(options.pluginComponents?.mcpServers?.length
+            ? { pluginMcpServers: options.pluginComponents.mcpServers }
+            : {}),
+        ...(options.permissionMode ? { permissionMode: options.permissionMode } : {}),
+        ...(options.toolFilter ? { toolFilter: options.toolFilter } : {}),
+    });
+    let stopRequested = false;
+    let started = false;
+    let memoryLearning;
+    return {
+        async run(input) {
+            if (started) {
+                throw new Error(`runtime ${options.runId} already ran once (one Runtime = one Run)`);
+            }
+            started = true;
+            // run() resolves only when the loop is at a SAFE steer boundary
+            // (message_start fires after acceptingSteer=true) or settled without
+            // starting - acceptance therefore implies steer/abort are routable,
+            // with no timing window.
+            let liveResolve = null;
+            const live = new Promise((resolve) => {
+                liveResolve = resolve;
+            });
+            let liveSettled = false;
+            const settleLive = () => {
+                if (liveSettled)
+                    return;
+                liveSettled = true;
+                liveResolve?.();
+            };
+            // Stop landing before the loop starts settles aborted without running.
+            if (stopRequested) {
+                settleLive();
+                const outcome = { status: "aborted", error: "stopped before start" };
+                return {
+                    events: (async function* () { })(),
+                    outcome: Promise.resolve(outcome),
+                    stop: async () => { },
+                };
+            }
+            // Push-based event fan-out: onEvent envelopes feed both the RPC stdout
+            // writer and the in-process segment stream.
+            const queue = [];
+            const waiters = [];
+            let closed = false;
+            let seq = 0;
+            const unsubscribe = rt.session.onEvent((event) => {
+                if (event.type === "message_start" || event.type === "agent_end")
+                    settleLive();
+                const envelope = { id: seq++, type: event.type, data: event };
+                queue.push(envelope);
+                options.onEvent?.(envelope);
+                for (const w of waiters.splice(0))
+                    w();
+            });
+            // The Run's store is seeded with the full Product history + the current
+            // input by the loop itself (buildLoopInput appends history + meta +
+            // input atomically). Create the session root first.
+            await rt.store.create({
+                sessionId: options.runId,
+                backendKind: "oma",
+                workspaceRoot: options.workspaceRoot,
+                leafEntryId: null,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            rt.setActiveRun(input.run);
+            const outcomePromise = (async () => {
+                try {
+                    // Workflow mode: the input IS a script to execute (Loop items).
+                    // No interactive loop, no messages — the script's return value is
+                    // the run's product (outcome.workflow.value).
+                    if (input.workflow) {
+                        const result = await rt.executeWorkflow(input.workflow);
+                        // Top-level usage so product accounting (usage totals, Loop
+                        // budget) sees the subagent spend; workflow.usage mirrors it.
+                        const usage = { inputTokens: 0, outputTokens: result.totalTokens };
+                        return {
+                            status: "completed",
+                            usage,
+                            workflow: { ok: result.ok, value: result.value, usage },
+                        };
+                    }
+                    const result = await rt.session.startLoop({
+                        history: options.sessionTranscript ?? [],
+                        input: input.input,
+                        run: input.run,
+                        workspace: input.workspace,
+                        metadata: input.metadata,
+                    });
+                    if (result.status === "completed") {
+                        // Autonomous memory: extract durable facts from this Run's
+                        // transcript + compaction summaries, persist to the workspace.
+                        // Best-effort — never affects the outcome.
+                        const branch = await rt.store.readBranch(options.runId);
+                        const compactions = [];
+                        for (const entry of branch) {
+                            if (entry.type === "compaction" && entry.summary)
+                                compactions.push(entry.summary);
+                        }
+                        // FIRE-AND-FORGET: awaiting here blocks the outcome (and the
+                        // TUI busy state) on a second model call the user cannot abort.
+                        memoryLearning = extractAutonomousMemory({
+                            modelRuntime: options.modelRuntime,
+                            modelId: options.modelId,
+                            workspaceRoot: options.workspaceRoot,
+                            runId: options.runId,
+                            messages: result.messages ?? [],
+                            compactions,
+                        });
+                    }
+                    const outcome = mapLoopResult(result);
+                    if (outcome.status === "completed") {
+                        // Fan-out spend (run_workflow / workflow_run subagents) merges
+                        // into the run's terminal usage (B6).
+                        return { ...outcome, usage: mergeWorkflowUsage(outcome.usage, rt.workflowUsage()) };
+                    }
+                    return outcome;
+                }
+                catch (caught) {
+                    const errObj = caught instanceof Error ? caught : new Error(String(caught));
+                    return { status: "failed", error: errObj.message };
+                }
+                finally {
+                    settleLive(); // loop settled without starting: live is still resolved
+                    unsubscribe();
+                    closed = true;
+                    for (const w of waiters.splice(0))
+                        w();
+                }
+            })();
+            const segment = {
+                events: (async function* () {
+                    while (!closed || queue.length > 0) {
+                        if (queue.length > 0) {
+                            yield mapRunEvent(queue.shift());
+                            continue;
+                        }
+                        if (closed)
+                            return;
+                        await new Promise((resolve) => waiters.push(resolve));
+                    }
+                })(),
+                outcome: outcomePromise,
+                stop: async () => {
+                    rt.session.stop();
+                },
+            };
+            // Acceptance = live: run() resolves once steer/abort are routable.
+            await live;
+            return segment;
+        },
+        async steer(input) {
+            rt.session.steer(input);
+        },
+        async stop() {
+            stopRequested = true;
+            rt.session.stop();
+        },
+        async close() {
+            await rt.close();
+        },
+        /** Compaction summaries produced by this run's loop (empty when the
+         *  run never compacted). Read the store BEFORE close(). */
+        async compactions() {
+            const branch = await rt.store.readBranch(options.runId);
+            const summaries = [];
+            for (const entry of branch) {
+                if (entry.type === "compaction" && entry.summary)
+                    summaries.push(entry.summary);
+            }
+            return summaries;
+        },
+        /** Estimated context footprint under the run model's window (the same
+         *  estimate/limit the compactor uses). Read before close(). */
+        async contextUsage() {
+            const budget = rt.contextBudget;
+            if (!budget)
+                return undefined;
+            const branch = await rt.store.readBranch(options.runId);
+            let estimatedTokens = 0;
+            for (const entry of branch) {
+                if (entry.type !== "message")
+                    continue;
+                estimatedTokens += budget.estimate(entry.message);
+            }
+            return { estimatedTokens, limit: budget.limit };
+        },
+        /** Background memory-learn pass for the completed run (undefined while
+         * the run has not completed). */
+        memoryLearning() {
+            return memoryLearning;
+        },
+    };
+}

package/dist/core/runtime/fake-provider.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "@chengchenccc/ai";
+export declare function fakeProvider(env?: Readonly<Record<string, string | undefined>>): Provider;
+//# sourceMappingURL=fake-provider.d.ts.map

package/dist/core/runtime/fake-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-provider.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/fake-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAmCxD,wBAAgB,YAAY,CAC1B,GAAG,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAe,GAC9D,QAAQ,CA4DV"}