@ouro.bot/cli 0.1.0-alpha.22 → 0.1.0-alpha.220

package/dist/repertoire/bitwarden-client.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Bitwarden vault client for credential management.
+ *
+ * SDK-first approach: attempts dynamic import of @bitwarden/sdk-napi,
+ * falls back to `bw` CLI with --session flag.
+ *
+ * Raw secrets are NEVER returned to callers except via getRawSecret(),
+ * which is reserved for internal use by the credential gateway (apiRequest vaultKey).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitwardenClient = void 0;
+exports.getBitwardenClient = getBitwardenClient;
+exports.resetBitwardenClient = resetBitwardenClient;
+const child_process_1 = require("child_process");
+const runtime_1 = require("../nerves/runtime");
+class BitwardenClient {
+    sessionKey = null;
+    connected = false;
+    clientMode = null;
+    async connect(config) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.vault_connect_start",
+            component: "clients",
+            message: "connecting to Bitwarden vault",
+            meta: { mode: config.mode ?? "auto" },
+        });
+        try {
+            if (config.mode === "cli") {
+                await this.connectCli(config);
+            }
+            else {
+                // Try SDK first, fall back to CLI
+                try {
+                    await this.connectSdk(config);
+                }
+                catch {
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "client.vault_sdk_fallback",
+                        component: "clients",
+                        message: "SDK not available, falling back to bw CLI",
+                        meta: {},
+                    });
+                    await this.connectCli(config);
+                }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                event: "client.vault_connect_end",
+                component: "clients",
+                message: "connected to Bitwarden vault",
+                meta: { mode: this.clientMode },
+            });
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.vault_connect_error",
+                component: "clients",
+                message: "failed to connect to Bitwarden vault",
+                /* v8 ignore next -- defensive: execCli always wraps in Error @preserve */
+                meta: { reason: err instanceof Error ? err.message : String(err) },
+            });
+            throw err;
+        }
+    }
+    async disconnect() {
+        this.sessionKey = null;
+        this.connected = false;
+        this.clientMode = null;
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.vault_disconnect",
+            component: "clients",
+            message: "disconnected from Bitwarden vault",
+            meta: {},
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async getItem(id) {
+        this.requireConnected();
+        return this.withNervesEvents("getItem", { id }, async () => {
+            const raw = await this.fetchRawItem(id);
+            return this.stripSecrets(raw);
+        });
+    }
+    async createItem(name, fields) {
+        this.requireConnected();
+        return this.withNervesEvents("createItem", { name }, async () => {
+            const itemFields = Object.entries(fields).map(([k, v]) => ({
+                name: k,
+                value: v,
+                type: 0, // text type
+            }));
+            const itemTemplate = {
+                type: 1, // login type
+                name,
+                fields: itemFields,
+                login: {},
+            };
+            const encoded = Buffer.from(JSON.stringify(itemTemplate)).toString("base64");
+            const stdout = await this.execCli(["create", "item", encoded]);
+            const parsed = this.parseCliResponse(stdout);
+            return { id: parsed.id, name: parsed.name, type: parsed.type };
+        });
+    }
+    async listItems(search) {
+        this.requireConnected();
+        return this.withNervesEvents("listItems", { search }, async () => {
+            const args = ["list", "items"];
+            if (search) {
+                args.push("--search", search);
+            }
+            const stdout = await this.execCli(args);
+            const parsed = this.parseCliResponse(stdout);
+            const items = Array.isArray(parsed.data) ? parsed.data : (Array.isArray(parsed) ? parsed : []);
+            return items.map((item) => ({ id: item.id, name: item.name, type: item.type }));
+        });
+    }
+    async deleteItem(id) {
+        this.requireConnected();
+        return this.withNervesEvents("deleteItem", { id }, async () => {
+            await this.execCli(["delete", "item", id]);
+        });
+    }
+    /**
+     * Internal: used by credential gateway (PR 5) to get raw secret for HTTP injection.
+     * NOT exposed via tools -- only called by apiRequest() internally.
+     */
+    async getRawSecret(itemId, fieldName) {
+        this.requireConnected();
+        return this.withNervesEvents("getRawSecret", { itemId, fieldName }, async () => {
+            const raw = await this.fetchRawItem(itemId);
+            // Check custom fields first
+            if (raw.fields) {
+                const field = raw.fields.find((f) => f.name === fieldName);
+                if (field)
+                    return field.value;
+            }
+            // Check login.password
+            if (fieldName === "password" && raw.login?.password) {
+                return raw.login.password;
+            }
+            throw new Error(`field "${fieldName}" not found on vault item "${itemId}"`);
+        });
+    }
+    // --- Private methods ---
+    requireConnected() {
+        if (!this.connected) {
+            throw new Error("vault not connected -- call connect() first");
+        }
+    }
+    async withNervesEvents(operation, meta, fn) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: `vault ${operation} starting`,
+            meta: { operation, ...meta },
+        });
+        try {
+            const result = await fn();
+            (0, runtime_1.emitNervesEvent)({
+                event: "client.request_end",
+                component: "clients",
+                message: `vault ${operation} complete`,
+                meta: { operation, ...meta },
+            });
+            return result;
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: `vault ${operation} failed`,
+                /* v8 ignore next -- defensive: callers always throw Error instances @preserve */
+                meta: { operation, reason: err instanceof Error ? err.message : String(err), ...meta },
+            });
+            throw err;
+        }
+    }
+    async connectSdk(_config) {
+        // Attempt dynamic import of SDK
+        // This will throw if the package is not installed
+        const sdk = await Promise.resolve(`${"@bitwarden/sdk-napi"}`).then(s => __importStar(require(s)));
+        /* v8 ignore start -- SDK not yet published; path tested when package becomes available @preserve */
+        const client = new sdk.BitwardenClient({ apiUrl: _config.serverUrl ?? "https://api.bitwarden.com" }, 0);
+        await client.auth().loginAccessToken(_config.accessToken, "");
+        this.connected = true;
+        this.clientMode = "sdk";
+        /* v8 ignore stop */
+    }
+    async connectCli(config) {
+        this.sessionKey = config.accessToken;
+        // Verify CLI is available and session key works
+        await this.execCli(["status"]);
+        this.connected = true;
+        this.clientMode = "cli";
+    }
+    async fetchRawItem(id) {
+        const stdout = await this.execCli(["get", "item", id]);
+        const parsed = this.parseCliResponse(stdout);
+        return parsed;
+    }
+    stripSecrets(raw) {
+        const item = {
+            id: raw.id,
+            name: raw.name,
+            type: raw.type,
+        };
+        if (raw.notes)
+            item.notes = raw.notes;
+        if (raw.fields)
+            item.fields = raw.fields;
+        if (raw.login) {
+            item.login = {};
+            if (raw.login.username)
+                item.login.username = raw.login.username;
+            if (raw.login.uris)
+                item.login.uris = raw.login.uris;
+            // password intentionally NOT copied
+        }
+        return item;
+    }
+    parseCliResponse(stdout) {
+        const parsed = JSON.parse(stdout);
+        // bw CLI with --response wraps in { success, data }
+        if (parsed.success !== undefined && parsed.data !== undefined) {
+            return parsed.data;
+        }
+        return parsed;
+    }
+    execCli(args) {
+        return new Promise((resolve, reject) => {
+            const fullArgs = [...args, "--session", this.sessionKey, "--response"];
+            (0, child_process_1.execFile)("bw", fullArgs, { timeout: 30_000 }, (err, stdout, _stderr) => {
+                if (err) {
+                    reject(new Error(`bw CLI error: ${err.message}`));
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    }
+}
+exports.BitwardenClient = BitwardenClient;
+// Singleton accessor
+let _client = null;
+function getBitwardenClient() {
+    if (!_client) {
+        _client = new BitwardenClient();
+    }
+    return _client;
+}
+function resetBitwardenClient() {
+    _client = null;
+}

package/dist/repertoire/coding/codex-jsonl.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Codex JSONL event parser.
+ * Parses typed events from Codex --json output:
+ * thread.started, turn.started, turn.completed, item.completed.
+ * Maps events to coding session status transitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodexJsonlEvent = parseCodexJsonlEvent;
+const runtime_1 = require("../../nerves/runtime");
+const KNOWN_TYPES = new Set(["thread.started", "turn.started", "turn.completed", "item.completed"]);
+/**
+ * Parse a single JSONL line from Codex --json output.
+ * Returns null for invalid JSON, empty strings, or unknown event types.
+ */
+function parseCodexJsonlEvent(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.codex_jsonl_parse_error",
+            message: "failed to parse codex JSONL line",
+            meta: { line: trimmed.slice(0, 100) },
+        });
+        return null;
+    }
+    const type = parsed.type;
+    if (!type || !KNOWN_TYPES.has(type))
+        return null;
+    const event = {
+        type: type,
+        threadId: typeof parsed.thread_id === "string" ? parsed.thread_id : undefined,
+        turnId: typeof parsed.turn_id === "string" ? parsed.turn_id : undefined,
+        item: typeof parsed.item === "object" && parsed.item !== null ? parsed.item : undefined,
+        raw: parsed,
+        statusHint: mapStatusHint(type),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.codex_jsonl_event",
+        message: "parsed codex JSONL event",
+        meta: { type, threadId: event.threadId ?? null },
+    });
+    return event;
+}
+function mapStatusHint(type) {
+    switch (type) {
+        case "thread.started":
+        case "turn.started":
+            return "running";
+        case "turn.completed":
+        case "item.completed":
+            return null; // No automatic status change for completion events
+        /* v8 ignore next -- defensive default for unknown event types */
+        default:
+            return null;
+    }
+}

package/dist/repertoire/coding/context-pack.js

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareCodingContextPack = prepareCodingContextPack;
+exports.emitCodingEpisode = emitCodingEpisode;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const active_work_1 = require("../../heart/active-work");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const episodes_1 = require("../../arc/episodes");
+const skills_1 = require("../skills");
+const CONTEXT_FILENAMES = ["AGENTS.md", "CLAUDE.md"];
+function defaultRunCommand(command, args, cwd) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        cwd,
+        encoding: "utf-8",
+    });
+    return {
+        status: result.status ?? 1,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function stableContextKey(request) {
+    const payload = JSON.stringify({
+        runner: request.runner,
+        workdir: request.workdir,
+        taskRef: request.taskRef ?? "",
+        parentAgent: request.parentAgent ?? "",
+        obligationId: request.obligationId ?? "",
+        originSession: request.originSession ?? null,
+    });
+    return crypto.createHash("sha1").update(payload).digest("hex").slice(0, 12);
+}
+function collectProjectContextFiles(workdir, deps) {
+    const files = [];
+    const seen = new Set();
+    let current = path.resolve(workdir);
+    const root = path.parse(current).root;
+    while (true) {
+        for (const filename of CONTEXT_FILENAMES) {
+            const candidate = path.join(current, filename);
+            if (!deps.existsSync(candidate) || seen.has(candidate))
+                continue;
+            try {
+                const content = deps.readFileSync(candidate, "utf-8").trim();
+                if (content.length > 0) {
+                    files.unshift({ path: candidate, content });
+                    seen.add(candidate);
+                }
+            }
+            catch {
+                // Best-effort loading only.
+            }
+        }
+        if (current === root)
+            break;
+        current = path.dirname(current);
+    }
+    return files;
+}
+function captureRepoSnapshot(workdir, runCommand) {
+    const repoRoot = runCommand("git", ["rev-parse", "--show-toplevel"], workdir);
+    if (repoRoot.status !== 0) {
+        return {
+            available: false,
+            repoRoot: null,
+            branch: null,
+            head: null,
+            statusLines: [],
+        };
+    }
+    const branch = runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], workdir);
+    const head = runCommand("git", ["rev-parse", "--short", "HEAD"], workdir);
+    const status = runCommand("git", ["status", "--short"], workdir);
+    return {
+        available: true,
+        repoRoot: repoRoot.stdout.trim() || null,
+        branch: branch.status === 0 ? branch.stdout.trim() || null : null,
+        head: head.status === 0 ? head.stdout.trim() || null : null,
+        statusLines: status.status === 0
+            ? status.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean)
+            : [],
+    };
+}
+function buildIdentityPacket(snapshot, request) {
+    if (!snapshot.available) {
+        return {
+            repoPath: null,
+            worktreePath: null,
+            branch: null,
+            commit: null,
+            dirty: false,
+            dirtyFiles: [],
+            taskRef: request.taskRef ?? null,
+            verificationCommands: request.verificationCommands ?? [],
+            verificationStatus: "not-verified",
+        };
+    }
+    const dirtyFiles = snapshot.statusLines.filter((line) => line.length > 0);
+    return {
+        repoPath: snapshot.repoRoot,
+        worktreePath: snapshot.repoRoot,
+        branch: snapshot.branch,
+        commit: snapshot.head,
+        dirty: dirtyFiles.length > 0,
+        dirtyFiles,
+        taskRef: request.taskRef ?? null,
+        verificationCommands: request.verificationCommands ?? [],
+        verificationStatus: "not-verified",
+    };
+}
+function formatIdentitySection(packet) {
+    const lines = [
+        "## Coding Identity",
+        `repoPath: ${packet.repoPath ?? "unknown"}`,
+        `worktreePath: ${packet.worktreePath ?? "unknown"}`,
+        `branch: ${packet.branch ?? "unknown"}`,
+        `commit: ${packet.commit ?? "unknown"}`,
+        `dirty: ${packet.dirty}`,
+    ];
+    if (packet.dirtyFiles.length > 0) {
+        lines.push("dirtyFiles:");
+        for (const file of packet.dirtyFiles) {
+            lines.push(file);
+        }
+    }
+    lines.push(`taskRef: ${packet.taskRef ?? "none"}`);
+    if (packet.verificationCommands.length > 0) {
+        lines.push(`verificationCommands: ${packet.verificationCommands.join(", ")}`);
+    }
+    lines.push(`verificationStatus: ${packet.verificationStatus}`);
+    return lines.join("\n");
+}
+function formatContextFiles(files) {
+    if (files.length === 0)
+        return "(none found)";
+    return files.map((file) => `### ${file.path}\n${file.content}`).join("\n\n");
+}
+function formatSkills(skills) {
+    return skills.length > 0 ? skills.join(", ") : "(none found)";
+}
+function formatExistingSessions(sessions) {
+    if (sessions.length === 0)
+        return "activeSessions: none";
+    return sessions
+        .map((session) => {
+        return [
+            `- ${session.id}`,
+            `status=${session.status}`,
+            `lastActivityAt=${session.lastActivityAt}`,
+            session.taskRef ? `taskRef=${session.taskRef}` : null,
+            session.checkpoint ? `checkpoint=${session.checkpoint}` : null,
+            session.artifactPath ? `artifact=${session.artifactPath}` : null,
+        ].filter(Boolean).join(" ");
+    })
+        .join("\n");
+}
+function formatOrigin(request) {
+    if (!request.originSession)
+        return "originSession: none";
+    return `originSession: ${request.originSession.channel}/${request.originSession.key} (${request.originSession.friendId})`;
+}
+function buildScopeContent(request, contextFiles, skills, agentName) {
+    return [
+        "# Coding Session Scope",
+        "",
+        "## Request",
+        `runner: ${request.runner}`,
+        `taskRef: ${request.taskRef ?? "unassigned"}`,
+        `parentAgent: ${request.parentAgent ?? agentName}`,
+        `workdir: ${request.workdir}`,
+        formatOrigin(request),
+        `obligationId: ${request.obligationId ?? "none"}`,
+        "",
+        "## Prompt",
+        request.prompt,
+        "",
+        "## Session Contract",
+        "- This is a focused coding lane opened by the parent Ouro agent.",
+        "- Execute the concrete prompt in the supplied workdir directly.",
+        "- Do not switch into planning/doing workflows or approval gates unless the prompt explicitly asks for them.",
+        "- Treat the current prompt, scope file, and live world-state checkpoint in the state file as the authoritative briefing for this lane.",
+        "",
+        "## Project Context Files",
+        formatContextFiles(contextFiles),
+        "",
+        "## Available Bundle Skills",
+        formatSkills(skills),
+    ].join("\n");
+}
+function buildStateContent(request, contextKey, generatedAt, snapshot, existingSessions, agentName, identityPacket, activeWorkFrame, startOfTurnPacket) {
+    const gitSection = snapshot.available
+        ? [
+            `repoRoot: ${snapshot.repoRoot ?? "unknown"}`,
+            `branch: ${snapshot.branch ?? "unknown"}`,
+            `head: ${snapshot.head ?? "unknown"}`,
+            "status:",
+            snapshot.statusLines.length > 0 ? snapshot.statusLines.join("\n") : "(clean)",
+        ].join("\n")
+        : "git: unavailable";
+    return [
+        "# Coding Session State",
+        `generatedAt: ${generatedAt}`,
+        `contextKey: ${contextKey}`,
+        `agent: ${request.parentAgent ?? agentName}`,
+        formatOrigin(request),
+        `obligationId: ${request.obligationId ?? "none"}`,
+        ...(startOfTurnPacket ? ["", "## Continuity", startOfTurnPacket] : []),
+        "",
+        formatIdentitySection(identityPacket),
+        "",
+        "## Workspace Snapshot",
+        gitSection,
+        ...(activeWorkFrame ? ["", (0, active_work_1.formatLiveWorldStateCheckpoint)(activeWorkFrame)] : []),
+        "",
+        "## Related Coding Sessions",
+        formatExistingSessions(existingSessions),
+    ].join("\n");
+}
+function relatedSessions(request, existingSessions) {
+    return existingSessions.filter((session) => {
+        return session.runner === request.runner
+            && session.workdir === request.workdir
+            && session.taskRef === request.taskRef;
+    });
+}
+function prepareCodingContextPack(input, deps = {}) {
+    const agentRoot = deps.agentRoot ?? (0, identity_1.getAgentRoot)();
+    const agentName = deps.agentName ?? (0, identity_1.getAgentName)();
+    const nowIso = deps.nowIso ?? (() => new Date().toISOString());
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const listAvailableSkills = deps.listSkills ?? skills_1.listSkills;
+    const runCommand = deps.runCommand ?? defaultRunCommand;
+    const contextKey = stableContextKey(input.request);
+    const contextDir = path.join(agentRoot, "state", "coding", "context");
+    const scopeFile = path.join(contextDir, `${contextKey}-scope.md`);
+    const stateFile = path.join(contextDir, `${contextKey}-state.md`);
+    const contextFiles = collectProjectContextFiles(input.request.workdir, { existsSync, readFileSync });
+    const skills = listAvailableSkills();
+    const existingSessions = relatedSessions(input.request, input.existingSessions ?? []);
+    const snapshot = captureRepoSnapshot(input.request.workdir, runCommand);
+    const generatedAt = nowIso();
+    const identityPacket = buildIdentityPacket(snapshot, input.request);
+    const scopeContent = buildScopeContent(input.request, contextFiles, skills, agentName);
+    const stateContent = buildStateContent(input.request, contextKey, generatedAt, snapshot, existingSessions, agentName, identityPacket, input.activeWorkFrame, input.startOfTurnPacket || undefined);
+    mkdirSync(contextDir, { recursive: true });
+    writeFileSync(scopeFile, `${scopeContent}\n`, "utf-8");
+    writeFileSync(stateFile, `${stateContent}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_context_pack_written",
+        message: "prepared coding session context pack",
+        meta: {
+            contextKey,
+            workdir: input.request.workdir,
+            taskRef: input.request.taskRef ?? null,
+            contextFiles: contextFiles.length,
+            skills: skills.length,
+            relatedSessions: existingSessions.length,
+            gitAvailable: snapshot.available,
+        },
+    });
+    return {
+        contextKey,
+        scopeFile,
+        stateFile,
+        scopeContent,
+        stateContent,
+        identityPacket,
+    };
+}
+/**
+ * Emit a coding milestone episode when a session completes or blocks.
+ * This is the outbound leg of the coding round-trip: compact start-of-turn packet goes IN,
+ * episodes come BACK OUT.
+ */
+function emitCodingEpisode(agentRoot, session, outcome) {
+    (0, episodes_1.emitEpisode)(agentRoot, {
+        kind: "coding_milestone",
+        summary: `coding session ${session.id} (${session.runner}): ${outcome}`,
+        whyItMattered: `coding lane ${session.status}`,
+        relatedEntities: [`coding:${session.id}`],
+        salience: session.status === "failed" ? "high" : "medium",
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_episode_emitted",
+        message: `coding episode emitted for ${session.id}`,
+        meta: { sessionId: session.id, outcome, status: session.status },
+    });
+}