@ouro.bot/cli 0.1.0-alpha.724 → 0.1.0-alpha.725

package/dist/mind/obligation-steering.js

@@ -10,6 +10,12 @@ exports.renderExactStatusReplyContract = renderExactStatusReplyContract;
 const config_1 = require("../heart/config");
 const active_work_1 = require("../heart/active-work");
 const runtime_1 = require("../nerves/runtime");
+const orientation_frame_1 = require("../heart/orientation-frame");
+function labelSteeringSurface(surface, options) {
+    return typeof options?.resumePriorWork === "boolean"
+        ? (0, orientation_frame_1.labelPriorWorkSurface)(surface, options.resumePriorWork)
+        : surface;
+}
 function findActivePersistentObligation(frame) {
     if (!frame)
         return null;
@@ -47,7 +53,7 @@ function findCurrentSessionStatusObligation(frame) {
         .sort(newestObligationFirst);
     return openObligations.find((obligation) => matchesCurrentSession(frame, obligation)) ?? null;
 }
-function renderActiveObligationSteering(obligation) {
+function renderActiveObligationSteering(obligation, options) {
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.obligation_steering_rendered",
@@ -63,10 +69,10 @@ function renderActiveObligationSteering(obligation) {
     const surfaceLine = obligation.currentSurface?.label
         ? `\nright now that work is happening in ${obligation.currentSurface.label}.`
         : "";
-    return `## where my attention is
+    return labelSteeringSurface(`## where my attention is
 i'm already working on something i owe ${name}.${surfaceLine}
 
-i should close that loop before i act like this is a fresh blank turn.`;
+i should close that loop before i act like this is a fresh blank turn.`, options);
 }
 function mergeArtifactFallback(obligation) {
     const trimmed = obligation.content.trim();
@@ -141,7 +147,7 @@ function formatNextAction(frame, obligation) {
     }
     return obligation ? "continue the active loop and bring the result back here" : "";
 }
-function renderConcreteStatusGuidance(frame, obligation) {
+function renderConcreteStatusGuidance(frame, obligation, options) {
     const activeLane = obligation ? formatActiveLane(frame, obligation) : "";
     const currentArtifact = formatCurrentArtifact(frame, obligation);
     const nextAction = formatNextAction(frame, obligation);
@@ -150,19 +156,19 @@ function renderConcreteStatusGuidance(frame, obligation) {
         : "";
     if (!activeLane && !currentArtifact && !nextAction)
         return "";
-    return `if someone asks what i'm doing or for status mid-task, i answer from these live facts instead of copying a canned block.
+    return labelSteeringSurface(`if someone asks what i'm doing or for status mid-task, i answer from these live facts instead of copying a canned block.
 the live conversation is ${liveConversation || "not in a live conversation"}.
 the active lane is ${activeLane}.
 the current artifact is ${currentArtifact}.
 if i just finished or verified something concrete in this live lane, i name that as the latest checkpoint.
 the next action is ${nextAction}.
 
-i answer naturally from those facts instead of forcing a canned status block.`;
+i answer naturally from those facts instead of forcing a canned status block.`, options);
 }
-function renderLiveThreadStatusShape(frame) {
+function renderLiveThreadStatusShape(frame, options) {
     if (!frame.currentSession)
         return "";
-    return `if someone asks what i'm doing or for status mid-task in this live thread, i answer in these exact lines, in order, with no intro paragraph:
+    return labelSteeringSurface(`if someone asks what i'm doing or for status mid-task in this live thread, i answer in these exact lines, in order, with no intro paragraph:
 live conversation: ${frame.currentSession.channel}/${frame.currentSession.key}
 active lane: this same thread
 current artifact: <actual artifact or "no artifact yet">
@@ -172,7 +178,7 @@ next action: <smallest concrete next step i'm taking now>
 no recap paragraph before those lines.
 no option list.
 present tense only.
-if a finished step matters, i label it "just finished" instead of presenting it as current work.`;
+if a finished step matters, i label it "just finished" instead of presenting it as current work.`, options);
 }
 function buildExactStatusReply(frame, obligation, latestCheckpoint, statusCheckScope) {
     const headerObligation = statusCheckScope === "all-sessions-family"

package/dist/mind/prompt.js

@@ -767,26 +767,56 @@ function bridgeContextSection(options) {
     const bridgeContext = options?.bridgeContext?.trim() ?? "";
     if (!bridgeContext)
         return "";
-    return bridgeContext.startsWith("## ") ? bridgeContext : `## active bridge work\n${bridgeContext}`;
+    const surface = bridgeContext.startsWith("## ") ? bridgeContext : `## active bridge work\n${bridgeContext}`;
+    return (0, orientation_frame_1.labelPriorWorkSurface)(surface, options?.resumePriorWork === true);
 }
 function startOfTurnPacketSection(options) {
-    return options?.startOfTurnPacket ?? "";
+    const packet = options?.startOfTurnPacket ?? "";
+    if (!packet)
+        return "";
+    const instruction = options?.resumePriorWork === true
+        ? orientation_frame_1.EXPLICIT_PRIOR_WORK_RESUME_INSTRUCTION
+        : orientation_frame_1.BACKGROUND_ONLY_INSTRUCTION;
+    const lines = packet.split("\n");
+    if (lines.some((line) => line === orientation_frame_1.BACKGROUND_ONLY_INSTRUCTION || line === orientation_frame_1.EXPLICIT_PRIOR_WORK_RESUME_INSTRUCTION)) {
+        return lines
+            .map((line) => line === orientation_frame_1.BACKGROUND_ONLY_INSTRUCTION || line === orientation_frame_1.EXPLICIT_PRIOR_WORK_RESUME_INSTRUCTION
+            ? instruction
+            : line)
+            .join("\n");
+    }
+    return (0, orientation_frame_1.labelPriorWorkSurface)(packet, options?.resumePriorWork === true);
 }
 function arcResumeSection(options) {
-    return options?.flightRecorderResume ? (0, flight_recorder_1.formatFlightRecorderResume)(options.flightRecorderResume) : "";
-}
-function orientationFrameSection(options) {
-    return options?.orientationFrame ? (0, orientation_frame_1.renderOrientationFrame)(options.orientationFrame) : "";
+    if (!options?.flightRecorderResume)
+        return "";
+    return (0, orientation_frame_1.labelPriorWorkSurface)((0, flight_recorder_1.formatFlightRecorderResume)(options.flightRecorderResume), options.resumePriorWork === true);
+}
+function currentTriggerSection(channel, options) {
+    const frame = options?.orientationFrame ?? {
+        schemaVersion: 1,
+        channel,
+        currentUserSpeech: [],
+        priorAssistantReferents: [],
+        signals: [],
+        actionPolicy: { mode: "normal" },
+    };
+    return (0, orientation_frame_1.renderOrientationFrame)(frame);
 }
 function activeWorkSection(options) {
     if (!options?.activeWorkFrame)
         return "";
-    return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame, { obligationDetailsRenderedElsewhere: !!options?.startOfTurnPacket });
+    return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame, {
+        obligationDetailsRenderedElsewhere: !!options?.startOfTurnPacket,
+        resumePriorWork: options.resumePriorWork === true,
+    });
 }
 function liveWorldStateSection(options) {
     if (!options?.activeWorkFrame)
         return "";
-    return (0, active_work_1.formatLiveWorldStateCheckpoint)(options.activeWorkFrame);
+    return (0, active_work_1.formatLiveWorldStateCheckpoint)(options.activeWorkFrame, {
+        resumePriorWork: options.resumePriorWork === true,
+    });
 }
 function pendingMessagesSection(options) {
     const pending = options?.pendingMessages;
@@ -936,13 +966,13 @@ function familyCrossSessionTruthSection(context, options) {
         return "";
     // When start-of-turn packet is present, compress to one line
     if (options?.startOfTurnPacket) {
-        return "When family asks whole-self status, answer from the cross-session picture above.";
+        return (0, orientation_frame_1.labelPriorWorkSurface)("When family asks whole-self status, answer from the cross-session picture above.", options.resumePriorWork === true);
     }
-    return `## cross-session truth
+    return (0, orientation_frame_1.labelPriorWorkSurface)(`## cross-session truth
 When family asks what I'm up to or how things are going, I answer from the live world-state across visible sessions and lanes, not just the current thread.
 When live state conflicts with older transcript history, live state wins.
 I say what I can see, what is active, and what the next concrete step is.
-If part of the picture is still unclear, I say so plainly and note what still needs checking.`;
+If part of the picture is still unclear, I say so plainly and note what still needs checking.`, options.resumePriorWork === true);
 }
 function centerOfGravitySteeringSection(channel, options, context) {
     if (channel === "inner")
@@ -951,19 +981,21 @@ function centerOfGravitySteeringSection(channel, options, context) {
     if (!frame)
         return "";
     const cog = frame.centerOfGravity;
+    const labelSurface = (surface) => (0, orientation_frame_1.labelPriorWorkSurface)(surface, options?.resumePriorWork === true);
+    const steeringOptions = { resumePriorWork: options?.resumePriorWork === true };
     const job = frame.inner?.job;
     const activeObligation = (0, obligation_steering_1.findActivePersistentObligation)(frame);
     const statusObligation = (0, obligation_steering_1.findStatusObligation)(frame);
-    const genericConcreteStatus = (0, obligation_steering_1.renderConcreteStatusGuidance)(frame, statusObligation);
+    const genericConcreteStatus = (0, obligation_steering_1.renderConcreteStatusGuidance)(frame, statusObligation, steeringOptions);
     const liveWorldClause = context?.friend?.trustLevel === "family"
         ? "\nmy center of gravity lives in the active-work world-state above. private-runtime work is one lane inside it, not the whole picture.\nwhen that world-state conflicts with older transcript history, the world-state wins."
         : "";
     if (cog === "local-turn") {
-        return genericConcreteStatus || (0, obligation_steering_1.renderLiveThreadStatusShape)(frame);
+        return genericConcreteStatus || (0, obligation_steering_1.renderLiveThreadStatusShape)(frame, steeringOptions);
     }
     if (cog === "inward-work") {
         if (activeObligation) {
-            return `${(0, obligation_steering_1.renderActiveObligationSteering)(activeObligation)}${liveWorldClause}
+            return `${(0, obligation_steering_1.renderActiveObligationSteering)(activeObligation, steeringOptions)}${liveWorldClause}
 
 ${genericConcreteStatus}`;
         }
@@ -974,21 +1006,21 @@ ${genericConcreteStatus}`;
             const obligationClause = job.obligationStatus === "pending"
                 ? "\ni still owe them an answer."
                 : "";
-            return `## where my attention is
+            return labelSurface(`## where my attention is
 i'm thinking through something privately right now.${originClause}${obligationClause}${liveWorldClause}
 
 if this conversation connects to that private-runtime work, i can weave them together.
-if it's separate, i can be fully present here -- my private-runtime work will wait.`;
+if it's separate, i can be fully present here -- my private-runtime work will wait.`);
         }
         /* v8 ignore start -- surfaced/idle/shared branches tested in prompt-steering.test.ts; CI module caching prevents attribution @preserve */
         if (job?.status === "surfaced") {
             const originClause = job.origin
                 ? ` this started when ${job.origin.friendName ?? job.origin.friendId} asked about something.`
                 : "";
-            return `## where my attention is
+            return labelSurface(`## where my attention is
 i've been thinking privately and reached something.${originClause}${liveWorldClause}
 
-i should bring my answer back to the conversation it came from.`;
+i should bring my answer back to the conversation it came from.`);
         }
         const liveCodingSession = frame.codingSessions?.[0];
         if (liveCodingSession) {
@@ -1009,25 +1041,25 @@ after i name this lane, i widen back out with:
 other active sessions:
 ${otherSessionLines.length > 0 ? otherSessionLines.join("\n") : "- none"}`
                 : "";
-            return `## where my attention is
+            return labelSurface(`## where my attention is
 i already have coding work running in ${liveCodingSession.runner} ${liveCodingSession.id}${scopeClause}.${familyStatusClause}${liveWorldClause}
 
-i should orient around that live lane first, then decide what still needs to come back here.`;
+i should orient around that live lane first, then decide what still needs to come back here.`);
         }
         if (genericConcreteStatus) {
             return genericConcreteStatus;
         }
-        return `## where my attention is
+        return labelSurface(`## where my attention is
 i have unfinished work that needs attention before i move on.
 
-i can take it inward with ponder to think privately, or address it directly here.`;
+i can take it inward with ponder to think privately, or address it directly here.`);
     }
     if (cog === "shared-work") {
         /* v8 ignore stop */
-        return `## where my attention is
+        return labelSurface(`## where my attention is
 this work touches multiple conversations -- i'm holding threads across sessions.${liveWorldClause}
 
-i should keep the different sides aligned. what i learn here may matter there, and vice versa.`;
+i should keep the different sides aligned. what i learn here may matter there, and vice versa.`);
     }
     /* v8 ignore next -- unreachable: all center-of-gravity modes covered above @preserve */
     return "";
@@ -1051,7 +1083,7 @@ function commitmentsSection(options) {
     const commitments = (0, commitments_1.deriveCommitments)(options.activeWorkFrame, job, options.activeWorkFrame.pendingObligations, awaits);
     if (commitments.committedTo.length === 0 && awaits.length === 0)
         return "";
-    return `## my commitments\n\n${(0, commitments_1.formatCommitments)(commitments)}`;
+    return (0, orientation_frame_1.labelPriorWorkSurface)(`## my commitments\n\n${(0, commitments_1.formatCommitments)(commitments)}`, options.resumePriorWork === true);
 }
 const DELEGATION_REASON_PROSE_HINT = {
     explicit_reflection: "something here calls for reflection",
@@ -1451,8 +1483,8 @@ async function buildSystem(channel = "cli", options, context) {
         rhythmStatusSection(options?.daemonHealth),
         // Group 7: dynamic state for this turn
         "# dynamic state for this turn",
+        currentTriggerSection(channel, options),
         startOfTurnPacketSection(options),
-        orientationFrameSection(options),
         pulseSection(channel),
         tripLedgerTruthSection(channel, context),
         liveWorldStateSection(options),

package/dist/nerves/coverage/run-artifacts.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REPO_SLUG = void 0;
 exports.getTestRunsRoot = getTestRunsRoot;
+exports.coverageRunOwner = coverageRunOwner;
+exports.getOwnedTestRunsRoot = getOwnedTestRunsRoot;
 exports.createRunId = createRunId;
 exports.getRunDir = getRunDir;
 exports.writeActiveRun = writeActiveRun;
@@ -10,68 +12,86 @@ exports.clearActiveRun = clearActiveRun;
 exports.writeLatestRun = writeLatestRun;
 exports.readLatestRun = readLatestRun;
 const fs_1 = require("fs");
-const path_1 = require("path");
+const crypto_1 = require("crypto");
 const os_1 = require("os");
+const path_1 = require("path");
 exports.REPO_SLUG = "ouroboros-agent-harness";
 function getTestRunsRoot(repoSlug = exports.REPO_SLUG) {
     return (0, path_1.join)((0, os_1.tmpdir)(), "ouroboros-test-runs", repoSlug);
 }
+function coverageRunOwner(cwd = process.cwd()) {
+    const hash = (0, crypto_1.createHash)("sha256").update((0, path_1.resolve)(cwd)).digest("hex").slice(0, 12);
+    return `cwd-${hash}`;
+}
+function getOwnedTestRunsRoot(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    return (0, path_1.join)(getTestRunsRoot(repoSlug), coverageRunOwner(cwd));
+}
 function createRunId(now = new Date()) {
     return now.toISOString().replace(/[:.]/g, "-");
 }
-function getRunDir(runId, repoSlug = exports.REPO_SLUG) {
-    return (0, path_1.join)(getTestRunsRoot(repoSlug), runId);
+function getRunDir(runId, repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    return (0, path_1.join)(getOwnedTestRunsRoot(repoSlug, cwd), runId);
 }
-function getActiveRunPath(repoSlug = exports.REPO_SLUG) {
-    return (0, path_1.join)(getTestRunsRoot(repoSlug), ".active-run.json");
+function getActiveRunPath(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    return (0, path_1.join)(getOwnedTestRunsRoot(repoSlug, cwd), ".active-run.json");
 }
-function getLatestRunPath(repoSlug = exports.REPO_SLUG) {
-    return (0, path_1.join)(getTestRunsRoot(repoSlug), "latest-run.json");
+function getLatestRunPath(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    return (0, path_1.join)(getOwnedTestRunsRoot(repoSlug, cwd), "latest-run.json");
 }
-function ensureRoot(repoSlug = exports.REPO_SLUG) {
-    const root = getTestRunsRoot(repoSlug);
+function ensureRoot(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    const root = getOwnedTestRunsRoot(repoSlug, cwd);
     (0, fs_1.mkdirSync)(root, { recursive: true });
     return root;
 }
-function writeActiveRun(info) {
-    ensureRoot(info.repo_slug);
-    (0, fs_1.writeFileSync)(getActiveRunPath(info.repo_slug), JSON.stringify(info, null, 2), "utf8");
+function isValidRunInfo(value, repoSlug, cwd) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const parsed = value;
+    const owner = coverageRunOwner(cwd);
+    if (parsed.repo_slug !== repoSlug ||
+        parsed.run_owner !== owner ||
+        typeof parsed.run_id !== "string" ||
+        parsed.run_id.length === 0 ||
+        typeof parsed.run_dir !== "string" ||
+        parsed.run_dir.length === 0 ||
+        typeof parsed.created_at !== "string" ||
+        parsed.created_at.length === 0) {
+        return false;
+    }
+    const ownerRoot = (0, path_1.resolve)(getOwnedTestRunsRoot(repoSlug, cwd));
+    const runDir = (0, path_1.resolve)(parsed.run_dir);
+    const relativeRunDir = (0, path_1.relative)(ownerRoot, runDir);
+    const isContained = relativeRunDir !== "" && relativeRunDir !== ".." && !relativeRunDir.startsWith(`..${path_1.sep}`) && !(0, path_1.isAbsolute)(relativeRunDir);
+    return isContained && runDir === (0, path_1.resolve)(ownerRoot, parsed.run_id);
 }
-function readActiveRun(repoSlug = exports.REPO_SLUG) {
-    const filePath = getActiveRunPath(repoSlug);
+function readRunInfo(filePath, repoSlug, cwd) {
     if (!(0, fs_1.existsSync)(filePath))
         return null;
     try {
         const parsed = JSON.parse((0, fs_1.readFileSync)(filePath, "utf8"));
-        if (!parsed.run_id || !parsed.run_dir)
-            return null;
-        return parsed;
+        return isValidRunInfo(parsed, repoSlug, cwd) ? parsed : null;
     }
     catch {
         return null;
     }
 }
-function clearActiveRun(repoSlug = exports.REPO_SLUG) {
-    const filePath = getActiveRunPath(repoSlug);
+function writeActiveRun(info, cwd = process.cwd()) {
+    ensureRoot(info.repo_slug, cwd);
+    (0, fs_1.writeFileSync)(getActiveRunPath(info.repo_slug, cwd), JSON.stringify(info, null, 2), "utf8");
+}
+function readActiveRun(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    return readRunInfo(getActiveRunPath(repoSlug, cwd), repoSlug, cwd);
+}
+function clearActiveRun(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    const filePath = getActiveRunPath(repoSlug, cwd);
     if ((0, fs_1.existsSync)(filePath)) {
         (0, fs_1.unlinkSync)(filePath);
     }
 }
-function writeLatestRun(info) {
-    ensureRoot(info.repo_slug);
-    (0, fs_1.writeFileSync)(getLatestRunPath(info.repo_slug), JSON.stringify(info, null, 2), "utf8");
+function writeLatestRun(info, cwd = process.cwd()) {
+    ensureRoot(info.repo_slug, cwd);
+    (0, fs_1.writeFileSync)(getLatestRunPath(info.repo_slug, cwd), JSON.stringify(info, null, 2), "utf8");
 }
-function readLatestRun(repoSlug = exports.REPO_SLUG) {
-    const filePath = getLatestRunPath(repoSlug);
-    if (!(0, fs_1.existsSync)(filePath))
-        return null;
-    try {
-        const parsed = JSON.parse((0, fs_1.readFileSync)(filePath, "utf8"));
-        if (!parsed.run_id || !parsed.run_dir)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
+function readLatestRun(repoSlug = exports.REPO_SLUG, cwd = process.cwd()) {
+    return readRunInfo(getLatestRunPath(repoSlug, cwd), repoSlug, cwd);
 }

package/dist/nerves/review/cli.js

@@ -38,7 +38,7 @@ const path = __importStar(require("node:path"));
 const identity_1 = require("../../heart/identity");
 const core_1 = require("./core");
 function parseArgs(argv) {
-    const args = { process: "daemon", json: false, help: false };
+    const args = { process: core_1.DEFAULT_NERVES_PROCESS, json: false, help: false };
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
         const next = argv[i + 1];
@@ -100,7 +100,7 @@ function printHelp() {
         "Tail the agent's nerves ndjson and filter recent events. Read-only.",
         "",
         "options:",
-        "  --process <name>      log stream to read (default: daemon)",
+        `  --process <name>      log stream to read (default: ${core_1.DEFAULT_NERVES_PROCESS})`,
         "  --agent <name>        agent bundle to read from (default: current)",
         "  --component <substr>  filter by component substring (case-insensitive)",
         "  --event <substr>      filter by event-name substring (case-insensitive)",

package/dist/nerves/review/core.js

@@ -33,10 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NERVES_PROCESS = void 0;
 exports.parseDuration = parseDuration;
 exports.reviewNerveEvents = reviewNerveEvents;
 exports.formatNerveEntry = formatNerveEntry;
 const fs = __importStar(require("node:fs"));
+exports.DEFAULT_NERVES_PROCESS = "ouro";
 const DURATION_PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/;
 function parseDuration(value) {
     const match = DURATION_PATTERN.exec(value.trim().toLowerCase());
@@ -56,15 +58,20 @@ function parseDuration(value) {
         /* v8 ignore stop */
     }
 }
-function entryTimeMs(parsed) {
+function entryTimestamp(parsed) {
     if (!parsed)
         return null;
-    const time = parsed.time;
-    if (typeof time === "string") {
-        const ms = Date.parse(time);
-        return Number.isFinite(ms) ? ms : null;
+    if (Object.prototype.hasOwnProperty.call(parsed, "ts")) {
+        return typeof parsed.ts === "string" ? parsed.ts : null;
     }
-    return null;
+    return typeof parsed.time === "string" ? parsed.time : null;
+}
+function entryTimeMs(parsed) {
+    const timestamp = entryTimestamp(parsed);
+    if (timestamp === null)
+        return null;
+    const ms = Date.parse(timestamp);
+    return Number.isFinite(ms) ? ms : null;
 }
 function readLastNLines(filePath, maxLines, maxBytes = 8 * 1024 * 1024) {
     let text;
@@ -143,7 +150,7 @@ function formatNerveEntry(entry) {
     const parsed = entry.parsed;
     if (!parsed)
         return entry.raw;
-    const time = String(parsed.time ?? "");
+    const time = entryTimestamp(parsed) ?? "";
     const level = String(parsed.level ?? "info");
     const component = String(parsed.component ?? "?");
     const event = String(parsed.event ?? "?");

package/dist/repertoire/tools-base.js

@@ -27,6 +27,7 @@ const tools_evolution_1 = require("./tools-evolution");
 const tools_runtime_1 = require("./tools-runtime");
 const tools_orientation_1 = require("./tools-orientation");
 const tools_rsvp_1 = require("./tools-rsvp");
+const tools_habits_1 = require("./tools-habits");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
 Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_flow_1.ponderTool; } });
@@ -69,6 +70,7 @@ exports.baseToolDefinitions = [
     ...tools_orientation_1.orientationToolDefinitions,
     ...tools_runtime_1.runtimeToolDefinitions,
     ...tools_rsvp_1.rsvpToolDefinitions,
+    ...tools_habits_1.habitToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).
 // Used by consumers that need the OpenAI function-tool format.

package/dist/repertoire/tools-habits.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.habitToolDefinitions = void 0;
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../nerves/runtime");
+const habit_cancel_1 = require("../heart/habits/habit-cancel");
+const semantic_receipts_1 = require("../senses/bluebubbles/semantic-receipts");
+const CAPTURE_LOCATOR_PATTERN = /^capture:([a-f0-9]{64})$/;
+const ACTOR_AUTHORITY_ERROR = "habit_cancel requires trusted current-ingress actor authority";
+async function requireTrustedCurrentIngressActor(agentRoot, captureKeyHash, context) {
+    const capture = (0, semantic_receipts_1.readBlueBubblesSemanticCaptureAtRoot)(agentRoot, captureKeyHash);
+    const actor = capture?.event.actor;
+    if (!actor || !context?.friendStore)
+        throw new Error(ACTOR_AUTHORITY_ERROR);
+    try {
+        const friend = await context.friendStore.findByExternalId(actor.provider, actor.externalId);
+        if (!friends_1.TRUSTED_LEVELS.has(friend?.trustLevel ?? "stranger")) {
+            throw new Error(ACTOR_AUTHORITY_ERROR);
+        }
+    }
+    catch {
+        throw new Error(ACTOR_AUTHORITY_ERROR);
+    }
+}
+exports.habitToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "habit_cancel",
+                description: "Cancel a named habit from the immutable evidence capture that triggered the current turn.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        habit: {
+                            type: "string",
+                            description: "Exact habit identifier to cancel.",
+                        },
+                        evidence: {
+                            type: "string",
+                            description: "Current ingress evidence locator in capture:<sha256> form.",
+                        },
+                    },
+                    required: ["habit", "evidence"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        riskProfile: {
+            mutates: "durable_state_write",
+            risk: "high",
+            reason: "Permanently transitions a durable habit definition to cancelled.",
+        },
+        terminalProjection: {
+            mode: "verbatim",
+            requiresSoleCall: true,
+            clearBufferedText: true,
+        },
+        summaryKeys: ["habit", "evidence"],
+        handler: async (args, context) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tools.habit_cancel_invoked",
+                message: "habit cancellation tool invoked",
+                meta: { habit: typeof args.habit === "string" ? args.habit : null },
+            });
+            const keys = Object.keys(args);
+            const unexpected = keys.find((key) => key !== "habit" && key !== "evidence");
+            if (unexpected)
+                throw new Error(`unexpected habit_cancel argument: ${unexpected}`);
+            if (keys.length !== 2 || typeof args.habit !== "string" || args.habit.trim().length === 0) {
+                throw new Error("habit_cancel requires exactly habit and evidence");
+            }
+            const match = CAPTURE_LOCATOR_PATTERN.exec(args.evidence);
+            if (!match)
+                throw new Error("habit_cancel evidence must use capture:<sha256>");
+            const currentIngressEvidence = context?.currentIngressEvidence;
+            if (!currentIngressEvidence
+                || Object.keys(currentIngressEvidence).length !== 3
+                || Object.keys(currentIngressEvidence).some((key) => (key !== "schemaVersion" && key !== "provider" && key !== "captureKeyHash"))
+                || currentIngressEvidence.schemaVersion !== 1
+                || currentIngressEvidence.provider !== "bluebubbles"
+                || !/^[a-f0-9]{64}$/.test(currentIngressEvidence.captureKeyHash))
+                throw new Error("habit_cancel requires authoritative current ingress evidence");
+            if (currentIngressEvidence.captureKeyHash !== match[1]) {
+                throw new Error("habit_cancel evidence mismatch with current ingress evidence");
+            }
+            if (!context?.agentRoot)
+                throw new Error("habit_cancel requires an agent root");
+            await requireTrustedCurrentIngressActor(context.agentRoot, currentIngressEvidence.captureKeyHash, context);
+            const receipt = await (0, habit_cancel_1.cancelHabit)({
+                agentRoot: context.agentRoot,
+                habitId: args.habit,
+                evidenceLocator: args.evidence,
+                authority: {
+                    kind: "current_ingress",
+                    currentIngressEvidence,
+                },
+            });
+            return receipt.acknowledgement;
+        },
+    },
+];

package/dist/repertoire/tools.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.surfaceToolDef = exports.speakTool = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
 exports.resetMcpDefinitions = resetMcpDefinitions;
 exports.getToolsForChannel = getToolsForChannel;
+exports.getRestrictedReactionFeedbackTools = getRestrictedReactionFeedbackTools;
+exports.resolveToolDefinition = resolveToolDefinition;
 exports.shellRiskProfile = shellRiskProfile;
 exports.riskProfileForTool = riskProfileForTool;
 exports.riskProfileForToolName = riskProfileForToolName;
@@ -125,11 +127,24 @@ function getToolsForChannel(capabilities, toolPreferences, _context, providerCap
     }
     return filterByCapability(result, providerCapabilities);
 }
-// Look up a tool definition from the combined registry (native + MCP).
-function findDefinition(toolName) {
-    return allDefinitions.find((d) => d.tool.function.name === toolName)
+/**
+ * The complete provider-facing tool surface for trusted reaction feedback.
+ * Keep these schemas sourced from the normal registry so restricted turns
+ * cannot drift onto lookalike definitions or inherit channel/MCP tools.
+ */
+function getRestrictedReactionFeedbackTools() {
+    const orientationGetTool = tools_base_1.baseToolDefinitions.find((definition) => definition.tool.function.name === "orientation_get").tool;
+    return [tools_base_1.settleTool, tools_base_1.observeTool, orientationGetTool];
+}
+// Look up a tool definition from the live combined registry (native + MCP).
+// The base registry is intentionally consulted at call time so tests and
+// runtime extensions cannot leave execution metadata behind a stale snapshot.
+function resolveToolDefinition(toolName) {
+    return tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === toolName)
+        ?? allDefinitions.find((d) => d.tool.function.name === toolName)
         ?? mcpDefinitions.find((d) => d.tool.function.name === toolName);
 }
+const findDefinition = resolveToolDefinition;
 function normalizeGuardArgs(_name, args) {
     return args;
 }