@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

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

@@ -0,0 +1,331 @@
+"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 session_events_1 = require("../../heart/session-events");
+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",
+        (0, session_events_1.capStructuredRecordString)(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", (0, session_events_1.capStructuredRecordString)(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 },
+    });
+}

package/dist/repertoire/coding/feedback.js

@@ -3,9 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCodingTail = formatCodingTail;
 exports.attachCodingSessionFeedback = attachCodingSessionFeedback;
 const identity_1 = require("../../heart/identity");
-const obligations_1 = require("../../heart/obligations");
+const socket_client_1 = require("../../heart/daemon/socket-client");
+const obligations_1 = require("../../arc/obligations");
 const runtime_1 = require("../../nerves/runtime");
 const TERMINAL_UPDATE_KINDS = new Set(["completed", "failed", "killed"]);
+const OBLIGATION_WAKE_UPDATE_KINDS = new Set([
+    "waiting_input",
+    "stalled",
+    "completed",
+    "failed",
+    "killed",
+]);
+const PULL_REQUEST_NUMBER_PATTERN = /\bPR\s*#(\d+)\b/i;
+const PULL_REQUEST_URL_PATTERN = /\/pull\/(\d+)(?:\b|\/)?/i;
 function clip(text, maxLength = 280) {
     const trimmed = text.trim();
     if (trimmed.length <= maxLength)
@@ -49,23 +59,128 @@ function formatSessionLabel(session) {
         : "";
     return `${session.runner} ${session.id}${origin}`;
 }
+function codingFeedbackOriginSessionId(session) {
+    return session.originSession
+        ? `${session.originSession.friendId}/${session.originSession.channel}/${session.originSession.key}`
+        : "detached";
+}
+function buildCodingFeedbackPrivateWakeOptions(input) {
+    return {
+        reason: "coding feedback private attention",
+        triggerSource: "coding-feedback",
+        budgetClass: "interactive",
+        idempotencyKey: `coding-feedback:${input.agentName}:${input.obligationId}:${input.update.session.id}:${input.update.kind}`,
+        originRefs: [
+            { kind: "coding-session", id: input.update.session.id },
+            { kind: "coding-update", id: input.update.kind },
+            { kind: "obligation", id: input.obligationId },
+            { kind: "session", id: codingFeedbackOriginSessionId(input.update.session) },
+        ],
+    };
+}
+function extractPullRequestLabel(snippet) {
+    if (!snippet)
+        return null;
+    const numberMatch = snippet.match(PULL_REQUEST_NUMBER_PATTERN);
+    if (numberMatch)
+        return `PR #${numberMatch[1]}`;
+    const urlMatch = snippet.match(PULL_REQUEST_URL_PATTERN);
+    if (urlMatch)
+        return `PR #${urlMatch[1]}`;
+    return null;
+}
+function isMergedPullRequestSnippet(snippet) {
+    return /\bmerged\b/i.test(snippet) || /\blanded\b/i.test(snippet);
+}
+function deriveObligationMilestone(update) {
+    const snippet = pickUpdateSnippet(update);
+    const pullRequest = extractPullRequestLabel(snippet);
+    if (update.kind === "completed" && snippet && pullRequest && isMergedPullRequestSnippet(snippet)) {
+        return {
+            status: "updating_runtime",
+            currentSurface: { kind: "runtime", label: "ouro up" },
+            currentArtifact: pullRequest,
+            nextAction: "update runtime, verify version/changelog, then re-observe",
+        };
+    }
+    if (update.kind === "completed" && pullRequest) {
+        return {
+            status: "waiting_for_merge",
+            currentSurface: { kind: "merge", label: pullRequest },
+            currentArtifact: pullRequest,
+            nextAction: `wait for checks, merge ${pullRequest}, then update runtime`,
+        };
+    }
+    if (update.kind === "waiting_input") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            nextAction: `answer ${update.session.runner} ${update.session.id} and continue`,
+        };
+    }
+    if (update.kind === "stalled") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            nextAction: `unstick ${update.session.runner} ${update.session.id} and continue`,
+        };
+    }
+    if (update.kind === "progress" || update.kind === "spawned" || update.kind === "failed" || update.kind === "killed" || update.kind === "completed") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+        };
+    }
+    return null;
+}
 function isSafeProgressSnippet(snippet) {
+    const normalized = snippet.trim();
     const wordCount = snippet.split(/\s+/).filter(Boolean).length;
-    return (snippet.length <= 80
+    return (normalized.length <= 80
+        && wordCount >= 2
         && wordCount <= 8
-        && !snippet.includes(":")
-        && !snippet.startsWith("**")
-        && !/^Respond with\b/i.test(snippet)
-        && !/^Coding session metadata\b/i.test(snippet)
-        && !/^sessionId\b/i.test(snippet)
-        && !/^taskRef\b/i.test(snippet)
-        && !/^parentAgent\b/i.test(snippet));
+        && /[A-Za-z]{3,}/.test(normalized)
+        && !normalized.includes(":")
+        && !/[{}\[\]();]/.test(normalized)
+        && !normalized.startsWith("**")
+        && !/^Respond with\b/i.test(normalized)
+        && !/^Coding session metadata\b/i.test(normalized)
+        && !/^sessionId\b/i.test(normalized)
+        && !/^taskRef\b/i.test(normalized)
+        && !/^parentAgent\b/i.test(normalized));
 }
 function pickUpdateSnippet(update) {
-    return (lastMeaningfulLine(update.text)
+    const checkpoint = update.session.checkpoint?.trim() || null;
+    return (checkpoint
+        ?? lastMeaningfulLine(update.text)
         ?? lastMeaningfulLine(update.session.stderrTail)
         ?? lastMeaningfulLine(update.session.stdoutTail));
 }
+function renderValue(text) {
+    const trimmed = text?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : "(empty)";
+}
+function renderPath(text) {
+    return text && text.trim().length > 0 ? text : "(none)";
+}
+function formatCodingTail(session) {
+    const stdout = renderValue(session.stdoutTail);
+    const stderr = renderValue(session.stderrTail);
+    return [
+        `sessionId: ${session.id}`,
+        `runner: ${session.runner}`,
+        `status: ${session.status}`,
+        `checkpoint: ${renderValue(session.checkpoint ?? undefined)}`,
+        `artifactPath: ${renderPath(session.artifactPath)}`,
+        `workdir: ${session.workdir}`,
+        "",
+        "[stdout]",
+        stdout,
+        "",
+        "[stderr]",
+        stderr,
+    ].join("\n");
+}
 function formatUpdateMessage(update) {
     const label = formatSessionLabel(update.session);
     const snippet = pickUpdateSnippet(update);
@@ -86,6 +201,22 @@ function formatUpdateMessage(update) {
             return `${label} started`;
     }
 }
+function formatReportBackMessage(update, baseMessage) {
+    if (!baseMessage)
+        return null;
+    if (!update.session.obligationId || !update.session.originSession) {
+        return baseMessage;
+    }
+    const milestone = deriveObligationMilestone(update);
+    const extraLines = [];
+    if (milestone?.currentArtifact) {
+        extraLines.push(`current artifact: ${milestone.currentArtifact}`);
+    }
+    if (milestone?.nextAction) {
+        extraLines.push(`next: ${milestone.nextAction}`);
+    }
+    return extraLines.length > 0 ? `${baseMessage}\n${extraLines.join("\n")}` : baseMessage;
+}
 function obligationNoteFromUpdate(update) {
     const snippet = pickUpdateSnippet(update);
     switch (update.kind) {
@@ -113,10 +244,13 @@ function syncObligationFromUpdate(update) {
     const obligationId = update.session.obligationId;
     if (!obligationId)
         return;
+    const milestone = deriveObligationMilestone(update);
     try {
         (0, obligations_1.advanceObligation)((0, identity_1.getAgentRoot)(), obligationId, {
-            status: "investigating",
-            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            status: milestone?.status ?? "investigating",
+            currentSurface: milestone?.currentSurface ?? { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            currentArtifact: milestone?.currentArtifact,
+            nextAction: milestone?.nextAction,
             latestNote: obligationNoteFromUpdate(update) ?? undefined,
         });
     }
@@ -124,26 +258,33 @@ function syncObligationFromUpdate(update) {
         // Detached feedback should still reach the human even if obligation sync is unavailable.
     }
 }
-function formatCodingTail(session) {
-    const stdout = session.stdoutTail.trim() || "(empty)";
-    const stderr = session.stderrTail.trim() || "(empty)";
-    return [
-        `sessionId: ${session.id}`,
-        `runner: ${session.runner}`,
-        `status: ${session.status}`,
-        `workdir: ${session.workdir}`,
-        "",
-        "[stdout]",
-        stdout,
-        "",
-        "[stderr]",
-        stderr,
-    ].join("\n");
+async function requestPrivateWakeForObligation(update) {
+    const obligationId = update.session.obligationId;
+    if (!obligationId || !OBLIGATION_WAKE_UPDATE_KINDS.has(update.kind)) {
+        return;
+    }
+    try {
+        const agentName = (0, identity_1.getAgentName)();
+        await (0, socket_client_1.requestPrivateWake)(agentName, undefined, buildCodingFeedbackPrivateWakeOptions({ agentName, obligationId, update }));
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.coding_feedback_wake_error",
+            message: "coding feedback wake request failed",
+            meta: {
+                sessionId: update.session.id,
+                kind: update.kind,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
 }
 function attachCodingSessionFeedback(manager, session, target) {
     let lastMessage = "";
     let closed = false;
-    let unsubscribe = () => { };
+    let unsubscribe = null;
     const sendMessage = (message) => {
         if (closed || !message || message === lastMessage) {
             return;
@@ -164,17 +305,18 @@ function attachCodingSessionFeedback(manager, session, target) {
     };
     const spawnedUpdate = { kind: "spawned", session };
     syncObligationFromUpdate(spawnedUpdate);
-    sendMessage(formatUpdateMessage(spawnedUpdate));
+    sendMessage(formatReportBackMessage(spawnedUpdate, formatUpdateMessage(spawnedUpdate)));
     unsubscribe = manager.subscribe(session.id, async (update) => {
         syncObligationFromUpdate(update);
-        sendMessage(formatUpdateMessage(update));
+        sendMessage(formatReportBackMessage(update, formatUpdateMessage(update)));
+        await requestPrivateWakeForObligation(update);
         if (TERMINAL_UPDATE_KINDS.has(update.kind)) {
             closed = true;
-            unsubscribe();
+            unsubscribe?.();
         }
     });
     return () => {
         closed = true;
-        unsubscribe();
+        unsubscribe?.();
     };
 }

package/dist/repertoire/coding/index.js

@@ -1,19 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatCodingTail = exports.attachCodingSessionFeedback = exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.CodingSessionManager = void 0;
+exports.formatCodingTail = exports.attachCodingSessionFeedback = exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.WorkbenchMcpClient = exports.WorkbenchCodingSessionManager = exports.CodingSessionManager = void 0;
 exports.getCodingSessionManager = getCodingSessionManager;
 exports.resetCodingSessionManager = resetCodingSessionManager;
 const runtime_1 = require("../../nerves/runtime");
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
 const manager_1 = require("./manager");
+const workbench_manager_1 = require("./workbench-manager");
+const workbench_client_1 = require("./workbench-client");
 let manager = null;
 function getCodingSessionManager() {
     if (!manager) {
-        manager = new manager_1.CodingSessionManager({});
+        const config = (0, config_1.loadConfig)();
+        const backend = config.features.workbenchCoding ? "workbench" : "process";
+        manager = config.features.workbenchCoding
+            ? new workbench_manager_1.WorkbenchCodingSessionManager({ agentName: (0, identity_1.getAgentName)(), client: new workbench_client_1.WorkbenchMcpClient() })
+            : new manager_1.CodingSessionManager({});
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
             event: "repertoire.coding_manager_init",
             message: "initialized coding session manager singleton",
-            meta: {},
+            meta: { backend },
         });
     }
     return manager;
@@ -30,6 +38,10 @@ function resetCodingSessionManager() {
 }
 var manager_2 = require("./manager");
 Object.defineProperty(exports, "CodingSessionManager", { enumerable: true, get: function () { return manager_2.CodingSessionManager; } });
+var workbench_manager_2 = require("./workbench-manager");
+Object.defineProperty(exports, "WorkbenchCodingSessionManager", { enumerable: true, get: function () { return workbench_manager_2.WorkbenchCodingSessionManager; } });
+var workbench_client_2 = require("./workbench-client");
+Object.defineProperty(exports, "WorkbenchMcpClient", { enumerable: true, get: function () { return workbench_client_2.WorkbenchMcpClient; } });
 var monitor_1 = require("./monitor");
 Object.defineProperty(exports, "CodingSessionMonitor", { enumerable: true, get: function () { return monitor_1.CodingSessionMonitor; } });
 var reporter_1 = require("./reporter");