@gencode/uni 0.3.1 → 0.4.0

package/dist/uni/src/run.js

@@ -1,17 +1,46 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
 import { isAgentDiagnosticEvent } from "@gencode/shared";
+import { ArtifactAccumulator } from "./artifacts/accumulator.js";
+import { ARTIFACTS_START_TAG, parseAndStripArtifacts, } from "./artifacts/parser.js";
+import { ArtifactStreamFilter } from "./artifacts/stream-filter.js";
+import { inferArtifactsFromToolExecution } from "./artifacts/tool-inference.js";
 import { generateApiKey } from "./auth/api-key.js";
 import { normalizeProviderEvent } from "./events/normalizer.js";
 import { UniHookDispatcher } from "./hooks.js";
+import { providerStateDir, providerStateRoot } from "./providers/provider-state.js";
 import { createBuiltInProviderRegistry } from "./providers/registry.js";
+import { createArtifactOperationRecorder } from "./session/artifact-operation-store.js";
+import { createUniContextStore, } from "./session/context-store.js";
 import { resolveRunInput } from "./session/input.js";
 import { initializeUniLogger, uniLogger } from "./session/logger.js";
 import { createSessionState } from "./session/session-state.js";
-import { appendUniTranscriptEntry, buildUniSessionMetadata, saveUniSessionMetadata, } from "./session/session-store.js";
+import { appendUniTranscriptEntries, appendUniTranscriptEntry, bindUniProviderSession, buildUniSessionMetadata, loadUniSessionMetadata, prepareUniSession, saveUniSessionMetadata, UniSessionError, updateUniSessionMetadata, } from "./session/session-store.js";
 import { CompositeSink } from "./transports/composite-sink.js";
 import { HttpCallbackSink } from "./transports/http-callback-sink.js";
 import { WebSocketSink } from "./transports/websocket-sink.js";
+import { UniTurnAccumulator } from "./transcript/turn-accumulator.js";
 const DEFAULT_STREAM_EVENTS = ["start", "text", "done", "error"];
 const DEFAULT_TIMEOUT_MS = 600_000;
+const ZERO_USAGE = { input: 0, output: 0, total: 0 };
+const ALIGNED_RUNTIME_AGENTS = new Set([
+    "claude-code",
+    "codex",
+    "opencode",
+    "pi",
+]);
+const UNI_ARTIFACT_DECLARATION_PROMPT = [
+    "## Artifact Declaration",
+    "Before your final answer, audit the current turn for user-relevant persistent files and user-openable URLs.",
+    "If this turn produced, modified, exported, downloaded, uploaded, shared, or published any such artifact, append exactly one JSON array block in this form:",
+    "<aimax_artifacts>",
+    '[{"kind":"file","file":"/absolute/or/workspace-relative/path","label":"short description"},{"kind":"url","url":"https://example.test/result","label":"short description"}]',
+    "</aimax_artifacts>",
+    "Audit successful write/edit/apply_patch operations, command outputs and redirections, plugin/skill results, online resources, and explicit child-agent artifacts.",
+    "Do not declare deleted, failed, read-only, temporary/cache, or internal AIMax session files.",
+    "If there are no artifacts, omit the block. Do not duplicate paths or URLs.",
+    "The block is for the runtime parser. It must be the last content in the answer, with no text after </aimax_artifacts>.",
+].join("\n");
 export const UNSUPPORTED_UNI_RUN_OPTION_MESSAGES = {
     agent: "--agent is not supported by @gencode/uni yet",
     skillsLoadPaths: "--skillsLoadPaths is not supported by @gencode/uni yet",
@@ -22,73 +51,62 @@ export const UNSUPPORTED_UNI_RUN_OPTION_MESSAGES = {
 };
 const UNSUPPORTED_UNI_RUN_OPTION_KEYS = Object.keys(UNSUPPORTED_UNI_RUN_OPTION_MESSAGES);
 function hasUnsupportedOptionValue(value) {
-    if (value === undefined || value === null) {
+    if (value === undefined || value === null)
         return false;
-    }
-    if (typeof value === "string") {
+    if (typeof value === "string")
         return value.trim().length > 0;
-    }
-    if (Array.isArray(value)) {
+    if (Array.isArray(value))
         return value.length > 0;
-    }
     return true;
 }
 function collectUnsupportedOptionKeys(options) {
     const record = options;
-    const unsupported = [];
-    for (const key of UNSUPPORTED_UNI_RUN_OPTION_KEYS) {
-        if (hasUnsupportedOptionValue(record[key])) {
-            unsupported.push(key);
-        }
-    }
-    return unsupported;
+    return UNSUPPORTED_UNI_RUN_OPTION_KEYS.filter((key) => hasUnsupportedOptionValue(record[key]));
 }
 export function omitUnsupportedUniRunOptions(options) {
     const omittedKeys = collectUnsupportedOptionKeys(options);
-    if (omittedKeys.length === 0) {
+    if (omittedKeys.length === 0)
         return { options, omittedKeys };
-    }
     const nextOptions = { ...options };
-    for (const key of omittedKeys) {
+    for (const key of omittedKeys)
         delete nextOptions[key];
-    }
     return {
         options: nextOptions,
         omittedKeys,
     };
 }
 function parseStreamEvents(value) {
-    if (!value?.trim()) {
+    if (!value?.trim())
         return new Set(DEFAULT_STREAM_EVENTS);
-    }
-    const parsed = value
-        .split(",")
-        .map((entry) => entry.trim().toLowerCase())
-        .filter(Boolean);
-    const allowed = new Set(["start", "text", "progress", "done", "error", "hitl", "title_updated"]);
+    const parsed = value.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+    const allowed = new Set([
+        "start",
+        "text",
+        "progress",
+        "done",
+        "error",
+        "hitl",
+        "title_updated",
+    ]);
     const resolved = new Set();
     for (const item of parsed) {
-        if (!allowed.has(item)) {
+        if (!allowed.has(item))
             throw new Error(`Invalid stream event: ${item}`);
-        }
         resolved.add(item);
     }
     return resolved.size > 0 ? resolved : new Set(DEFAULT_STREAM_EVENTS);
 }
 function coerceTimeout(value) {
-    if (value === undefined) {
+    if (value === undefined)
         return DEFAULT_TIMEOUT_MS;
-    }
     const parsed = typeof value === "number" ? value : Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
+    if (!Number.isFinite(parsed) || parsed <= 0)
         throw new Error(`Invalid timeout: ${String(value)}`);
-    }
     return parsed;
 }
 function coerceContextWindow(value) {
-    if (value === undefined) {
+    if (value === undefined)
         return undefined;
-    }
     const parsed = typeof value === "number" ? value : Number(value);
     if (!Number.isFinite(parsed) || parsed <= 0) {
         throw new Error(`Invalid context window: ${String(value)}`);
@@ -97,18 +115,16 @@ function coerceContextWindow(value) {
 }
 function ensureDataDir(value) {
     const dataDir = value ?? process.env.AIMAX_DATA_DIR;
-    if (!dataDir) {
+    if (!dataDir)
         throw new Error("Data directory must be specified via dataDir or AIMAX_DATA_DIR");
-    }
     return dataDir;
 }
 function ensureChannel(value) {
     return value ?? "WEB";
 }
 function ensureApiKey(options) {
-    if (options.authToken) {
+    if (options.authToken)
         return generateApiKey(options.authToken);
-    }
     return options.apiKey ?? process.env.AIMAX_API_KEY ?? "";
 }
 function assertSupportedOptions(options) {
@@ -117,6 +133,32 @@ function assertSupportedOptions(options) {
         throw new Error(unsupported.map((key) => UNSUPPORTED_UNI_RUN_OPTION_MESSAGES[key]).join("; "));
     }
 }
+function parseArtifactUrlWhitelist(value) {
+    const rawValues = Array.isArray(value) ? value : value?.split(",") ?? [];
+    const hostnames = rawValues.flatMap((raw) => {
+        const candidate = raw.trim();
+        if (!candidate)
+            return [];
+        try {
+            return [new URL(candidate).hostname.toLowerCase()];
+        }
+        catch {
+            return [candidate.toLowerCase()];
+        }
+    }).filter(Boolean);
+    return hostnames.length > 0 ? [...new Set(hostnames)] : undefined;
+}
+function accumulateUsage(current, next) {
+    if (!next)
+        return current;
+    if (!current)
+        return { ...next };
+    return {
+        input: current.input + next.input,
+        output: current.output + next.output,
+        total: current.total + next.total,
+    };
+}
 async function resolveRunConfig(options) {
     assertSupportedOptions(options);
     const input = await resolveRunInput(options);
@@ -124,7 +166,7 @@ async function resolveRunConfig(options) {
         runtimeAgent: options.runtimeAgent,
         dataDir: ensureDataDir(options.dataDir),
         projectDir: options.projectDir?.trim() || undefined,
-        sessionId: options.sessionId?.trim() || undefined,
+        sessionId: options.sessionId?.trim() || randomUUID(),
         sessionStore: options.sessionStore?.trim() || "sessions",
         messageId: options.messageId?.trim() || undefined,
         channel: ensureChannel(options.channel),
@@ -138,6 +180,7 @@ async function resolveRunConfig(options) {
         streamUrl: options.streamUrl?.trim() || undefined,
         streamAuthToken: options.streamAuthToken?.trim() || undefined,
         streamEvents: parseStreamEvents(options.streamEvents),
+        artifactsUrlWhitelist: parseArtifactUrlWhitelist(options.artifactsUrlWhitelist),
         timeoutMs: coerceTimeout(options.timeout),
         output: options.output === "json" || options.output === "jsonl" ? options.output : "text",
         runtimeConfig: options.runtimeConfig ?? {},
@@ -148,32 +191,25 @@ async function resolveRunConfig(options) {
 function createExternalSink(config) {
     const sinks = [];
     let websocketSink = null;
-    if (config.callbackUrl) {
+    if (config.callbackUrl)
         sinks.push(new HttpCallbackSink(config.callbackUrl));
-    }
     if (config.streamUrl) {
         websocketSink = new WebSocketSink(config.streamUrl, config.streamEvents, config.streamAuthToken);
         sinks.push(websocketSink);
     }
-    return {
-        sink: new CompositeSink(sinks),
-        websocketSink,
-    };
+    return { sink: new CompositeSink(sinks), websocketSink };
 }
 async function emitExternalEvent(sink, event, state, onExternalEvent) {
     state.externalEvents.push(event);
     await onExternalEvent?.(event);
     await sink.send(event);
 }
-function eventMessageId(event, defaultMessageId) {
-    return event.messageId ?? defaultMessageId;
+function eventMessageId(event, fallback) {
+    return event.messageId ?? fallback;
 }
 async function emitProgressEvent(params) {
     const { progressEvent, state, sink, websocketSink, onProgress, onExternalEvent } = params;
     await onProgress?.(progressEvent);
-    if (progressEvent.sessionId) {
-        state.sessionId = progressEvent.sessionId;
-    }
     if (progressEvent.type === "stream_text_delta") {
         state.finalText += progressEvent.text;
         await websocketSink?.sendTextDelta({
@@ -184,12 +220,11 @@ async function emitProgressEvent(params) {
             text: progressEvent.text,
         });
     }
-    if (progressEvent.type === "text") {
+    else if (progressEvent.type === "text") {
         state.finalText += progressEvent.text;
     }
-    if (isAgentDiagnosticEvent(progressEvent)) {
+    if (isAgentDiagnosticEvent(progressEvent))
         return;
-    }
     if (progressEvent.type === "start") {
         await emitExternalEvent(sink, {
             type: "start",
@@ -234,14 +269,411 @@ async function emitProgressEvent(params) {
         event: progressEvent,
     }, state, onExternalEvent);
 }
+function promptText(input) {
+    if (input.kind === "text")
+        return input.message;
+    return input.singleUserText ?? JSON.stringify(input.messages);
+}
+function providerInput(input, aligned) {
+    if (!aligned)
+        return input;
+    if (input.kind === "text") {
+        return { kind: "text", message: `${input.message}\n\n${UNI_ARTIFACT_DECLARATION_PROMPT}` };
+    }
+    const messages = [
+        ...input.messages,
+        { role: "user", content: UNI_ARTIFACT_DECLARATION_PROMPT },
+    ];
+    return {
+        kind: "messages",
+        messages,
+        ...(input.singleUserText
+            ? { singleUserText: `${input.singleUserText}\n\n${UNI_ARTIFACT_DECLARATION_PROMPT}` }
+            : {}),
+    };
+}
+function titleForPrompt(value) {
+    return value.length > 80 ? `${value.slice(0, 77)}...` : value;
+}
+function nonEmpty(value) {
+    return value?.trim() ? value.trim() : undefined;
+}
+function redactKnownProviderIds(value, providerIds) {
+    let redacted = value;
+    for (const providerId of providerIds) {
+        if (providerId) {
+            redacted = redacted.replaceAll(providerId, "[provider-session]");
+        }
+    }
+    return redacted;
+}
+function redactKnownProviderIdsInValue(value, providerIds, depth = 0) {
+    if (typeof value === "string") {
+        return redactKnownProviderIds(value, providerIds);
+    }
+    if (!value || typeof value !== "object" || depth > 12) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactKnownProviderIdsInValue(item, providerIds, depth + 1));
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [
+        key,
+        redactKnownProviderIdsInValue(nested, providerIds, depth + 1),
+    ]));
+}
+function redactProviderEventForPublicBoundary(event, providerIds) {
+    return redactKnownProviderIdsInValue(event, providerIds);
+}
+function providerStateRoots(config) {
+    const commonEnv = config.runtimeConfig.env ?? {};
+    switch (config.runtimeAgent) {
+        case "claude-code": {
+            const runtime = config.runtimeConfig.claudeCode;
+            return [
+                nonEmpty(runtime?.env?.CLAUDE_CONFIG_DIR)
+                    ?? nonEmpty(runtime?.provider?.env?.CLAUDE_CONFIG_DIR)
+                    ?? nonEmpty(commonEnv.CLAUDE_CONFIG_DIR)
+                    ?? nonEmpty(process.env.CLAUDE_CONFIG_DIR)
+                    ?? providerStateDir(config.dataDir, "claude-code"),
+            ];
+        }
+        case "codex": {
+            const runtime = config.runtimeConfig.codex;
+            return [
+                nonEmpty(runtime?.codexHome)
+                    ?? nonEmpty(runtime?.env?.CODEX_HOME)
+                    ?? nonEmpty(runtime?.provider?.env?.CODEX_HOME)
+                    ?? nonEmpty(commonEnv.CODEX_HOME)
+                    ?? nonEmpty(process.env.CODEX_HOME)
+                    ?? providerStateDir(config.dataDir, "codex"),
+            ];
+        }
+        case "opencode": {
+            const runtime = config.runtimeConfig.opencode;
+            const root = nonEmpty(runtime?.env?.XDG_DATA_HOME)
+                ?? nonEmpty(runtime?.provider?.env?.XDG_DATA_HOME)
+                ?? nonEmpty(commonEnv.XDG_DATA_HOME)
+                ?? nonEmpty(process.env.XDG_DATA_HOME)
+                ?? providerStateRoot(config.dataDir);
+            return [path.join(root, "opencode")];
+        }
+        case "pi": {
+            const runtime = config.runtimeConfig.pi;
+            const agentDir = nonEmpty(runtime?.env?.PI_CODING_AGENT_DIR)
+                ?? nonEmpty(commonEnv.PI_CODING_AGENT_DIR)
+                ?? nonEmpty(process.env.PI_CODING_AGENT_DIR)
+                ?? providerStateDir(config.dataDir, "pi");
+            const sessionsDir = nonEmpty(runtime?.env?.PI_CODING_AGENT_SESSION_DIR)
+                ?? nonEmpty(commonEnv.PI_CODING_AGENT_SESSION_DIR)
+                ?? nonEmpty(process.env.PI_CODING_AGENT_SESSION_DIR)
+                ?? path.join(agentDir, "sessions");
+            return [agentDir, sessionsDir];
+        }
+        case "acp":
+            return [];
+    }
+}
+function configuredProviderModel(config) {
+    if (config.model)
+        return config.model;
+    switch (config.runtimeAgent) {
+        case "claude-code":
+            return nonEmpty(config.runtimeConfig.claudeCode?.provider?.model);
+        case "codex":
+            return nonEmpty(config.runtimeConfig.codex?.provider?.model);
+        case "opencode":
+            return nonEmpty(config.runtimeConfig.opencode?.provider?.model);
+        case "pi":
+        case "acp":
+            return undefined;
+    }
+}
+async function prepareAcpCompatibilitySession(params) {
+    const existing = await loadUniSessionMetadata(params.config.dataDir, params.config.sessionId, params.config.sessionStore);
+    if (!existing) {
+        await saveUniSessionMetadata(params.config.dataDir, buildUniSessionMetadata({
+            sessionId: params.config.sessionId,
+            title: params.title,
+            channel: params.config.channel,
+        }), params.config.sessionStore);
+    }
+}
+function toRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : { input: value };
+}
+function canonicalToolName(name) {
+    const normalized = name.trim().toLowerCase().replaceAll("-", "_");
+    if (normalized === "write")
+        return "write_file";
+    if (normalized === "edit")
+        return "edit_file";
+    if (normalized === "command_execution" || normalized === "shell" || normalized === "bash_command") {
+        return "exec";
+    }
+    if (normalized === "file_change")
+        return "apply_patch";
+    return normalized;
+}
+function hasStringField(record, keys) {
+    return keys.some((key) => typeof record[key] === "string");
+}
+function isTrustedOpenCodeCompletedOnlyFileTool(event) {
+    if (event.isError || !event.output.trim())
+        return false;
+    const input = toRecord(event.input);
+    if (!firstString(input, ["path", "file_path", "filePath"]))
+        return false;
+    const name = canonicalToolName(event.name);
+    if (name === "write_file") {
+        return hasStringField(input, ["content"]);
+    }
+    if (name === "edit_file") {
+        return hasStringField(input, ["oldString", "old_string", "oldText", "old_text"])
+            && hasStringField(input, ["newString", "new_string", "newText", "new_text"]);
+    }
+    return false;
+}
+function firstString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function patchSummary(input) {
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    const changes = input.changes;
+    if (Array.isArray(changes)) {
+        for (const raw of changes) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            const change = raw;
+            const file = firstString(change, ["path", "file", "file_path"]);
+            if (!file)
+                continue;
+            const kind = firstString(change, ["kind", "type", "operation"])?.toLowerCase();
+            if (kind === "add" || kind === "create")
+                added.push(file);
+            else if (kind === "delete" || kind === "remove")
+                deleted.push(file);
+            else
+                modified.push(file);
+        }
+    }
+    const patch = firstString(input, ["patch", "input"]);
+    if (patch) {
+        for (const line of patch.split(/\r?\n/)) {
+            const match = line.match(/^\*\*\* (Add|Update|Delete) File:\s*(.+)$/);
+            if (!match?.[2])
+                continue;
+            if (match[1] === "Add")
+                added.push(match[2].trim());
+            else if (match[1] === "Delete")
+                deleted.push(match[2].trim());
+            else
+                modified.push(match[2].trim());
+        }
+    }
+    if (added.length + modified.length + deleted.length === 0)
+        return undefined;
+    return { added, modified, deleted };
+}
+function structuredFileChangesPatch(input) {
+    const changes = toRecord(input).changes;
+    if (!Array.isArray(changes))
+        return undefined;
+    const markers = ["*** Begin Patch"];
+    for (const raw of changes) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            continue;
+        const change = raw;
+        const kind = firstString(change, ["kind", "type", "operation"])?.toLowerCase();
+        const file = firstString(change, ["path", "file", "file_path", "target"]);
+        const source = firstString(change, ["source", "source_path", "from", "old_path"]);
+        if ((kind === "move" || kind === "rename") && file && source) {
+            markers.push(`*** Update File: ${source}`, `*** Move to: ${file}`);
+        }
+        else if ((kind === "add" || kind === "create") && file) {
+            markers.push(`*** Add File: ${file}`);
+        }
+        else if ((kind === "delete" || kind === "remove") && file) {
+            markers.push(`*** Delete File: ${file}`);
+        }
+        else if (file) {
+            markers.push(`*** Update File: ${file}`);
+        }
+    }
+    markers.push("*** End Patch");
+    return markers.length > 2 ? markers.join("\n") : undefined;
+}
+function artifactAuditStartEvent(event) {
+    if (canonicalToolName(event.name) !== "apply_patch")
+        return event;
+    const patch = structuredFileChangesPatch(event.input);
+    return patch ? { ...event, name: "apply_patch", input: { patch } } : event;
+}
+function artifactAuditEndEvent(event) {
+    if (canonicalToolName(event.name) !== "apply_patch")
+        return event;
+    const patch = structuredFileChangesPatch(event.input);
+    return patch ? { ...event, name: "apply_patch", input: { patch } } : event;
+}
+function artifactAuditFileOperation(event) {
+    const name = canonicalToolName(event.name);
+    if (name !== "apply_patch")
+        return { ...event, name };
+    const patch = structuredFileChangesPatch(event.input);
+    return {
+        ...event,
+        name,
+        ...(patch ? { input: { patch } } : {}),
+    };
+}
+function inferenceResultForTool(params) {
+    const input = toRecord(params.input);
+    const name = canonicalToolName(params.name);
+    const content = [{ type: "text", text: params.output }];
+    if (name === "write_file") {
+        return { content, details: { path: firstString(input, ["path", "file_path", "filePath"]) } };
+    }
+    if (name === "edit_file") {
+        return {
+            content,
+            details: {
+                path: firstString(input, ["path", "file_path", "filePath"]),
+                occurrences: params.isError ? 0 : 1,
+            },
+        };
+    }
+    if (name === "apply_patch")
+        return { content, details: { summary: patchSummary(input) } };
+    if (name === "exec" || name === "bash" || name === "process") {
+        return {
+            content,
+            details: {
+                status: params.isError ? "failed" : "completed",
+                cwd: firstString(input, ["cwd"]) ?? undefined,
+            },
+        };
+    }
+    return params.output;
+}
+function inferenceResult(event) {
+    return inferenceResultForTool(event);
+}
+function isInternalArtifact(artifact, dataDir) {
+    if (artifact.kind !== "file")
+        return false;
+    const internalRoot = path.resolve(dataDir, ".aimax");
+    const candidate = path.resolve(artifact.file);
+    return candidate === internalRoot || candidate.startsWith(`${internalRoot}${path.sep}`);
+}
+function parseArtifactArray(value, workspaceDir) {
+    if (!Array.isArray(value))
+        return [];
+    const now = new Date().toISOString();
+    return value.flatMap((raw) => {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return [];
+        const record = raw;
+        const label = typeof record.label === "string" && record.label.trim()
+            ? record.label.trim()
+            : undefined;
+        if (record.kind === "file" && typeof record.file === "string" && record.file.trim() && label) {
+            const file = path.isAbsolute(record.file) ? path.normalize(record.file) : path.resolve(workspaceDir, record.file);
+            return [{ kind: "file", file, label, timestamp: now }];
+        }
+        if (record.kind === "url" && typeof record.url === "string" && record.url.trim() && label) {
+            try {
+                const url = new URL(record.url).toString();
+                return [{ kind: "url", url, label, timestamp: now }];
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    });
+}
+function extractChildArtifacts(toolName, output, workspaceDir) {
+    const normalized = toolName.trim().toLowerCase().replaceAll("-", "_");
+    if (!normalized.includes("subagent") && normalized !== "task" && normalized !== "batch")
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return [];
+    const record = parsed;
+    const direct = parseArtifactArray(record.artifacts, workspaceDir);
+    if (direct.length > 0)
+        return direct;
+    const result = record.result;
+    return result && typeof result === "object" && !Array.isArray(result)
+        ? parseArtifactArray(result.artifacts, workspaceDir)
+        : [];
+}
 export async function runUni(options) {
     const config = await resolveRunConfig(options);
     initializeUniLogger(config.dataDir);
     const registry = createBuiltInProviderRegistry();
     const provider = options.runtimeProviderFactory?.(config.runtimeAgent) ?? registry.get(config.runtimeAgent);
-    if (!provider) {
+    if (!provider)
         throw new Error(`Unsupported runtime agent: ${config.runtimeAgent}`);
+    const aligned = ALIGNED_RUNTIME_AGENTS.has(config.runtimeAgent);
+    const rawPrompt = promptText(config.input);
+    const metadataTitle = titleForPrompt(rawPrompt);
+    let prepared;
+    let contextStore;
+    if (aligned) {
+        try {
+            prepared = await prepareUniSession({
+                dataDir: config.dataDir,
+                logicalSessionId: config.sessionId,
+                runtimeAgent: config.runtimeAgent,
+                title: metadataTitle,
+                channel: config.channel,
+                storeName: config.sessionStore,
+                providerStateRoots: providerStateRoots(config),
+            });
+        }
+        catch (error) {
+            if (error instanceof UniSessionError && error.code === "legacy_unresolved") {
+                await createUniContextStore({
+                    dataDir: config.dataDir,
+                    logicalSessionId: config.sessionId,
+                    storeName: config.sessionStore,
+                });
+            }
+            throw error;
+        }
+        contextStore = await createUniContextStore({
+            dataDir: config.dataDir,
+            logicalSessionId: config.sessionId,
+            storeName: config.sessionStore,
+        });
     }
+    else {
+        await prepareAcpCompatibilitySession({ config, title: metadataTitle });
+    }
+    await appendUniTranscriptEntry(config.dataDir, config.sessionId, {
+        role: "user",
+        content: rawPrompt,
+        timestamp: new Date().toISOString(),
+        runtimeAgent: config.runtimeAgent,
+        ...(config.messageId ? { messageId: config.messageId } : {}),
+    }, config.sessionStore);
+    const coveredTranscriptEntryCount = (prepared?.existingTranscriptEntryCount ?? 0) + 1;
     const state = createSessionState({
         runtimeAgent: config.runtimeAgent,
         sessionId: config.sessionId,
@@ -255,344 +687,428 @@ export async function runUni(options) {
     const abortController = new AbortController();
     const timeout = setTimeout(() => abortController.abort(), config.timeoutMs);
     const hookDispatcher = new UniHookDispatcher(options.runtimeHooks);
+    const turn = new UniTurnAccumulator({
+        runtimeAgent: config.runtimeAgent,
+        messageId: config.messageId,
+    });
+    const streamFilter = aligned ? new ArtifactStreamFilter() : undefined;
+    const artifactAccumulator = aligned
+        ? new ArtifactAccumulator({ urlWhitelist: config.artifactsUrlWhitelist })
+        : undefined;
+    const workspaceDir = config.projectDir ?? config.dataDir;
+    const operationRecorder = aligned && config.channel !== "CRON"
+        ? createArtifactOperationRecorder({
+            dataDir: config.dataDir,
+            logicalSessionId: config.sessionId,
+            storeName: config.sessionStore,
+            workspaceDir,
+        })
+        : undefined;
     const activeToolCalls = new Map();
-    const pendingTranscriptToolCalls = [];
-    const pendingTranscriptToolCallIds = new Set();
-    const pendingTranscriptToolResults = [];
-    const pendingTranscriptToolResultIds = new Set();
-    let pendingAssistantContent = "";
-    let persistenceSessionId = config.sessionId;
-    let metadataSaved = false;
-    let metadataTitle = "";
-    const pendingTranscriptEntries = [];
-    const ensureSessionPersistence = async (sessionId) => {
-        if (!metadataSaved) {
-            await saveUniSessionMetadata(config.dataDir, buildUniSessionMetadata({
-                sessionId,
-                title: metadataTitle,
-                channel: config.channel,
-            }), config.sessionStore).catch((err) => { uniLogger.warn("failed to save session metadata", { error: String(err) }); });
-            metadataSaved = true;
-        }
-        while (pendingTranscriptEntries.length > 0) {
-            const entry = pendingTranscriptEntries.shift();
-            if (!entry) {
-                continue;
-            }
-            await appendUniTranscriptEntry(config.dataDir, sessionId, entry, config.sessionStore).catch((err) => { uniLogger.warn("failed to append buffered transcript", { error: String(err) }); });
-        }
-    };
-    const setPersistenceSessionId = async (sessionId) => {
-        if (!persistenceSessionId) {
-            persistenceSessionId = sessionId;
-            await ensureSessionPersistence(sessionId);
-            return;
-        }
-        if (persistenceSessionId !== sessionId) {
-            uniLogger.warn("provider session id differed from transcript session id", {
-                transcriptSessionId: persistenceSessionId,
-                providerSessionId: sessionId,
-            });
-        }
+    const observedToolStartIds = new Set();
+    const recordedCompletedOnlyToolIds = new Set();
+    const observedProviderSessionIds = new Set(prepared?.providerSessionId ? [prepared.providerSessionId] : []);
+    let rawProviderText = "";
+    let observedDoneText;
+    let observedUsage;
+    let observedModel;
+    let observedError;
+    let observedTitle;
+    const emitProgress = async (event) => {
+        progressEvents.push(event);
+        await emitProgressEvent({
+            progressEvent: event,
+            state,
+            sink,
+            websocketSink,
+            onProgress: options.onProgress,
+            onExternalEvent: options.onExternalEvent,
+        });
     };
-    const appendTranscriptEntry = async (entry) => {
-        if (!persistenceSessionId) {
-            pendingTranscriptEntries.push(entry);
-            return;
-        }
-        await ensureSessionPersistence(persistenceSessionId);
-        await appendUniTranscriptEntry(config.dataDir, persistenceSessionId, entry, config.sessionStore).catch((err) => { uniLogger.warn("failed to append transcript", { error: String(err) }); });
+    const appendTurnEntries = async (entries) => {
+        await appendUniTranscriptEntries(config.dataDir, config.sessionId, entries, config.sessionStore);
     };
-    const ensureFinalPersistenceSession = async () => {
-        if (!persistenceSessionId) {
-            persistenceSessionId = state.sessionId;
-        }
-        await ensureSessionPersistence(persistenceSessionId);
-        return persistenceSessionId;
+    const flushCompletedTools = async () => {
+        if (turn.hasCompletedToolBatch())
+            await appendTurnEntries(turn.flushToolBatch());
     };
     const createToolHookContext = () => ({
         runtimeAgent: config.runtimeAgent,
-        sessionId: state.sessionId,
-        messageId: state.messageId,
-        channel: state.channel,
+        sessionId: config.sessionId,
+        messageId: config.messageId,
+        channel: config.channel,
         projectDir: config.projectDir,
     });
-    const recordPendingTranscriptToolCall = (toolCallId, toolName, params) => {
-        if (pendingTranscriptToolCallIds.has(toolCallId)) {
-            return;
-        }
-        pendingTranscriptToolCallIds.add(toolCallId);
-        pendingTranscriptToolCalls.push({
-            id: toolCallId,
-            name: toolName,
-            arguments: params,
-        });
-    };
-    const flushPendingToolBatch = async () => {
-        if (pendingTranscriptToolCalls.length === 0) {
-            pendingTranscriptToolResults.length = 0;
-            pendingTranscriptToolResultIds.clear();
+    const emitVisibleText = async (type, text) => {
+        rawProviderText += text;
+        const visible = streamFilter ? streamFilter.push(text) : text;
+        if (!visible)
             return;
-        }
-        await appendTranscriptEntry({
-            role: "assistant",
-            content: pendingAssistantContent,
-            toolCalls: [...pendingTranscriptToolCalls],
-            timestamp: new Date().toISOString(),
-            runtimeAgent: config.runtimeAgent,
-            messageId: state.messageId,
-        });
-        pendingAssistantContent = "";
-        pendingTranscriptToolCalls.length = 0;
-        pendingTranscriptToolCallIds.clear();
-        for (const entry of pendingTranscriptToolResults) {
-            await appendTranscriptEntry(entry);
-        }
-        pendingTranscriptToolResults.length = 0;
-        pendingTranscriptToolResultIds.clear();
-    };
-    const recordPendingTranscriptToolResult = (params) => {
-        if (pendingTranscriptToolResultIds.has(params.toolCallId)) {
-            return;
-        }
-        pendingTranscriptToolResultIds.add(params.toolCallId);
-        pendingTranscriptToolResults.push({
-            role: "tool_result",
-            toolCallId: params.toolCallId,
-            toolName: params.toolName,
-            content: params.output,
-            isError: params.isError,
-            timestamp: new Date().toISOString(),
-            runtimeAgent: config.runtimeAgent,
-            messageId: state.messageId,
-        });
+        await flushCompletedTools();
+        turn.addText(visible);
+        const normalized = normalizeProviderEvent(config.sessionId, config.messageId, { type, text: visible });
+        for (const event of normalized)
+            await emitProgress(event);
     };
-    const appendPendingAssistantContentEntry = async (fallbackContent, metadata) => {
-        await flushPendingToolBatch();
-        const content = pendingAssistantContent || fallbackContent || "";
-        if (!content && !fallbackContent) {
+    const bindProviderSession = async (providerSessionId) => {
+        if (!aligned)
             return;
-        }
-        await appendTranscriptEntry({
-            role: "assistant",
-            content,
-            timestamp: new Date().toISOString(),
+        await bindUniProviderSession({
+            dataDir: config.dataDir,
+            logicalSessionId: config.sessionId,
             runtimeAgent: config.runtimeAgent,
-            messageId: state.messageId,
-            ...metadata,
+            providerSessionId,
+            storeName: config.sessionStore,
         });
-        pendingAssistantContent = "";
     };
     try {
-        const promptText = config.input.kind === "text"
-            ? config.input.message
-            : config.input.singleUserText ?? `Loaded ${config.input.messages.length} structured messages`;
-        metadataTitle = promptText.length > 80 ? promptText.slice(0, 77) + "..." : promptText;
         uniLogger.info("uni run started", {
             runtimeAgent: config.runtimeAgent,
-            sessionId: state.sessionId,
-            messageId: state.messageId,
+            sessionId: config.sessionId,
+            messageId: config.messageId,
             channel: config.channel,
             sessionStore: config.sessionStore,
         });
-        await appendTranscriptEntry({
-            role: "user",
-            content: promptText,
-            timestamp: new Date().toISOString(),
-            runtimeAgent: config.runtimeAgent,
-            messageId: state.messageId,
-        });
-        const startEvent = {
+        await emitProgress({
             type: "start",
-            sessionId: state.sessionId,
-            messageId: state.messageId,
-            message: promptText,
-        };
-        progressEvents.push(startEvent);
-        await emitProgressEvent({
-            progressEvent: startEvent,
-            state,
-            sink,
-            websocketSink,
-            onProgress: options.onProgress,
-            onExternalEvent: options.onExternalEvent,
-        });
-        const providerResult = await provider.run({
-            runtimeAgent: config.runtimeAgent,
-            dataDir: config.dataDir,
-            projectDir: config.projectDir,
             sessionId: config.sessionId,
             messageId: config.messageId,
-            channel: config.channel,
-            baseUrl: config.baseUrl,
-            apiKey: config.apiKey,
-            authToken: config.authToken,
-            model: config.model,
-            contextWindow: config.contextWindow,
-            flashModel: config.flashModel,
-            timeoutMs: config.timeoutMs,
-            runtimeConfig: config.runtimeConfig,
-            input: config.input,
-            signal: abortController.signal,
-        }, async (providerEvent) => {
-            if (providerEvent.type === "session_started") {
-                await setPersistenceSessionId(providerEvent.sessionId);
-                if (providerEvent.sessionId === state.sessionId) {
+            message: rawPrompt,
+        });
+        if (aligned && prepared?.isNew) {
+            await emitProgress({
+                type: "session_reset",
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                action: "new",
+                message: "Logical session started",
+            });
+        }
+        let providerResult;
+        try {
+            providerResult = await provider.run({
+                runtimeAgent: config.runtimeAgent,
+                logicalSessionId: config.sessionId,
+                dataDir: config.dataDir,
+                projectDir: config.projectDir,
+                providerSessionId: aligned ? prepared?.providerSessionId : nonEmpty(options.sessionId),
+                sessionId: aligned ? prepared?.providerSessionId : nonEmpty(options.sessionId),
+                messageId: config.messageId,
+                channel: config.channel,
+                baseUrl: config.baseUrl,
+                apiKey: config.apiKey,
+                authToken: config.authToken,
+                model: config.model,
+                contextWindow: config.contextWindow,
+                flashModel: config.flashModel,
+                timeoutMs: config.timeoutMs,
+                runtimeConfig: config.runtimeConfig,
+                input: providerInput(config.input, aligned),
+                signal: abortController.signal,
+            }, async (providerEvent) => {
+                let eventForProgress = providerEvent;
+                if (providerEvent.type === "session_started") {
+                    observedModel = providerEvent.model ?? observedModel;
+                    if (aligned) {
+                        if (!observedProviderSessionIds.has(providerEvent.sessionId)) {
+                            await bindProviderSession(providerEvent.sessionId);
+                            observedProviderSessionIds.add(providerEvent.sessionId);
+                        }
+                    }
+                    else {
+                        for (const event of normalizeProviderEvent(config.sessionId, config.messageId, providerEvent)) {
+                            await emitProgress(event);
+                        }
+                    }
                     return;
                 }
-            }
-            if (providerEvent.type === "step_finished") {
-                await flushPendingToolBatch();
-            }
-            const normalized = normalizeProviderEvent(state.sessionId, state.messageId, providerEvent);
-            for (const event of normalized) {
-                if (event.type === "tool_start") {
-                    const params = event.input && typeof event.input === "object" && !Array.isArray(event.input)
-                        ? event.input
-                        : { input: event.input };
-                    activeToolCalls.set(event.toolCallId, {
-                        toolName: event.name,
+                if (aligned) {
+                    providerEvent = redactProviderEventForPublicBoundary(providerEvent, observedProviderSessionIds);
+                    eventForProgress = providerEvent;
+                }
+                if (providerEvent.type === "text_delta" || providerEvent.type === "message") {
+                    await emitVisibleText(providerEvent.type, providerEvent.text);
+                    return;
+                }
+                if (providerEvent.type === "thinking_delta") {
+                    if (aligned) {
+                        await flushCompletedTools();
+                        turn.addThinking(providerEvent.text);
+                    }
+                    return;
+                }
+                if (providerEvent.type === "file_operation") {
+                    const auditEvent = artifactAuditFileOperation(providerEvent);
+                    await Promise.resolve(operationRecorder?.recordObservedFileOperation(auditEvent))
+                        .catch(() => undefined);
+                    if (!providerEvent.isError && artifactAccumulator) {
+                        artifactAccumulator.addInferred(inferArtifactsFromToolExecution({
+                            toolName: canonicalToolName(providerEvent.name),
+                            input: toRecord(providerEvent.input),
+                            result: inferenceResultForTool(providerEvent),
+                            isError: false,
+                            workspaceDir,
+                        }).filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
+                    }
+                    return;
+                }
+                if (providerEvent.type === "tool_start") {
+                    const params = toRecord(providerEvent.input);
+                    observedToolStartIds.add(providerEvent.toolCallId);
+                    activeToolCalls.set(providerEvent.toolCallId, {
+                        toolName: providerEvent.name,
                         params,
                         startedAt: Date.now(),
                     });
-                    recordPendingTranscriptToolCall(event.toolCallId, event.name, params);
+                    turn.startTool(providerEvent);
+                    await Promise.resolve(operationRecorder?.onToolStart(artifactAuditStartEvent(providerEvent)))
+                        .catch(() => undefined);
                     await hookDispatcher.dispatchBeforeToolCall({
-                        toolCallId: event.toolCallId,
-                        toolName: event.name,
+                        toolCallId: providerEvent.toolCallId,
+                        toolName: providerEvent.name,
                         params,
                     }, createToolHookContext());
                 }
-                if (event.type === "tool_end") {
-                    const active = activeToolCalls.get(event.toolCallId);
-                    const params = active?.params
-                        ?? (event.input && typeof event.input === "object" && !Array.isArray(event.input)
-                            ? event.input
-                            : { input: event.input });
-                    recordPendingTranscriptToolCall(event.toolCallId, event.name, params);
-                    recordPendingTranscriptToolResult({
-                        toolCallId: event.toolCallId,
-                        toolName: event.name,
-                        output: event.output,
-                        isError: event.isError,
+                else if (providerEvent.type === "tool_end") {
+                    const active = activeToolCalls.get(providerEvent.toolCallId);
+                    const params = active?.params ?? toRecord(providerEvent.input);
+                    const toolEndEvent = active
+                        ? {
+                            ...providerEvent,
+                            name: active.toolName,
+                            input: active.params,
+                        }
+                        : providerEvent;
+                    eventForProgress = toolEndEvent;
+                    const paired = turn.endTool(toolEndEvent);
+                    await Promise.resolve(operationRecorder?.onToolEnd(artifactAuditEndEvent(toolEndEvent)))
+                        .catch(() => undefined);
+                    if (config.runtimeAgent === "opencode"
+                        && !observedToolStartIds.has(toolEndEvent.toolCallId)
+                        && !recordedCompletedOnlyToolIds.has(toolEndEvent.toolCallId)
+                        && isTrustedOpenCodeCompletedOnlyFileTool(toolEndEvent)) {
+                        recordedCompletedOnlyToolIds.add(toolEndEvent.toolCallId);
+                        await Promise.resolve(operationRecorder?.recordObservedFileOperation({
+                            operationId: toolEndEvent.toolCallId,
+                            name: toolEndEvent.name,
+                            input: toolEndEvent.input,
+                            output: toolEndEvent.output,
+                            isError: toolEndEvent.isError,
+                        })).catch(() => undefined);
+                    }
+                    await contextStore?.persistToolResult({
+                        toolCallId: toolEndEvent.toolCallId,
+                        toolName: toolEndEvent.name,
+                        content: toolEndEvent.output,
+                    }).catch((error) => {
+                        uniLogger.warn("failed to persist observable tool result", { error: String(error) });
                     });
+                    if (aligned && paired && !providerEvent.isError && artifactAccumulator) {
+                        artifactAccumulator.addChild(extractChildArtifacts(toolEndEvent.name, toolEndEvent.output, workspaceDir)
+                            .filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
+                        artifactAccumulator.addInferred(inferArtifactsFromToolExecution({
+                            toolName: canonicalToolName(toolEndEvent.name),
+                            input: params,
+                            result: inferenceResult(toolEndEvent),
+                            isError: toolEndEvent.isError,
+                            workspaceDir,
+                        }).filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
+                    }
                     await hookDispatcher.dispatchAfterToolCall({
-                        toolCallId: event.toolCallId,
-                        toolName: event.name,
+                        toolCallId: providerEvent.toolCallId,
+                        toolName: toolEndEvent.name,
                         params,
-                        result: event.output,
-                        error: event.isError ? event.output : undefined,
+                        result: toolEndEvent.output,
+                        error: toolEndEvent.isError ? toolEndEvent.output : undefined,
                         durationMs: active ? Date.now() - active.startedAt : undefined,
                     }, createToolHookContext());
-                    activeToolCalls.delete(event.toolCallId);
+                    activeToolCalls.delete(providerEvent.toolCallId);
                 }
-                if (event.type === "stream_text_delta" || event.type === "text") {
-                    await flushPendingToolBatch();
-                    pendingAssistantContent += event.text;
+                else if (providerEvent.type === "step_finished") {
+                    await flushCompletedTools();
+                    return;
                 }
-                progressEvents.push(event);
-                await emitProgressEvent({
-                    progressEvent: event,
-                    state,
-                    sink,
-                    websocketSink,
-                    onProgress: options.onProgress,
-                    onExternalEvent: options.onExternalEvent,
-                });
-            }
-        });
+                else if (providerEvent.type === "done") {
+                    observedDoneText = providerEvent.text ?? observedDoneText;
+                    observedUsage = accumulateUsage(observedUsage, providerEvent.usage);
+                    observedModel = providerEvent.model ?? observedModel;
+                    await flushCompletedTools();
+                    return;
+                }
+                else if (providerEvent.type === "error") {
+                    observedError = providerEvent.message;
+                    observedUsage = accumulateUsage(observedUsage, providerEvent.usage);
+                    observedModel = providerEvent.model ?? observedModel;
+                }
+                else if (providerEvent.type === "title") {
+                    observedTitle = providerEvent.title;
+                }
+                for (const event of normalizeProviderEvent(config.sessionId, config.messageId, eventForProgress)) {
+                    await emitProgress(event);
+                }
+            });
+        }
+        catch (error) {
+            if (error instanceof UniSessionError)
+                throw error;
+            providerResult = { error: error instanceof Error ? error.message : String(error) };
+        }
         if (providerResult.sessionId) {
-            await setPersistenceSessionId(providerResult.sessionId);
-            state.sessionId = providerResult.sessionId;
+            await bindProviderSession(providerResult.sessionId);
+            observedProviderSessionIds.add(providerResult.sessionId);
+        }
+        const filterTail = streamFilter?.finish() ?? "";
+        if (filterTail) {
+            await flushCompletedTools();
+            turn.addText(filterTail);
+            for (const event of normalizeProviderEvent(config.sessionId, config.messageId, {
+                type: "text_delta",
+                text: filterTail,
+            }))
+                await emitProgress(event);
+        }
+        const hasExplicitTerminalText = providerResult.text !== undefined || observedDoneText !== undefined;
+        const rawProviderFinalText = providerResult.text ?? observedDoneText ?? rawProviderText;
+        const providerFinalText = aligned
+            ? redactKnownProviderIds(rawProviderFinalText, observedProviderSessionIds)
+            : rawProviderFinalText;
+        const parsedArtifacts = aligned
+            ? parseAndStripArtifacts(providerFinalText, { workspaceDir })
+            : { cleanedText: providerFinalText, artifacts: [], warnings: [] };
+        const streamedArtifactParse = aligned
+            && rawProviderText !== providerFinalText
+            && rawProviderText.includes(ARTIFACTS_START_TAG)
+            ? parseAndStripArtifacts(rawProviderText, { workspaceDir })
+            : undefined;
+        artifactAccumulator?.addOwn(parsedArtifacts.artifacts.filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
+        artifactAccumulator?.addOwn((streamedArtifactParse?.artifacts ?? [])
+            .filter((artifact) => !isInternalArtifact(artifact, config.dataDir)));
+        for (const warning of new Set([
+            ...parsedArtifacts.warnings,
+            ...(streamedArtifactParse?.warnings ?? []),
+        ])) {
+            await emitProgress({
+                type: "diagnostic",
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                level: "warn",
+                scope: "runner",
+                phase: "artifact_declaration",
+                message: warning,
+            });
         }
-        if (providerResult.text) {
-            state.finalText = providerResult.text;
+        if (rawProviderText && state.finalText !== parsedArtifacts.cleanedText) {
+            await emitProgress({
+                type: "diagnostic",
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                level: "warn",
+                scope: "runner",
+                phase: "provider_text_mismatch",
+                message: "Provider terminal text differed from streamed text; the terminal result is authoritative",
+            });
+        }
+        const usage = providerResult.usage ?? observedUsage;
+        const rawError = providerResult.error ?? observedError;
+        const error = rawError
+            ? redactKnownProviderIds(rawError, observedProviderSessionIds)
+            : undefined;
+        const durationMs = Date.now() - startedAt;
+        const artifacts = artifactAccumulator?.dump() ?? [];
+        state.finalText = parsedArtifacts.cleanedText;
+        if (!usage && aligned) {
+            await emitProgress({
+                type: "diagnostic",
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                level: "warn",
+                scope: "runner",
+                phase: "provider_usage_unavailable",
+                message: `${config.runtimeAgent} did not expose token usage; transport compatibility uses zero without persisting it`,
+            });
         }
-        if (providerResult.title) {
-            const event = {
+        const finalEntries = turn.finalize({
+            fallbackContent: parsedArtifacts.cleanedText,
+            forceFallbackContent: hasExplicitTerminalText,
+            usage,
+            durationMs,
+            error,
+            artifacts: artifacts.length > 0 ? artifacts : undefined,
+        });
+        await appendTurnEntries(finalEntries);
+        if (usage && contextStore) {
+            const rawModel = providerResult.model
+                ?? observedModel
+                ?? configuredProviderModel(config)
+                ?? `runtime:${config.runtimeAgent}`;
+            await contextStore.recordModelUsage({
+                model: aligned
+                    ? redactKnownProviderIds(rawModel, observedProviderSessionIds)
+                    : rawModel,
+                usage,
+                coveredTranscriptEntryCount,
+            }).catch((contextError) => {
+                uniLogger.warn("failed to update model usage context", { error: String(contextError) });
+            });
+        }
+        const rawFinalTitle = providerResult.title ?? observedTitle;
+        const finalTitle = rawFinalTitle && aligned
+            ? redactKnownProviderIds(rawFinalTitle, observedProviderSessionIds)
+            : rawFinalTitle;
+        await updateUniSessionMetadata(config.dataDir, config.sessionId, {
+            ...(finalTitle ? { title: finalTitle } : {}),
+        }, config.sessionStore);
+        if (finalTitle) {
+            await emitProgress({
                 type: "title_updated",
-                sessionId: state.sessionId,
-                messageId: state.messageId,
-                title: providerResult.title,
-            };
-            progressEvents.push(event);
-            await emitProgressEvent({
-                progressEvent: event,
-                state,
-                sink,
-                websocketSink,
-                onProgress: options.onProgress,
-                onExternalEvent: options.onExternalEvent,
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                title: finalTitle,
             });
         }
-        if (providerResult.error) {
+        const resultPayload = {
+            text: parsedArtifacts.cleanedText,
+            usage: usage ?? { ...ZERO_USAGE },
+            durationMs,
+            ...(error ? { error } : {}),
+            ...(aligned && artifacts.length > 0 ? { artifacts } : {}),
+        };
+        if (error) {
             uniLogger.error("uni run failed", {
                 runtimeAgent: config.runtimeAgent,
-                sessionId: state.sessionId,
-                durationMs: Date.now() - startedAt,
-                error: providerResult.error,
-            });
-            // Persist assistant error transcript entry
-            await ensureFinalPersistenceSession();
-            await flushPendingToolBatch();
-            await appendTranscriptEntry({
-                role: "assistant",
-                content: state.finalText,
-                timestamp: new Date().toISOString(),
-                runtimeAgent: config.runtimeAgent,
-                messageId: state.messageId,
-                usage: providerResult.usage,
-                durationMs: Date.now() - startedAt,
-                error: providerResult.error,
+                sessionId: config.sessionId,
+                durationMs,
+                error,
             });
             await emitExternalEvent(sink, {
                 type: "error",
-                sessionId: state.sessionId,
-                messageId: state.messageId,
-                channel: state.channel,
-                user: state.user,
-                message: providerResult.error,
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                channel: config.channel,
+                user: config.user,
+                message: error,
             }, state, options.onExternalEvent);
-            return {
+        }
+        else {
+            uniLogger.info("uni run completed", {
                 runtimeAgent: config.runtimeAgent,
-                sessionId: state.sessionId,
-                text: state.finalText,
-                usage: providerResult.usage ?? { input: 0, output: 0, total: 0 },
-                durationMs: Date.now() - startedAt,
-                error: providerResult.error,
-                progressEvents,
-                externalEvents: state.externalEvents,
-            };
+                sessionId: config.sessionId,
+                durationMs,
+                ...(usage ? { inputTokens: usage.input, outputTokens: usage.output } : {}),
+            });
+            await emitExternalEvent(sink, {
+                type: "done",
+                sessionId: config.sessionId,
+                messageId: config.messageId,
+                channel: config.channel,
+                user: config.user,
+                result: resultPayload,
+            }, state, options.onExternalEvent);
         }
-        const result = {
-            text: state.finalText,
-            usage: providerResult.usage ?? { input: 0, output: 0, total: 0 },
-            durationMs: Date.now() - startedAt,
-        };
-        uniLogger.info("uni run completed", {
-            runtimeAgent: config.runtimeAgent,
-            sessionId: state.sessionId,
-            durationMs: result.durationMs,
-            inputTokens: result.usage.input,
-            outputTokens: result.usage.output,
-        });
-        // Persist assistant transcript entry
-        await ensureFinalPersistenceSession();
-        await appendPendingAssistantContentEntry(state.finalText, {
-            usage: result.usage,
-            durationMs: result.durationMs,
-        });
-        await emitExternalEvent(sink, {
-            type: "done",
-            sessionId: state.sessionId,
-            messageId: state.messageId,
-            channel: state.channel,
-            user: state.user,
-            result,
-        }, state, options.onExternalEvent);
         return {
             runtimeAgent: config.runtimeAgent,
-            sessionId: state.sessionId,
-            ...result,
+            sessionId: config.sessionId,
+            ...resultPayload,
             progressEvents,
             externalEvents: state.externalEvents,
         };