@kilnai/cli 1.0.4 → 2.0.0

package/dist/commands/run.js

@@ -3,23 +3,38 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import readline from "node:readline";
 import { SessionManager } from "../wrapper/session-manager.js";
-import { createDefaultRegistry, isDirectApiProvider } from "../wrapper/session-registry.js";
+import { createDefaultRegistry, getRuntimeProviderAvailability, isDirectApiProvider, } from "../wrapper/session-registry.js";
 import { cleanupRegistry } from "../wrapper/cleanup-registry.js";
 import { defaultBuildSystemPrompt } from "../config.js";
+import { withGlobalIdentityContext } from "../config/operator-identity-context.js";
 import { findAgent, loadAgentDefinitions, } from "../application/agent-loader.js";
+import { resolveAgentSkillContextCandidates, withContextCandidates, } from "../application/agent-skill-context.js";
+import { resolveInstructionProfileContextCandidates } from "../application/instruction-profile-context.js";
+import { withWorkGovernanceContext } from "../application/work-governance-context.js";
+import { readKilnYaml } from "../kiln-yaml.js";
 import { computeEvalScore, printContextGovernancePreview, printReport, summarizeContextGovernance, } from "../application/session-report.js";
 import { buildModuleSummaryArtifact, extractTouchedFilePaths } from "../application/repo-summary-cache.js";
+import { buildCliCompletionContextArtifacts } from "../application/session-context-artifacts.js";
 import { inferResumeStrategyFeedback } from "../application/resume-strategy-feedback.js";
 import { resolveResumeSessionId } from "../application/session-resume.js";
+import { deriveSessionMetadata } from "../application/session-metadata.js";
 import { SessionHooks } from "../application/session-hooks.js";
 import { runSession } from "../application/run-session.js";
 import { ApprovalMemoryStore as ApprovalMemoryStoreImpl } from "../wrapper/index.js";
 import { TranscriptStore } from "../wrapper/session-store.js";
 import { resolveEffectiveModel } from "../config/env-config.js";
-import { readGlobalConfig } from "../config/global-config.js";
-import { SkillGenerator, AnthropicAdapter, scoreComplexity, } from "@kilnai/core";
-import { getProjectContextArtifactCache } from "@kilnai/runtime";
-import { buildCliPlanSummaryArtifactKey, buildCliProjectSummaryArtifactKey, buildCliSessionSummaryArtifactKey, } from "../application/context-artifact-keys.js";
+import { readGlobalConfig, resolveGlobalDefaultModel } from "../config/global-config.js";
+import { loadKilnConfig } from "../config/config-merger.js";
+import { inferRouteTask, resolveProviderRouteCandidates } from "../config/provider-route-candidates.js";
+import { createManagedDirectProviderAdapterFactory } from "../config/managed-agent-direct-adapters.js";
+import { createKilnConfigTools } from "../application/config-tools.js";
+import { createWorkGovernanceTools } from "../application/work-governance-tool.js";
+import { discoverManagedAgentProviderModels } from "../config/managed-agent-provider-models.js";
+import { resolveManagedInvocationToolOptions } from "../config/managed-agent-routes.js";
+import { loadConfiguredBuiltinToolSurfaceOptions } from "../config/builtin-tool-surface-config.js";
+import { resolveEngineAvailabilityMap } from "../engines/engine-registry.js";
+import { SkillGenerator, AnthropicAdapter, GoalRunStore, WorkItemStore, createSessionBuiltinToolOptions, formatProviderModelRouteCooldown, mapProviderModelRouteErrorToOutcome, scoreComplexity, } from "@kilnai/core";
+import { ProviderModelRouteHealthStore, discoverGuiDirectProviderModelDiscovery, getProjectContextArtifactCache, } from "@kilnai/runtime";
 function resolveMode(flags) {
     if (flags.apiKey && flags.provider)
         return "byok";
@@ -29,6 +44,44 @@ function resolveMode(flags) {
 }
 const DEFAULT_POLICY = { approval: "never", sandbox: "workspace-write" };
 const PLAN_POLICY = { approval: "untrusted", sandbox: "read-only" };
+export function buildRunSessionRequirements(preferredProvider) {
+    return {
+        preferredProvider,
+        requiresMcp: preferredProvider === undefined,
+    };
+}
+export function resolveRunProviderModelAdmission(input) {
+    if (!isDirectApiProvider(input.provider)) {
+        return { ok: true };
+    }
+    const discovery = input.discovery[input.provider];
+    if (!discovery) {
+        return {
+            ok: false,
+            error: `Provider '${input.provider}' is unavailable`,
+        };
+    }
+    if (discovery.status !== "available") {
+        return {
+            ok: false,
+            error: discovery.reason,
+        };
+    }
+    const model = input.model?.trim() ?? "";
+    if (model.length === 0) {
+        return {
+            ok: false,
+            error: `Provider '${input.provider}' requires a selected model.`,
+        };
+    }
+    if (!discovery.models.includes(model)) {
+        return {
+            ok: false,
+            error: `Provider '${input.provider}' does not advertise model '${model}'`,
+        };
+    }
+    return { ok: true };
+}
 function buildConfig(flags, mode) {
     return {
         mode,
@@ -37,8 +90,49 @@ function buildConfig(flags, mode) {
         permissionPolicy: flags.plan ? PLAN_POLICY : (flags.permissionPolicy ?? DEFAULT_POLICY),
     };
 }
+async function resolveAdmittedRunRouteCandidates(input) {
+    const rejectedReasons = [];
+    const directCandidates = input.candidates.filter((candidate) => isDirectApiProvider(candidate.provider));
+    const directDiscovery = directCandidates.length > 0
+        ? await discoverGuiDirectProviderModelDiscovery({
+            ...getRuntimeProviderAvailability(input.registry),
+            ...Object.fromEntries(directCandidates.map((candidate) => [candidate.provider, true])),
+        }, {
+            ...process.env,
+            ...input.env,
+        })
+        : {};
+    const admitted = [];
+    for (const candidate of input.candidates) {
+        if (!isDirectApiProvider(candidate.provider)) {
+            admitted.push(candidate);
+            continue;
+        }
+        const admission = resolveRunProviderModelAdmission({
+            provider: candidate.provider,
+            model: candidate.model,
+            discovery: directDiscovery,
+        });
+        if (!admission.ok) {
+            rejectedReasons.push(`${formatRouteCandidate(candidate)}: ${admission.error}`);
+            continue;
+        }
+        if (candidate.model) {
+            const health = await input.routeHealthStore.evaluateRouteHealth(candidate.provider, candidate.model);
+            if (!health.healthy) {
+                rejectedReasons.push(`${formatRouteCandidate(candidate)}: ${formatProviderModelRouteCooldown(health)}`);
+                continue;
+            }
+        }
+        admitted.push(candidate);
+    }
+    return { candidates: admitted, rejectedReasons };
+}
+function formatRouteCandidate(candidate) {
+    return candidate.model ? `${candidate.provider}/${candidate.model}` : candidate.provider;
+}
 function appendAgentInstructionsToSystemPrompt(appConfig, agent) {
-    const instructions = agent?.instructions?.trim();
+    const instructions = renderAgentProfilePromptContext(agent);
     if (!instructions) {
         return appConfig;
     }
@@ -53,18 +147,42 @@ function appendAgentInstructionsToSystemPrompt(appConfig, agent) {
         },
     };
 }
+function renderAgentProfilePromptContext(agent) {
+    if (!agent) {
+        return undefined;
+    }
+    return [
+        "## Agent Profile",
+        `name: ${agent.name}`,
+        agent.displayName ? `displayName: ${agent.displayName}` : undefined,
+        agent.nicknameCandidates?.length ? `nicknameCandidates: ${agent.nicknameCandidates.join(", ")}` : undefined,
+        `role: ${agent.role}`,
+        agent.description ? `description: ${agent.description}` : undefined,
+        agent.goal ? `goal: ${agent.goal}` : undefined,
+        agent.backstory ? `backstory: ${agent.backstory}` : undefined,
+        agent.tier ? `tier: ${agent.tier}` : undefined,
+        agent.mode ? `mode: ${agent.mode}` : undefined,
+        agent.authorityProfile ? `authorityProfile: ${agent.authorityProfile}` : undefined,
+        agent.routeId ? `routeId: ${agent.routeId}` : undefined,
+        agent.skills?.length ? `skills: ${agent.skills.join(", ")}` : undefined,
+        agent.instructionProfiles?.length ? `instructionProfiles: ${agent.instructionProfiles.join(", ")}` : undefined,
+        agent.instructions ? "instructions:" : undefined,
+        agent.instructions,
+    ].filter((line) => Boolean(line)).join("\n");
+}
 function parseSubmittedPlan(line) {
     try {
         const parsed = JSON.parse(line);
-        const direct = extractSubmitPlan(parsed);
-        if (direct)
-            return direct;
-        const nestedData = (typeof parsed.data === "object" && parsed.data !== null
-            ? parsed.data
-            : undefined);
-        if (!nestedData)
-            return undefined;
-        return extractSubmitPlan(nestedData);
+        if (parsed.kind === "tool_call_started") {
+            const payload = typeof parsed.payload === "object" && parsed.payload !== null
+                ? parsed.payload
+                : undefined;
+            return payload ? extractSubmitPlan(payload) : undefined;
+        }
+        if (parsed.kind === "plan_submitted") {
+            return renderStructuredPlanSummary(parsed.payload);
+        }
+        return undefined;
     }
     catch {
         return undefined;
@@ -82,7 +200,70 @@ function extractSubmitPlan(event) {
         ? event.input
         : undefined;
     const plan = input?.plan;
-    return typeof plan === "string" ? plan : undefined;
+    if (typeof plan === "string") {
+        return plan;
+    }
+    return renderStructuredPlanSummary(input);
+}
+function renderStructuredPlanSummary(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return undefined;
+    }
+    const plan = input;
+    const objective = typeof plan.objective === "string" ? plan.objective.trim() : "";
+    if (!objective) {
+        return undefined;
+    }
+    const list = (value) => Array.isArray(value)
+        ? value.flatMap((entry) => typeof entry === "string" ? [entry.trim()] : []).filter((entry) => entry.length > 0)
+        : [];
+    const recommendation = plan.workGovernanceRecommendation
+        && typeof plan.workGovernanceRecommendation === "object"
+        && !Array.isArray(plan.workGovernanceRecommendation)
+        ? plan.workGovernanceRecommendation
+        : undefined;
+    const proposedWorkItems = Array.isArray(plan.proposedWorkItems)
+        ? plan.proposedWorkItems.filter((entry) => entry && typeof entry === "object" && !Array.isArray(entry))
+        : [];
+    const lines = [
+        objective,
+        typeof plan.riskClassification === "string" ? `- risk: ${plan.riskClassification}` : undefined,
+        typeof recommendation?.posture === "string" ? `- posture: ${recommendation.posture}` : undefined,
+        typeof recommendation?.workflowProfile === "string" ? `- workflow: ${recommendation.workflowProfile}` : undefined,
+        typeof recommendation?.rationale === "string" ? `- governance rationale: ${recommendation.rationale}` : undefined,
+        typeof plan.sourceSpecificationId === "string" ? `- source specification: ${plan.sourceSpecificationId}` : undefined,
+        ...list(plan.clarificationRecordIds).map((clarification) => `- clarification: ${clarification}`),
+        ...list(plan.affectedSurfaces).map((surface) => `- affected surface: ${surface}`),
+        ...list(plan.nonGoals).map((goal) => `- non-goal: ${goal}`),
+        ...list(plan.assumptions).map((assumption) => `- assumption: ${assumption}`),
+        ...list(plan.operatorDecisionsRequired).map((decision) => `- decision: ${decision}`),
+        ...list(plan.expectedEvidence).map((evidence) => `- evidence: ${evidence}`),
+        ...list(plan.verificationGates).map((gate) => `- gate: ${gate}`),
+        ...list(plan.managedAgentDelegationCandidates).map((candidate) => `- delegation candidate: ${candidate}`),
+        ...list(plan.approvalBoundaries).map((boundary) => `- approval boundary: ${boundary}`),
+        typeof plan.rollbackNotes === "string" && plan.rollbackNotes.trim().length > 0
+            ? `- rollback: ${plan.rollbackNotes.trim()}`
+            : undefined,
+        ...list(plan.residualRisks).map((risk) => `- residual risk: ${risk}`),
+        ...proposedWorkItems.flatMap((item) => {
+            const itemId = typeof item.id === "string" ? item.id.trim() : "";
+            const itemSummary = typeof item.summary === "string" ? item.summary.trim() : "";
+            const itemWorkflow = typeof item.workflowProfile === "string" ? item.workflowProfile.trim() : "";
+            const itemRisk = typeof item.risk === "string" ? item.risk.trim() : "";
+            const itemEvidence = list(item.expectedEvidence);
+            const itemGates = list(item.verificationGates);
+            const itemDeps = list(item.dependencies);
+            return [
+                itemSummary || itemId ? `- work item ${itemId || "item"}: ${itemSummary || "(no summary)"}` : undefined,
+                itemWorkflow ? `  workflow: ${itemWorkflow}` : undefined,
+                itemRisk ? `  risk: ${itemRisk}` : undefined,
+                ...itemEvidence.map((evidence) => `  evidence: ${evidence}`),
+                ...itemGates.map((gate) => `  gate: ${gate}`),
+                ...itemDeps.map((dependency) => `  depends on: ${dependency}`),
+            ];
+        }),
+    ].filter((line) => typeof line === "string" && line.length > 0);
+    return lines.join("\n");
 }
 async function readSubmittedPlanFromTranscript(projectPath, sessionId) {
     try {
@@ -144,14 +325,55 @@ export async function runCommand(appConfig, task, flags) {
         }
     }
     const globalConfig = readGlobalConfig();
-    const effectiveModel = resolveEffectiveModel(flags.model, globalConfig?.model) ?? resolvedAgent?.model;
-    const config = buildConfig(flags, mode);
-    const runtimeAppConfig = appendAgentInstructionsToSystemPrompt(appConfig, resolvedAgent);
+    const projectConfig = readKilnYaml(join(cwd, ".kiln"));
+    const resolvedKilnConfig = await loadKilnConfig(cwd);
+    const configuredRouteCandidates = resolveProviderRouteCandidates({
+        globalConfig,
+        flagProvider: flags.provider,
+        flagModel: flags.model,
+        taskText: task,
+        agentTaskAffinity: resolvedAgent?.taskAffinity,
+    }).map((candidate) => (candidate.model || !resolvedAgent?.model
+        ? candidate
+        : { ...candidate, model: resolvedAgent.model }));
+    const preferredProvider = configuredRouteCandidates[0]?.provider;
+    if (flags.requestedAuthority
+        && flags.requestedAuthority !== "auto"
+        && (!preferredProvider || !isDirectApiProvider(preferredProvider))) {
+        console.error("--authority is only supported for direct API providers in CLI run. Use --plan for harness read-only planning.");
+        process.exit(1);
+    }
+    const effectiveModel = configuredRouteCandidates[0]?.model
+        ?? resolveEffectiveModel(flags.model, resolveGlobalDefaultModel(globalConfig))
+        ?? resolvedAgent?.model;
+    const config = buildConfig({ ...flags, provider: preferredProvider }, mode);
+    let identityAppConfig = withWorkGovernanceContext(withGlobalIdentityContext(appConfig, globalConfig), resolvedKilnConfig?.workGovernance);
+    identityAppConfig = withContextCandidates(identityAppConfig, resolveInstructionProfileContextCandidates({
+        projectPath: cwd,
+        globalConfig,
+        projectConfig,
+        agent: resolvedAgent,
+    }));
+    try {
+        identityAppConfig = withContextCandidates(identityAppConfig, resolveAgentSkillContextCandidates(resolvedAgent, cwd, undefined, resolvedKilnConfig?.skills, {
+            task: inferRouteTask({
+                text: task,
+                agentTaskAffinity: resolvedAgent?.taskAffinity,
+            }),
+            provider: preferredProvider,
+            model: effectiveModel,
+            modelTaskSuitability: resolvedKilnConfig?.modelTaskSuitability,
+        }));
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    const runtimeAppConfig = appendAgentInstructionsToSystemPrompt(identityAppConfig, resolvedAgent);
     const sessionId = randomUUID();
     const { registry, worktreeManager } = createDefaultRegistry();
     const contextArtifactCache = await getProjectContextArtifactCache(cwd);
     const manager = new SessionManager(config, runtimeAppConfig, contextArtifactCache, worktreeManager);
-    const preferredProvider = config.provider;
     const resumeSessionId = await resolveResumeSessionId(cwd, flags.resume, preferredProvider);
     const transcriptStore = new TranscriptStore(cwd);
     const resumedMeta = resumeSessionId
@@ -184,14 +406,37 @@ export async function runCommand(appConfig, task, flags) {
     if (config.mode === "byok" && config.provider && config.apiKey) {
         env[`${config.provider.toUpperCase()}_API_KEY`] = config.apiKey;
     }
-    const requirements = {
-        preferredProvider,
-        requiresMcp: !isDirectApiProvider(preferredProvider),
-    };
+    const directRouteHealthStore = configuredRouteCandidates.some((candidate) => isDirectApiProvider(candidate.provider))
+        ? new ProviderModelRouteHealthStore()
+        : undefined;
+    const admittedRoutes = configuredRouteCandidates.length > 0
+        ? await resolveAdmittedRunRouteCandidates({
+            candidates: configuredRouteCandidates,
+            registry,
+            env,
+            routeHealthStore: directRouteHealthStore ?? new ProviderModelRouteHealthStore(),
+        })
+        : { candidates: [], rejectedReasons: [] };
+    if (configuredRouteCandidates.length > 0 && admittedRoutes.candidates.length === 0) {
+        console.error("Error: No configured provider routes are currently available.");
+        for (const reason of admittedRoutes.rejectedReasons) {
+            console.error(`- ${reason}`);
+        }
+        process.exit(1);
+    }
+    const requirements = buildRunSessionRequirements(preferredProvider);
     const startedAt = new Date().toISOString();
+    const initialMetadata = deriveSessionMetadata({
+        task,
+        provider: preferredProvider,
+        model: effectiveModel,
+    });
     await transcriptStore.init(sessionId, {
         kilnSessionId: sessionId,
         provider: preferredProvider ?? "unknown",
+        title: initialMetadata.title,
+        summary: initialMetadata.summary,
+        tags: initialMetadata.tags,
         task,
         startedAt,
         resumeStrategy: context.resumeStrategy,
@@ -206,6 +451,38 @@ export async function runCommand(appConfig, task, flags) {
             .filter((block) => block.kind === "artifact")
             .map((block) => block.content),
     });
+    const configuredBuiltinToolOptions = await loadConfiguredBuiltinToolSurfaceOptions(appConfig, cwd, {
+        memoryAuthority: {
+            modelFacingSession: true,
+            permissionPolicy: config.permissionPolicy,
+            permissionAgent: resolvedAgent?.name,
+            caller: { kind: "operator_surface", id: "run" },
+        },
+    });
+    const workItemStore = new WorkItemStore();
+    const goalRunStore = new GoalRunStore();
+    const builtinToolOptions = createSessionBuiltinToolOptions({
+        ...configuredBuiltinToolOptions,
+        workItemStore,
+        goalRunStore,
+        additionalTools: [
+            ...(configuredBuiltinToolOptions.additionalTools ?? []),
+            ...createKilnConfigTools(cwd),
+            ...createWorkGovernanceTools(resolvedKilnConfig?.workGovernance, { workItemStore, goalRunStore }),
+        ],
+    });
+    const engineAvailability = resolveEngineAvailabilityMap(globalConfig);
+    const managedAgentProviderModels = await discoverManagedAgentProviderModels();
+    const managedInvocationResolution = await resolveManagedInvocationToolOptions(globalConfig, {
+        cwd,
+        registry,
+        surface: "run",
+        isProviderAvailable: (providerId) => engineAvailability.get(providerId),
+        providerModels: managedAgentProviderModels,
+        directAdapterFactory: createManagedDirectProviderAdapterFactory({ builtinToolOptions, runtimeEnv: env }),
+        artifactStore: builtinToolOptions.artifactResources?.store,
+    });
+    const managedInvocation = appConfig.managedInvocation ?? managedInvocationResolution.managedInvocation;
     const sessionConfig = {
         task,
         systemPrompt: context.systemPrompt,
@@ -220,25 +497,46 @@ export async function runCommand(appConfig, task, flags) {
         outputSchema: flags.outputSchema,
         addDir: flags.addDir,
         localProvider: flags.localProvider,
+        builtinToolOptions,
+        managedInvocation,
         model: effectiveModel,
+        reasoningEffort: flags.reasoningEffort,
+        requestedAuthority: flags.requestedAuthority,
     };
     const sessionHooks = new SessionHooks(appConfig.kilnYaml?.hooks, {
         sessionId,
         workingDirectory: context.workingDirectory,
     });
     const approvalMemoryStore = new ApprovalMemoryStoreImpl(cwd);
+    let signalHandlersRegistered = false;
+    let shutdownStarted = false;
+    const unregisterSignalHandlers = () => {
+        if (!signalHandlersRegistered)
+            return;
+        process.off("SIGINT", shutdown);
+        process.off("SIGTERM", shutdown);
+        signalHandlersRegistered = false;
+    };
     const shutdown = () => {
-        void cleanupRegistry.runAll();
+        if (shutdownStarted)
+            return;
+        shutdownStarted = true;
+        unregisterSignalHandlers();
+        void cleanupRegistry.runAll().finally(() => {
+            process.exit(130);
+        });
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
+    signalHandlersRegistered = true;
     sessionHooks.sessionStart();
-    const { finalCostUsd, sessionSucceeded, lastError, accumulatedText, toolCallCount, turnDepth, successfulProviderId, transcript, exactArtifacts, submittedPlan: submittedPlanFromSession, } = await runSession({
+    const { finalCostUsd, sessionSucceeded, lastError, accumulatedText, toolCallCount, turnDepth, successfulProviderId, successfulModelId, attempts, transcript, exactArtifacts, submittedPlan: submittedPlanFromSession, } = await runSession({
         registry,
         cleanupRegistry,
         manager,
         context,
         requirements,
+        routeCandidates: admittedRoutes.candidates.length > 0 ? admittedRoutes.candidates : undefined,
         sessionConfig,
         permissionPolicy: config.permissionPolicy,
         permissionAgent: resolvedAgent?.name,
@@ -246,15 +544,40 @@ export async function runCommand(appConfig, task, flags) {
         approvalMemoryStore,
         env,
         sessionHooks,
+    }).finally(() => {
+        sessionHooks.sessionEnd();
+        unregisterSignalHandlers();
     });
-    sessionHooks.sessionEnd();
+    if (directRouteHealthStore) {
+        for (const attempt of attempts) {
+            if (!isDirectApiProvider(attempt.providerId) || !attempt.model) {
+                continue;
+            }
+            const errorMessage = attempt.error ?? lastError ?? "Provider ended with unknown error";
+            await directRouteHealthStore.recordOutcome({
+                providerId: attempt.providerId,
+                modelId: attempt.model,
+                outcome: attempt.succeeded
+                    ? { type: "ok" }
+                    : mapProviderModelRouteErrorToOutcome(errorMessage),
+                ...(attempt.succeeded ? {} : { errorMessage }),
+            });
+        }
+    }
     try {
         for (const [seq, entry] of transcript.entries()) {
+            const timestamp = "ts" in entry && typeof entry.ts === "string"
+                ? entry.ts
+                : new Date().toISOString();
+            const legacyType = typeof entry.event.type === "string" ? entry.event.type : "assistant_message";
             await transcriptStore.append(sessionId, {
-                seq: seq + 1,
-                ts: "ts" in entry && typeof entry.ts === "string" ? entry.ts : new Date().toISOString(),
-                type: entry.event.type,
-                data: entry.event,
+                eventId: randomUUID(),
+                kilnSessionId: sessionId,
+                sequence: seq + 1,
+                timestamp,
+                kind: mapTranscriptTypeToKind(legacyType),
+                source: mapTranscriptTypeToSource(legacyType),
+                payload: entry.event,
             });
         }
     }
@@ -264,10 +587,13 @@ export async function runCommand(appConfig, task, flags) {
     if (flags.plan && submittedPlanFromSession !== undefined) {
         try {
             await transcriptStore.append(sessionId, {
-                seq: transcript.length + 1,
-                ts: new Date().toISOString(),
-                type: "tool_use",
-                data: {
+                eventId: randomUUID(),
+                kilnSessionId: sessionId,
+                sequence: transcript.length + 1,
+                timestamp: new Date().toISOString(),
+                kind: "tool_call_started",
+                source: { actor: "tool", surface: "cli", component: "run-command" },
+                payload: {
                     type: "tool_use",
                     name: "submit_plan",
                     input: { plan: submittedPlanFromSession },
@@ -286,6 +612,14 @@ export async function runCommand(appConfig, task, flags) {
         const meta = {
             kilnSessionId: sessionId,
             provider: successfulProviderId ?? "unknown",
+            title: initialMetadata.title,
+            summary: initialMetadata.summary,
+            tags: deriveSessionMetadata({
+                task,
+                provider: successfulProviderId ?? preferredProvider,
+                model: successfulModelId ?? effectiveModel,
+                hasFileChanges: exactArtifacts.some((artifact) => /\b(created|modified|deleted|file)\b/i.test(artifact)),
+            }).tags,
             task,
             startedAt,
             completedAt,
@@ -307,52 +641,19 @@ export async function runCommand(appConfig, task, flags) {
         };
         try {
             await transcriptStore.finalize(sessionId, meta);
-            const summaryLines = [
-                `Task: ${task}`,
-                `Phase: completed`,
-                `Provider: ${successfulProviderId ?? "unknown"}`,
-                `Tool calls: ${toolCallCount}`,
-                `Turn depth: ${turnDepth}`,
-                ...(exactArtifacts.length > 0 ? ["Exact artifacts:", ...exactArtifacts.slice(0, 10).map((artifact) => `- ${artifact}`)] : []),
-            ];
-            const now = new Date();
-            const artifact = {
-                key: buildCliSessionSummaryArtifactKey(sessionId),
-                kind: "session-summary",
-                content: summaryLines.join("\n"),
-                createdAt: now,
-                updatedAt: now,
-            };
-            contextArtifactCache.set(artifact);
-            const projectArtifact = {
-                key: buildCliProjectSummaryArtifactKey(cwd),
-                kind: "project-summary",
-                content: [
-                    `Project path: ${cwd}`,
-                    `Domain: ${context.domain.displayName}`,
-                    `Last successful provider: ${successfulProviderId ?? "unknown"}`,
-                    `Latest task: ${task}`,
-                    `Latest turn depth: ${turnDepth}`,
-                ].join("\n"),
-                createdAt: now,
-                updatedAt: now,
-            };
-            contextArtifactCache.set(projectArtifact);
-            const planArtifact = {
-                key: buildCliPlanSummaryArtifactKey(cwd, task, 80),
-                kind: "plan-summary",
-                content: [
-                    `Task pattern: ${task}`,
-                    `Successful provider: ${successfulProviderId ?? "unknown"}`,
-                    `Observed turn depth: ${turnDepth}`,
-                    `Observed tool calls: ${toolCallCount}`,
-                    "Useful exact artifacts:",
-                    ...exactArtifacts.slice(0, 8).map((artifact) => `- ${artifact}`),
-                ].join("\n"),
-                createdAt: now,
-                updatedAt: now,
-            };
-            contextArtifactCache.set(planArtifact);
+            const artifacts = buildCliCompletionContextArtifacts({
+                sessionId,
+                projectPath: cwd,
+                domainDisplayName: context.domain.displayName,
+                task,
+                successfulProviderId,
+                toolCallCount,
+                turnDepth,
+                exactArtifacts,
+            });
+            contextArtifactCache.set(artifacts.sessionArtifact);
+            contextArtifactCache.set(artifacts.projectArtifact);
+            contextArtifactCache.set(artifacts.planArtifact);
             const touchedFiles = extractTouchedFilePaths(exactArtifacts);
             for (const filePath of touchedFiles.slice(0, 5)) {
                 const moduleArtifact = await buildModuleSummaryArtifact(cwd, filePath);
@@ -392,6 +693,9 @@ export async function runCommand(appConfig, task, flags) {
     if (!sessionSucceeded) {
         await transcriptStore.finalize(sessionId, {
             completedAt: new Date().toISOString(),
+            title: initialMetadata.title,
+            summary: initialMetadata.summary,
+            tags: initialMetadata.tags,
             costUsd: finalCostUsd,
             toolCount: toolCallCount,
             turnDepth,
@@ -483,6 +787,37 @@ export async function runCommand(appConfig, task, flags) {
         return;
     }
 }
+function mapTranscriptTypeToKind(type) {
+    switch (type) {
+        case "user":
+            return "user_message";
+        case "text_delta":
+            return "assistant_delta";
+        case "tool_use":
+            return "tool_call_started";
+        case "tool_result":
+            return "tool_call_completed";
+        case "error":
+            return "error_recorded";
+        default:
+            return "assistant_message";
+    }
+}
+function mapTranscriptTypeToSource(type) {
+    switch (type) {
+        case "user":
+            return { actor: "user", surface: "cli", component: "run-command" };
+        case "text_delta":
+            return { actor: "assistant", surface: "cli", component: "run-command" };
+        case "tool_use":
+        case "tool_result":
+            return { actor: "tool", surface: "cli", component: "run-command" };
+        case "error":
+            return { actor: "runtime", surface: "cli", component: "run-command" };
+        default:
+            return { actor: "system", surface: "cli", component: "run-command" };
+    }
+}
 export async function runParallelWorkers(appConfig, task, flags, workerCount, runner = runCommand) {
     const results = await Promise.allSettled(Array.from({ length: workerCount }, async (_, i) => {
         await runner(appConfig, task, { ...flags, workers: 1, isolate: true });