@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/repertoire/bundle-templates.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Templates for agent bundle scaffolding.
+ *
+ * ## .gitignore design philosophy
+ *
+ * The bundle .gitignore handles FUNCTIONAL "shouldn't track" cases only:
+ *
+ *   - Runtime state (sessions, logs, runtime files) — stale data with no
+ *     value for review or history.
+ *   - Credentials — real secrets live in the agent vault, but defense
+ *     in depth in case anything leaks into the bundle.
+ *   - Editor / OS noise (.DS_Store, .idea/, etc.).
+ *   - Build artifacts (rare in bundles, but possible).
+ *
+ * It DOES NOT handle PII. The bundle is inherently full of PII — `friends/`,
+ * `diary/`, `journal/`, `psyche/`, `arc/`, `facts/`, `family/`, `travel/`
+ * etc. That's the point of the bundle; blocking those via .gitignore would
+ * defeat the purpose.
+ *
+ * PII is handled at first-push time by `bundle_first_push_review`, which
+ * enumerates PII-bearing directories, shows the agent counts, probes the
+ * remote URL for GitHub visibility, and hard-pauses until the human
+ * confirms. See Directive D in the planning doc.
+ *
+ * No content-pattern blocks (no `**\/sk-ant-*` or similar). Content-review
+ * failures are a different safety layer — credential scanning at commit
+ * time would be a follow-up feature.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PII_BUNDLE_DIRECTORIES = exports.BUNDLE_GITIGNORE_TEMPLATE = void 0;
+exports.BUNDLE_GITIGNORE_TEMPLATE = `# Runtime state — sessions, logs, runtime files, never tracked
+state/
+
+# Credentials — never tracked. Real secrets live in the agent vault, but
+# defense in depth in case anything leaks into the bundle.
+.env
+.env.*
+secrets/
+**/*.key
+**/*.pem
+**/*.credentials
+**/*.pfx
+
+# Editor and OS noise
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Build artifacts (rare in bundles, but possible if a workspace lands here)
+node_modules/
+dist/
+`;
+/**
+ * PII-sensitive top-level directories. Enumerated here so `bundle_first_push_review`
+ * can categorize and count. Adding a new PII bucket to the bundle means adding
+ * it here so the first-push warning includes it.
+ */
+exports.PII_BUNDLE_DIRECTORIES = [
+    "friends",
+    "diary",
+    "journal",
+    "psyche",
+    "arc",
+    "facts",
+    "family",
+    "travel",
+    "notes",
+    "sessions",
+];

package/dist/repertoire/bw-installer.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Lazy bw CLI installer — auto-installs the Bitwarden CLI when not present.
+ *
+ * Mirrors the whisper-cpp pattern in senses/bluebubbles/media.ts:
+ * check PATH first, install via npm if missing, emit nerves event.
+ */
+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.findExecutableOnPath = findExecutableOnPath;
+exports.findExecutableViaNpmPrefix = findExecutableViaNpmPrefix;
+exports.ensureBwCli = ensureBwCli;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const INSTALL_TIMEOUT_MS = 120_000;
+const WHICH_TIMEOUT_MS = 5_000;
+const DEFAULT_WINDOWS_PATHEXT = ".EXE;.CMD;.BAT;.COM";
+function execFileAsync(cmd, args, timeout) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(cmd, args, { timeout }, (err, stdout) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function isExecutableFile(targetPath, platform) {
+    try {
+        fs.accessSync(targetPath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function executableNames(command, platform, pathExt) {
+    if (platform !== "win32")
+        return [command];
+    if (path.extname(command))
+        return [command];
+    const extensions = pathExt
+        .split(";")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return extensions.length === 0
+        ? [command]
+        : extensions.map((extension) => (extension.startsWith(".") ? `${command}${extension}` : `${command}.${extension}`));
+}
+function findExecutableInDirectory(command, directory, platform, pathExt) {
+    const cleanDirectory = stripWrappingQuotes(directory);
+    if (!cleanDirectory)
+        return null;
+    for (const candidateName of executableNames(command, platform, pathExt)) {
+        const candidatePath = path.isAbsolute(candidateName)
+            ? candidateName
+            : path.join(cleanDirectory, candidateName);
+        if (isExecutableFile(candidatePath, platform)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+function findExecutableOnPath(command, envPath = process.env.PATH ?? "", platform = process.platform, pathExt = process.env.PATHEXT ?? DEFAULT_WINDOWS_PATHEXT) {
+    if (path.isAbsolute(command) || command.includes(path.sep)) {
+        return isExecutableFile(command, platform) ? command : null;
+    }
+    for (const directory of envPath.split(path.delimiter)) {
+        const found = findExecutableInDirectory(command, directory, platform, pathExt);
+        if (found)
+            return found;
+    }
+    return null;
+}
+async function findExecutableViaNpmPrefix(command, platform = process.platform, pathExt = process.env.PATHEXT ?? DEFAULT_WINDOWS_PATHEXT) {
+    try {
+        const prefix = stripWrappingQuotes((await execFileAsync("npm", ["prefix", "-g"], WHICH_TIMEOUT_MS)).trim());
+        if (!prefix)
+            return null;
+        const searchDirs = platform === "win32"
+            ? [prefix, path.join(prefix, "bin")]
+            : [path.join(prefix, "bin"), prefix];
+        for (const directory of searchDirs) {
+            const found = findExecutableInDirectory(command, directory, platform, pathExt);
+            if (found)
+                return found;
+        }
+    }
+    catch {
+        // Prefix lookup is only a post-install fallback.
+    }
+    return null;
+}
+/**
+ * Ensure the `bw` CLI is available, installing it via npm if needed.
+ * Returns the path to the `bw` binary.
+ */
+async function ensureBwCli() {
+    // 1. Check if bw is already in PATH
+    const existing = findExecutableOnPath("bw");
+    if (existing) {
+        return existing;
+    }
+    // 2. Install via npm
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.bw_cli_install_start",
+        component: "repertoire",
+        message: "bw CLI not found, installing via npm",
+        meta: {},
+    });
+    try {
+        await execFileAsync("npm", ["install", "-g", "@bitwarden/cli"], INSTALL_TIMEOUT_MS);
+    }
+    catch (err) {
+        /* v8 ignore next -- execFileCb always throws Error instances @preserve */
+        const reason = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "repertoire.bw_cli_install_fail",
+            component: "repertoire",
+            message: "failed to install bw CLI via npm",
+            meta: { reason },
+        });
+        throw new Error(`failed to install bw CLI via npm: ${reason}`);
+    }
+    // 3. Verify installation and return path
+    const installed = findExecutableOnPath("bw") ?? await findExecutableViaNpmPrefix("bw");
+    if (installed) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.bw_cli_install_end",
+            component: "repertoire",
+            message: "bw CLI installed successfully",
+            meta: { path: installed },
+        });
+        return installed;
+    }
+    throw new Error("bw CLI installed via npm but binary not found in PATH or npm global bin");
+}

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 },
+    });
+}