@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

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

@@ -1,28 +1,11 @@
 "use strict";
-// TODO: Kicks enforce "any action" but not "meaningful action". After a narration
-// kick, the model can satisfy the constraint by calling a no-op tool like
-// get_current_time({}). We need to detect trivial compliance and either re-kick
-// or discount the tool call. Ideally, the kick message would suggest a specific
-// tool call based on conversation context (what the user asked, what tools are
-// relevant) rather than just saying "call a tool". That's a bigger piece of work —
-// it requires the kick system to be context-aware.
-// See ouroboros' observation: "i'm not chickening out. i'm satisfying a crude
-// constraint. poorly."
-//
-// A kick is a self-correction. When the harness detects a malformed response,
-// it injects an assistant-role message as if the model caught its own mistake.
-//
-// Kicks are:
-//   - assistant role (self-correction, not external rebuke)
-//   - first person ("I" not "you")
-//   - forward-looking (what I'm doing next, not what I did wrong)
-//   - short (one sentence)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasToolIntent = hasToolIntent;
 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 = [
@@ -141,4 +124,3 @@ function detectKick(content, options) {
     }
     return null;
 }
-const runtime_1 = require("../nerves/runtime");

package/dist/heart/machine-identity.js

@@ -0,0 +1,161 @@
+"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.getMachineIdentityPath = getMachineIdentityPath;
+exports.loadOrCreateMachineIdentity = loadOrCreateMachineIdentity;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function nowIso(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+function currentHostname(deps) {
+    return (deps.hostname?.() ?? os.hostname()).trim();
+}
+function defaultRandomId() {
+    return `machine_${crypto.randomUUID()}`;
+}
+function normalizeAliases(value) {
+    if (!Array.isArray(value))
+        return [];
+    const aliases = [];
+    for (const alias of value) {
+        if (typeof alias !== "string")
+            continue;
+        const trimmed = alias.trim();
+        if (trimmed && !aliases.includes(trimmed))
+            aliases.push(trimmed);
+    }
+    return aliases;
+}
+function parseMachineIdentity(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const aliases = normalizeAliases(record.hostnameAliases);
+    if (record.schemaVersion !== 1 ||
+        typeof record.machineId !== "string" ||
+        record.machineId.trim().length === 0 ||
+        typeof record.createdAt !== "string" ||
+        record.createdAt.trim().length === 0 ||
+        typeof record.updatedAt !== "string" ||
+        record.updatedAt.trim().length === 0) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        machineId: record.machineId,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        hostnameAliases: aliases,
+    };
+}
+function writeMachineIdentity(machinePath, identity) {
+    fs.mkdirSync(path.dirname(machinePath), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(machinePath, `${JSON.stringify(identity, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+}
+function getMachineIdentityPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".ouro-cli", "machine.json");
+}
+function loadOrCreateMachineIdentity(deps = {}) {
+    const homeDir = deps.homeDir ?? os.homedir();
+    const machinePath = getMachineIdentityPath(homeDir);
+    const hostname = currentHostname(deps);
+    let existing = null;
+    let hadInvalidFile = false;
+    try {
+        existing = parseMachineIdentity(JSON.parse(fs.readFileSync(machinePath, "utf-8")));
+        if (!existing)
+            hadInvalidFile = true;
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+            ? error.code
+            : undefined;
+        if (code !== "ENOENT")
+            hadInvalidFile = true;
+    }
+    if (hadInvalidFile) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "config/identity",
+            event: "config.machine_identity_invalid",
+            message: "machine identity file is invalid; replacing it",
+            meta: { path: machinePath },
+        });
+    }
+    if (existing) {
+        if (hostname && !existing.hostnameAliases.includes(hostname)) {
+            const updated = {
+                ...existing,
+                updatedAt: nowIso(deps),
+                hostnameAliases: [...existing.hostnameAliases, hostname],
+            };
+            writeMachineIdentity(machinePath, updated);
+            (0, runtime_1.emitNervesEvent)({
+                component: "config/identity",
+                event: "config.machine_identity_alias_added",
+                message: "recorded hostname alias for stable machine identity",
+                meta: { machineId: updated.machineId, hostname },
+            });
+            return updated;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config.machine_identity_loaded",
+            message: "loaded stable machine identity",
+            meta: { machineId: existing.machineId },
+        });
+        return existing;
+    }
+    const timestamp = nowIso(deps);
+    const identity = {
+        schemaVersion: 1,
+        machineId: (deps.randomId?.() ?? defaultRandomId()).trim() || defaultRandomId(),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        hostnameAliases: hostname ? [hostname] : [],
+    };
+    writeMachineIdentity(machinePath, identity);
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.machine_identity_created",
+        message: "created stable machine identity",
+        meta: { machineId: identity.machineId },
+    });
+    return identity;
+}