@ouro.bot/cli 0.1.0-alpha.90 → 0.1.0-alpha.900

package/dist/heart/identity.js

@@ -33,7 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HARNESS_CANONICAL_REPO_URL = exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.HARNESS_CANONICAL_REPO_URL = exports.DEFAULT_AGENT_SENSES = exports.LEGACY_VAULT_SERVER_URL_ALIASES = exports.DEFAULT_VAULT_SERVER_URL = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = exports.PROVIDER_CREDENTIALS = exports.normalizeHabitPaidTurnsPerDay = void 0;
+exports.normalizeVaultServerUrl = normalizeVaultServerUrl;
+exports.getVaultServerUrlCandidates = getVaultServerUrlCandidates;
+exports.defaultStableVaultEmail = defaultStableVaultEmail;
+exports.resolveVaultConfig = resolveVaultConfig;
+exports.normalizeSenses = normalizeSenses;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
@@ -45,8 +50,8 @@ exports.getAgentDaemonStateRoot = getAgentDaemonStateRoot;
 exports.getAgentDaemonLogsDir = getAgentDaemonLogsDir;
 exports.getAgentDaemonLoggingConfigPath = getAgentDaemonLoggingConfigPath;
 exports.getAgentMessagesRoot = getAgentMessagesRoot;
+exports.getAgentMailroomRoot = getAgentMailroomRoot;
 exports.getAgentToolsRoot = getAgentToolsRoot;
-exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
 exports.setAgentConfigOverride = setAgentConfigOverride;
@@ -56,6 +61,20 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
+const migrate_config_1 = require("./migrate-config");
+const autonomy_budget_1 = require("./autonomy-budget");
+var autonomy_budget_2 = require("./autonomy-budget");
+Object.defineProperty(exports, "normalizeHabitPaidTurnsPerDay", { enumerable: true, get: function () { return autonomy_budget_2.normalizeHabitPaidTurnsPerDay; } });
+/** Single source of truth for per-provider credential field names, env var mappings, and prompt labels. */
+exports.PROVIDER_CREDENTIALS = {
+    anthropic: { required: ["setupToken"], envVars: { ANTHROPIC_API_KEY: "setupToken" }, promptLabels: { setupToken: "Anthropic setup-token" } },
+    "openai-codex": { required: ["oauthAccessToken"], envVars: { OPENAI_API_KEY: "oauthAccessToken" }, promptLabels: { oauthAccessToken: "OpenAI Codex OAuth token" } },
+    azure: { required: ["apiKey", "endpoint", "deployment"], envVars: { AZURE_OPENAI_API_KEY: "apiKey", AZURE_OPENAI_KEY: "apiKey", AZURE_OPENAI_ENDPOINT: "endpoint", AZURE_OPENAI_DEPLOYMENT: "deployment" }, promptLabels: { apiKey: "Azure API key", endpoint: "Azure endpoint", deployment: "Azure deployment" } },
+    minimax: { required: ["apiKey"], envVars: { MINIMAX_API_KEY: "apiKey" }, promptLabels: { apiKey: "MiniMax API key" } },
+    "github-copilot": { required: ["githubToken", "baseUrl"], envVars: { GH_TOKEN: "githubToken", GITHUB_TOKEN: "githubToken" }, promptLabels: { githubToken: "GitHub token" } },
+    "openai-compatible": { required: ["apiKey", "baseUrl"], envVars: {}, promptLabels: { apiKey: "Z.ai API key", baseUrl: "Z.ai canonical base URL" } },
+    "openai-compatible-gemini": { required: ["apiKey", "baseUrl"], envVars: {}, promptLabels: { apiKey: "Gemini API key", baseUrl: "Gemini canonical base URL" } },
+};
 exports.DEFAULT_AGENT_CONTEXT = {
     maxTokens: 80000,
     contextMargin: 20,
@@ -65,16 +84,80 @@ exports.DEFAULT_AGENT_PHRASES = {
     tool: ["running tool"],
     followup: ["processing"],
 };
+exports.DEFAULT_VAULT_SERVER_URL = "https://vault.ouro.bot";
+exports.LEGACY_VAULT_SERVER_URL_ALIASES = [
+    "https://vault.ouroboros.bot",
+    "https://ouro-vault.gentleflower-74452a1e.eastus2.azurecontainerapps.io",
+];
+function normalizeVaultServerUrl(serverUrl) {
+    const trimmed = serverUrl.trim();
+    const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
+    if (!withoutTrailingSlash) {
+        return exports.DEFAULT_VAULT_SERVER_URL;
+    }
+    if (exports.LEGACY_VAULT_SERVER_URL_ALIASES.includes(withoutTrailingSlash)) {
+        return exports.DEFAULT_VAULT_SERVER_URL;
+    }
+    return withoutTrailingSlash;
+}
+function getVaultServerUrlCandidates(serverUrl) {
+    const raw = serverUrl.trim();
+    const withoutTrailingSlash = raw.replace(/\/+$/, "");
+    const normalized = normalizeVaultServerUrl(serverUrl);
+    const candidates = [normalized];
+    for (const candidate of [withoutTrailingSlash, raw]) {
+        if (candidate && !candidates.includes(candidate)) {
+            candidates.push(candidate);
+        }
+    }
+    if (normalized === exports.DEFAULT_VAULT_SERVER_URL) {
+        for (const alias of exports.LEGACY_VAULT_SERVER_URL_ALIASES) {
+            if (!candidates.includes(alias)) {
+                candidates.push(alias);
+            }
+        }
+    }
+    return candidates;
+}
+function defaultStableVaultEmail(agentName) {
+    const local = agentName
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "agent";
+    return `${local}@ouro.bot`;
+}
+/**
+ * Resolve the vault config for an agent, applying defaults.
+ * If vault is not configured in agent.json, returns default values.
+ */
+function resolveVaultConfig(agentName, config) {
+    return {
+        email: config?.email ?? defaultStableVaultEmail(agentName),
+        serverUrl: normalizeVaultServerUrl(config?.serverUrl ?? exports.DEFAULT_VAULT_SERVER_URL),
+    };
+}
 exports.DEFAULT_AGENT_SENSES = {
     cli: { enabled: true },
     teams: { enabled: false },
     bluebubbles: { enabled: false },
+    mail: { enabled: false },
+    voice: { enabled: false },
+    a2a: { enabled: false },
+    telegram: { enabled: false },
+    workbench: { enabled: false },
+    shepherd: { enabled: false },
 };
 function normalizeSenses(value, configFile) {
     const defaults = {
         cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
         teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
         bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+        mail: { ...exports.DEFAULT_AGENT_SENSES.mail },
+        voice: { ...exports.DEFAULT_AGENT_SENSES.voice },
+        a2a: { ...exports.DEFAULT_AGENT_SENSES.a2a },
+        telegram: { ...exports.DEFAULT_AGENT_SENSES.telegram },
+        workbench: { ...exports.DEFAULT_AGENT_SENSES.workbench },
+        shepherd: { ...exports.DEFAULT_AGENT_SENSES.shepherd },
     };
     if (value === undefined) {
         return defaults;
@@ -90,7 +173,7 @@ function normalizeSenses(value, configFile) {
         throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
     }
     const raw = value;
-    const senseNames = ["cli", "teams", "bluebubbles"];
+    const senseNames = ["cli", "teams", "bluebubbles", "mail", "voice", "a2a", "telegram", "workbench", "shepherd"];
     for (const senseName of senseNames) {
         const rawSense = raw[senseName];
         if (rawSense === undefined) {
@@ -123,14 +206,22 @@ function normalizeSenses(value, configFile) {
 }
 function buildDefaultAgentTemplate(_agentName) {
     return {
-        version: 1,
+        version: 2,
         enabled: true,
-        provider: "anthropic",
+        humanFacing: { provider: "anthropic", model: "claude-opus-4-6" },
+        agentFacing: { provider: "anthropic", model: "claude-opus-4-6" },
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        habitPaidTurnsPerDay: autonomy_budget_1.DEFAULT_HABIT_PAID_TURNS_PER_DAY,
         senses: {
             cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
             teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
             bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+            mail: { ...exports.DEFAULT_AGENT_SENSES.mail },
+            voice: { ...exports.DEFAULT_AGENT_SENSES.voice },
+            a2a: { ...exports.DEFAULT_AGENT_SENSES.a2a },
+            telegram: { ...exports.DEFAULT_AGENT_SENSES.telegram },
+            workbench: { ...exports.DEFAULT_AGENT_SENSES.workbench },
+            shepherd: { ...exports.DEFAULT_AGENT_SENSES.shepherd },
         },
         phrases: {
             thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
@@ -148,12 +239,6 @@ let _agentConfigOverride = null;
  */
 function getAgentName() {
     if (_cachedAgentName) {
-        (0, runtime_1.emitNervesEvent)({
-            event: "identity.resolve",
-            component: "config/identity",
-            message: "resolved agent name from cache",
-            meta: { source: "cache" },
-        });
         return _cachedAgentName;
     }
     const idx = process.argv.indexOf("--agent");
@@ -197,7 +282,7 @@ function resolveOptionalAgentName(agentName) {
         return getAgentName();
     }
     catch {
-        return "slugger";
+        return "default";
     }
 }
 /**
@@ -206,7 +291,7 @@ function resolveOptionalAgentName(agentName) {
 function getAgentStateRoot(agentName) {
     return path.join(getAgentRoot(resolveOptionalAgentName(agentName)), "state");
 }
-exports.HARNESS_CANONICAL_REPO_URL = "https://github.com/ouroborosbot/ouroboros.git";
+exports.HARNESS_CANONICAL_REPO_URL = "https://github.com/ourostack/ouroboros.git";
 function getAgentRepoWorkspacesRoot(agentName) {
     return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "workspaces");
 }
@@ -222,26 +307,17 @@ function getAgentDaemonLoggingConfigPath(agentName) {
 function getAgentMessagesRoot(agentName) {
     return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "messages");
 }
+function getAgentMailroomRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "mailroom");
+}
 function getAgentToolsRoot(agentName) {
     return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "tools");
 }
-/**
- * Returns the conventional secrets path: `~/.agentsecrets/<agentName>/secrets.json`
- */
-function getAgentSecretsPath(agentName = getAgentName()) {
-    return path.join(os.homedir(), ".agentsecrets", agentName, "secrets.json");
+const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot", "openai-compatible", "openai-compatible-gemini"];
+function isValidProvider(value) {
+    return typeof value === "string" && VALID_PROVIDERS.includes(value);
 }
-/**
- * Load and parse `<agentRoot>/agent.json`.
- * Reads the file fresh on each call unless an override is set.
- * Throws descriptive error if file is missing or contains invalid JSON.
- */
-function loadAgentConfig() {
-    if (_agentConfigOverride) {
-        return _agentConfigOverride;
-    }
-    const agentRoot = getAgentRoot();
-    const configFile = path.join(agentRoot, "agent.json");
+function readAndParseAgentJson(configFile) {
     let raw;
     try {
         raw = fs.readFileSync(configFile, "utf-8");
@@ -259,9 +335,8 @@ function loadAgentConfig() {
         });
         throw new Error(`Cannot read agent.json at ${configFile}. Does the agent directory exist?`);
     }
-    let parsed;
     try {
-        parsed = JSON.parse(raw);
+        return JSON.parse(raw);
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -276,6 +351,74 @@ function loadAgentConfig() {
         });
         throw new Error(`Invalid JSON in agent.json at ${configFile}. Check syntax.`);
     }
+}
+function validateFacingConfig(parsed, facingName, configFile) {
+    const raw = parsed[facingName];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: `agent config missing or invalid ${facingName}`,
+            meta: { path: configFile, [facingName]: raw ?? null },
+        });
+        throw new Error(`agent.json at ${configFile} must include ${facingName} as { provider, model }.`);
+    }
+    const facing = raw;
+    if (!isValidProvider(facing.provider)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: `agent config has invalid provider in ${facingName}`,
+            meta: { path: configFile, provider: facing.provider ?? null },
+        });
+        throw new Error(`agent.json at ${configFile} ${facingName}.provider must be one of: ${VALID_PROVIDERS.join(", ")}.`);
+    }
+    if (typeof facing.model !== "string") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: `agent config has invalid model in ${facingName}`,
+            meta: { path: configFile, model: facing.model ?? null },
+        });
+        throw new Error(`agent.json at ${configFile} ${facingName}.model must be a string.`);
+    }
+    return { provider: facing.provider, model: facing.model };
+}
+/**
+ * Load and parse `<agentRoot>/agent.json`.
+ * Reads the explicit owner's file fresh, or preserves the legacy ambient override when no owner is supplied.
+ * If the config is v1, auto-migrates to v2 via migrateAgentConfigV1ToV2 and re-reads.
+ * Throws descriptive error if file is missing or contains invalid JSON.
+ */
+function loadAgentConfig(owner) {
+    if (owner !== undefined && (typeof owner !== "object" || owner === null
+        || typeof owner.agentName !== "string" || owner.agentName.length === 0
+        || typeof owner.agentRoot !== "string" || !path.isAbsolute(owner.agentRoot))) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "invalid agent configuration owner",
+            meta: { reason: "explicit owner requires an agent name and absolute root" },
+        });
+        throw new Error("invalid agent configuration owner");
+    }
+    if (owner === undefined && _agentConfigOverride) {
+        return _agentConfigOverride;
+    }
+    const agentRoot = owner === undefined ? getAgentRoot() : owner.agentRoot;
+    const configFile = path.join(agentRoot, "agent.json");
+    let parsed = readAndParseAgentJson(configFile);
+    // Inline migration: v1 -> v2
+    const rawVersion = parsed.version;
+    const initialVersion = typeof rawVersion === "number" ? rawVersion : 1;
+    if (initialVersion < 2) {
+        (0, migrate_config_1.migrateAgentConfigV1ToV2)(agentRoot);
+        parsed = readAndParseAgentJson(configFile);
+    }
     const existingPhrases = parsed.phrases;
     const needsFill = !existingPhrases ||
         !existingPhrases.thinking ||
@@ -297,29 +440,11 @@ function loadAgentConfig() {
         });
         fs.writeFileSync(configFile, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
     }
-    const rawProvider = parsed.provider;
-    if (rawProvider !== "azure" &&
-        rawProvider !== "minimax" &&
-        rawProvider !== "anthropic" &&
-        rawProvider !== "openai-codex" &&
-        rawProvider !== "github-copilot") {
-        (0, runtime_1.emitNervesEvent)({
-            level: "error",
-            event: "config_identity.error",
-            component: "config/identity",
-            message: "agent config missing or invalid provider",
-            meta: {
-                path: configFile,
-                provider: rawProvider,
-            },
-        });
-        throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", "openai-codex", or "github-copilot".`);
-    }
-    const provider = rawProvider;
-    const rawVersion = parsed.version;
-    const version = rawVersion === undefined ? 1 : rawVersion;
-    if (typeof version !== "number" ||
-        !Number.isInteger(version) ||
+    // Validate v2 facing configs
+    const humanFacing = validateFacingConfig(parsed, "humanFacing", configFile);
+    const agentFacing = validateFacingConfig(parsed, "agentFacing", configFile);
+    const version = typeof parsed.version === "number" ? parsed.version : 1;
+    if (!Number.isInteger(version) ||
         version < 1) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -328,7 +453,7 @@ function loadAgentConfig() {
             message: "agent config missing or invalid version",
             meta: {
                 path: configFile,
-                version: rawVersion,
+                version: parsed.version,
             },
         });
         throw new Error(`agent.json at ${configFile} must include version as integer >= 1.`);
@@ -348,16 +473,31 @@ function loadAgentConfig() {
         });
         throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
     }
+    // Tolerate deprecated provider field for backward compatibility
+    const rawProvider = parsed.provider;
+    const provider = isValidProvider(rawProvider) ? rawProvider : undefined;
+    // Spread parsed first so any field present in AgentConfig is carried
+    // through by default, then explicitly override the fields that need
+    // validation or normalization. This eliminates the field-drop bug class
+    // that caused the `sync` block (and previously `shell`) to be silently
+    // omitted from the returned config. Regression-guarded by the
+    // Required<AgentConfig> contract test in identity-contract.test.ts.
     const config = {
+        ...parsed,
         version,
         enabled,
-        provider,
-        context: parsed.context,
-        logging: parsed.logging,
+        humanFacing,
+        agentFacing,
+        habitPaidTurnsPerDay: (0, autonomy_budget_1.normalizeHabitPaidTurnsPerDay)(owner === undefined ? getAgentName() : owner.agentName, parsed.habitPaidTurnsPerDay, configFile),
         senses: normalizeSenses(parsed.senses, configFile),
-        mcpServers: parsed.mcpServers,
         phrases: parsed.phrases,
     };
+    if (provider !== undefined) {
+        config.provider = provider;
+    }
+    else {
+        delete config.provider;
+    }
     (0, runtime_1.emitNervesEvent)({
         event: "identity.resolve",
         component: "config/identity",

package/dist/heart/kept-notes.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherKeptNotesCandidates = gatherKeptNotesCandidates;
+exports.renderKeptNotesOutcome = renderKeptNotesOutcome;
+exports.injectKeptNotes = injectKeptNotes;
+exports.createKeptNotesJudge = createKeptNotesJudge;
+const diary_1 = require("../mind/diary");
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_TIMEOUT_MS = 2500;
+const MAX_CANDIDATES = 8;
+const NOOP_CALLBACKS = {
+    onModelStart() { },
+    onModelStreamStart() { },
+    onTextChunk() { },
+    onReasoningChunk() { },
+    onToolStart() { },
+    onToolEnd() { },
+    onError() { },
+};
+function elapsedSince(startedAt) {
+    return Math.max(0, Date.now() - startedAt);
+}
+function latestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user" || typeof message.content !== "string")
+            continue;
+        const text = message.content.trim();
+        if (text)
+            return text;
+    }
+    return "";
+}
+function tokenize(text) {
+    return new Set(text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/g)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2));
+}
+function scoreText(queryTerms, text) {
+    const textTerms = tokenize(text);
+    let matches = 0;
+    for (const term of queryTerms) {
+        if (textTerms.has(term))
+            matches += 1;
+    }
+    return matches / queryTerms.size;
+}
+function diaryCandidate(fact) {
+    return {
+        text: fact.text,
+        source: { kind: "diary", label: "diary", ref: fact.id },
+    };
+}
+function friendNoteCandidates(friend, queryTerms) {
+    if (!friend)
+        return [];
+    return Object.entries(friend.notes ?? {})
+        .map(([key, note]) => {
+        const text = `${friend.name} / ${key}: ${note.value}`;
+        return {
+            candidate: {
+                text,
+                source: { kind: "friend-note", label: `friend note: ${friend.name}`, ref: key },
+            },
+            score: scoreText(queryTerms, `${key} ${note.value}`),
+        };
+    })
+        .filter((entry) => entry.score > 0);
+}
+function gatherKeptNotesCandidates(query, options = {}) {
+    const queryTerms = tokenize(query);
+    if (queryTerms.size === 0)
+        return [];
+    const diaryRoot = (0, diary_1.resolveDiaryRoot)(options.diaryRoot);
+    const diaryEntries = (0, diary_1.readDiaryEntries)(diaryRoot);
+    const diaryCandidates = diaryEntries
+        .map((fact) => ({ candidate: diaryCandidate(fact), score: scoreText(queryTerms, fact.text) }))
+        .filter((entry) => entry.score > 0);
+    return [...diaryCandidates, ...friendNoteCandidates(options.friend, queryTerms)]
+        .sort((left, right) => right.score - left.score)
+        .slice(0, MAX_CANDIDATES)
+        .map((entry) => entry.candidate);
+}
+function selectedSources(candidates, indexes) {
+    if (!indexes || indexes.length === 0)
+        return [];
+    const sources = [];
+    for (const index of indexes) {
+        if (!Number.isInteger(index))
+            continue;
+        const candidate = candidates[index];
+        if (candidate)
+            sources.push(candidate.source);
+    }
+    return sources;
+}
+function isFirstPerson(text) {
+    return /^(i|i'm|i’ve|i've|my|me)\b/i.test(text.trim());
+}
+function foundLine(text) {
+    const trimmed = text.trim();
+    if (isFirstPerson(trimmed))
+        return trimmed;
+    return `I kept this: ${trimmed}`;
+}
+function fuzzyLine(text) {
+    const trimmed = text.trim();
+    if (isFirstPerson(trimmed))
+        return trimmed;
+    return `I may have kept something related: ${trimmed}`;
+}
+const SOURCE_KIND_ORDER = ["diary", "friend-note"];
+const SOURCE_KIND_LABELS = {
+    diary: "my Desk record diary",
+    "friend-note": "my friend notes",
+};
+function joinLabels(labels) {
+    if (labels.length === 1)
+        return labels[0];
+    return `${labels[0]} and ${labels[1]}`;
+}
+function sourceHeading(sources) {
+    const sourceKinds = new Set(sources.map((source) => source.kind));
+    const labels = SOURCE_KIND_ORDER
+        .filter((kind) => sourceKinds.has(kind))
+        .map((kind) => SOURCE_KIND_LABELS[kind]);
+    if (labels.length === 0)
+        return "## from my kept record";
+    return `## from ${joinLabels(labels)}`;
+}
+function renderKeptNotesOutcome(outcome) {
+    if (outcome.status === "found") {
+        return `${sourceHeading(outcome.sources)}\nThis may matter now:\n${foundLine(outcome.note)}`;
+    }
+    if (outcome.status === "fuzzy") {
+        return `${sourceHeading(outcome.sources)}\nThis is only a possible match; I should verify it before relying on it:\n${fuzzyLine(outcome.hint)}`;
+    }
+    return null;
+}
+function finish(outcome, traceId) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.kept_notes_end",
+        trace_id: traceId,
+        message: "kept notes completed",
+        meta: { status: outcome.status, elapsedMs: outcome.elapsedMs },
+    });
+    return outcome;
+}
+async function withTimeout(promise, timeoutMs) {
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => resolve("timeout"), timeoutMs);
+        promise
+            .then((value) => {
+            clearTimeout(timeout);
+            resolve(value);
+        })
+            .catch((error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
+async function injectKeptNotes(messages, options = {}) {
+    const startedAt = Date.now();
+    const systemMessage = messages[0];
+    const query = latestUserText(messages);
+    if (systemMessage?.role !== "system" || typeof systemMessage.content !== "string" || !query) {
+        return { status: "none", elapsedMs: elapsedSince(startedAt), pressure: [] };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.kept_notes_start",
+        trace_id: options.traceId,
+        message: "kept notes started",
+        meta: { channel: options.channel ?? "unknown" },
+    });
+    try {
+        const candidates = gatherKeptNotesCandidates(query, options);
+        if (candidates.length === 0 || !options.judge) {
+            return finish({ status: "none", elapsedMs: elapsedSince(startedAt), pressure: [] }, options.traceId);
+        }
+        const judged = await withTimeout(options.judge({ query, candidates }), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        if (judged === "timeout") {
+            return finish({ status: "timeout", elapsedMs: elapsedSince(startedAt) }, options.traceId);
+        }
+        const elapsedMs = elapsedSince(startedAt);
+        const outcome = judged.status === "found"
+            ? { status: "found", note: judged.note, sources: selectedSources(candidates, judged.sourceIndexes), elapsedMs }
+            : judged.status === "fuzzy"
+                ? { status: "fuzzy", hint: judged.hint, sources: selectedSources(candidates, judged.sourceIndexes), elapsedMs }
+                : { status: "none", pressure: judged.pressure, elapsedMs };
+        if (outcome.status === "found" || outcome.status === "fuzzy") {
+            const rendered = renderKeptNotesOutcome(outcome);
+            messages[0] = { role: "system", content: `${systemMessage.content}\n\n${rendered}` };
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.kept_notes_injected",
+                trace_id: options.traceId,
+                message: "kept notes injected",
+                meta: { status: outcome.status, sourceCount: outcome.sources.length },
+            });
+        }
+        return finish(outcome, options.traceId);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        const outcome = { status: "error", reason, elapsedMs: elapsedSince(startedAt) };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.kept_notes_error",
+            trace_id: options.traceId,
+            message: "kept notes failed",
+            meta: { reason },
+        });
+        return finish(outcome, options.traceId);
+    }
+}
+function parseJudgeResult(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { status: "none", pressure: ["invalid kept notes judge output"] };
+        }
+        const record = parsed;
+        if (record.status === "found" && typeof record.note === "string" && record.note.trim()) {
+            return {
+                status: "found",
+                note: record.note.trim(),
+                sourceIndexes: Array.isArray(record.sourceIndexes) ? record.sourceIndexes.filter((index) => typeof index === "number") : undefined,
+            };
+        }
+        if (record.status === "fuzzy" && typeof record.hint === "string" && record.hint.trim()) {
+            return {
+                status: "fuzzy",
+                hint: record.hint.trim(),
+                sourceIndexes: Array.isArray(record.sourceIndexes) ? record.sourceIndexes.filter((index) => typeof index === "number") : undefined,
+            };
+        }
+        if (record.status === "none") {
+            return {
+                status: "none",
+                pressure: Array.isArray(record.pressure) ? record.pressure.filter((value) => typeof value === "string") : [],
+            };
+        }
+        return { status: "none", pressure: ["invalid kept notes judge output"] };
+    }
+    catch {
+        return { status: "none", pressure: ["invalid kept notes judge output"] };
+    }
+}
+function createJudgePrompt(input) {
+    const candidates = input.candidates
+        .map((candidate, index) => `${index}. [${candidate.source.kind}] ${candidate.text}`)
+        .join("\n");
+    return [
+        {
+            role: "system",
+            content: [
+                "Decide whether these intentionally kept notes matter to the user's current turn.",
+                "Return only JSON.",
+                "Use found when a note clearly helps, fuzzy when a note is close but uncertain, and none when nothing should be surfaced.",
+                "Shapes: {\"status\":\"found\",\"note\":\"...\",\"sourceIndexes\":[0]}, {\"status\":\"fuzzy\",\"hint\":\"...\",\"sourceIndexes\":[0]}, or {\"status\":\"none\",\"pressure\":[]}.",
+            ].join("\n"),
+        },
+        {
+            role: "user",
+            content: `Current turn:\n${input.query}\n\nCandidates:\n${candidates}`,
+        },
+    ];
+}
+function createKeptNotesJudge(runtime, signal) {
+    return async (input) => {
+        const messages = createJudgePrompt(input);
+        runtime.resetTurnState?.(messages);
+        const result = await runtime.streamTurn({
+            messages,
+            activeTools: [],
+            callbacks: NOOP_CALLBACKS,
+            signal,
+            toolChoiceRequired: false,
+            reasoningEffort: "low",
+        });
+        return parseJudgeResult(result.content ?? "");
+    };
+}

package/dist/heart/kicks.js

@@ -5,7 +5,7 @@ exports.detectKick = detectKick;
 const runtime_1 = require("../nerves/runtime");
 const KICK_MESSAGES = {
     empty: "I sent an empty message by accident — let me try again.",
-    narration: "I narrated instead of acting. Using the tool now -- if done, calling final_answer.",
+    narration: "I narrated instead of acting. Using the tool now -- if done, calling settle.",
     tool_required: "tool-required is on — I need to call a tool. use /tool-required to turn it off.",
 };
 const TOOL_INTENT_PATTERNS = [