@ouro.bot/cli 0.1.0-alpha.665 → 0.1.0-alpha.667

package/dist/heart/habits/habit-scheduler.js

@@ -108,7 +108,7 @@ class HabitScheduler {
                     message: "firing overdue habit (never run)",
                     meta: { habitName: habit.name, agent: this.agent },
                 });
-                this.onHabitFire(habit.name);
+                this.onHabitFire(habit.name, "overdue");
                 continue;
             }
             const lastRunMs = new Date(habit.lastRun).getTime();
@@ -120,7 +120,7 @@ class HabitScheduler {
                     message: "firing overdue habit",
                     meta: { habitName: habit.name, agent: this.agent, elapsedMs: elapsed },
                 });
-                this.onHabitFire(habit.name);
+                this.onHabitFire(habit.name, "overdue");
             }
         }
     }
@@ -174,6 +174,25 @@ class HabitScheduler {
             return null;
         }
     }
+    listJobs() {
+        return this.buildJobs(this.scanHabits())
+            .map((job) => ({ id: job.id, schedule: job.schedule, lastRun: job.lastRun }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    async triggerJob(jobId, trigger = "cron") {
+        const job = this.buildJobs(this.scanHabits()).find((candidate) => candidate.id === jobId);
+        if (!job) {
+            return { ok: false, message: `unknown habit job: ${jobId}` };
+        }
+        this.onHabitFire(job.taskId, trigger);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_job_triggered",
+            message: "habit scheduler job triggered",
+            meta: { agent: job.agent, habitName: job.taskId, jobId, trigger },
+        });
+        return { ok: true, message: `triggered habit ${jobId}` };
+    }
     watchForChanges() {
         const watchFn = this.deps.watch;
         if (!watchFn)
@@ -278,7 +297,7 @@ class HabitScheduler {
                 const output = this.execForVerify("crontab -l");
                 const lines = output.split("\n");
                 for (const line of lines) {
-                    const match = line.match(/ouro poke \S+ --habit (\S+)/);
+                    const match = line.match(/ouro poke \S+ --habit (\S+)(?:\s+--trigger\s+\S+)?/);
                     if (match) {
                         verified.add(match[1]);
                     }
@@ -293,7 +312,7 @@ class HabitScheduler {
     createTimerFallback(habitName, cadenceMs) {
         const schedule = () => {
             const timer = setTimeout(() => {
-                this.onHabitFire(habitName);
+                this.onHabitFire(habitName, "overdue");
                 schedule();
             }, cadenceMs);
             this.timerFallbacks.set(habitName, timer);
@@ -362,7 +381,7 @@ class HabitScheduler {
                 taskId: habit.name,
                 schedule: cronSchedule,
                 lastRun: habit.lastRun,
-                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name}`,
+                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name} --trigger launchd`,
                 taskPath: path.join(this.habitsDir, `${habit.name}.md`),
             });
         }

package/dist/heart/habits/habit-session-summary.js

@@ -0,0 +1,318 @@
+"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.selectHabitRunReceipt = selectHabitRunReceipt;
+exports.readHabitSessionSummary = readHabitSessionSummary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const flight_recorder_1 = require("../../arc/flight-recorder");
+const runtime_1 = require("../../nerves/runtime");
+const session_events_1 = require("../session-events");
+const VALID_WHICH = new Set(["latest", "previous", "latest-success", "latest-failure"]);
+const SUCCESS_OUTCOMES = new Set([
+    "no_change",
+    "wrote_arc",
+    "updated_desk",
+    "wrote_record",
+    "surfaced",
+]);
+const FAILURE_OUTCOMES = new Set(["blocked", "error"]);
+const MAX_SUMMARY_CHARS = 1600;
+const TRUNCATION_SUFFIX = "\n[truncated]";
+function selectorError(code, message) {
+    return { ok: false, error: { code, message } };
+}
+function normalizeWhich(value) {
+    if (value === undefined)
+        return "latest";
+    return VALID_WHICH.has(value) ? value : null;
+}
+function sortNewestFirst(receipts) {
+    return [...receipts].sort((left, right) => right.endedAt.localeCompare(left.endedAt) || right.runId.localeCompare(left.runId));
+}
+function filterReceipts(receipts, selector) {
+    return receipts.filter((receipt) => {
+        if (selector.habitName !== undefined && receipt.habitName !== selector.habitName)
+            return false;
+        if (selector.operationId !== undefined && receipt.operationId !== selector.operationId)
+            return false;
+        return true;
+    });
+}
+function filterByWhich(receipts, which) {
+    if (which === "latest" || which === "previous")
+        return receipts;
+    const outcomes = which === "latest-success" ? SUCCESS_OUTCOMES : FAILURE_OUTCOMES;
+    return receipts.filter((receipt) => outcomes.has(receipt.outcome));
+}
+function selectHabitRunReceipt(receipts, selector) {
+    if (selector.runId !== undefined) {
+        if (selector.habitName !== undefined || selector.operationId !== undefined || selector.which !== undefined) {
+            return selectorError("run_id_exclusive", "runId cannot be combined with habitName, operationId, or which");
+        }
+        const receipt = receipts.find((entry) => entry.runId === selector.runId);
+        return receipt ? { ok: true, receipt } : selectorError("not_found", "no habit run matched selector");
+    }
+    if (selector.habitName === undefined && selector.operationId === undefined) {
+        return selectorError("selector_required", "provide runId, habitName, or operationId");
+    }
+    const which = normalizeWhich(selector.which);
+    if (which === null) {
+        return selectorError("invalid_which", "which must be latest, previous, latest-success, or latest-failure");
+    }
+    const matches = filterByWhich(sortNewestFirst(filterReceipts([...receipts], selector)), which);
+    const index = which === "previous" ? 1 : 0;
+    const receipt = matches[index];
+    return receipt ? { ok: true, receipt } : selectorError("not_found", "no habit run matched selector");
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function summarySnapshot(receipt) {
+    const snapshot = receipt.summarySnapshot;
+    return {
+        summary: snapshot.summary,
+        decisions: snapshot.decisions,
+        nextLikelyStep: snapshot.nextLikelyStep,
+    };
+}
+function relativeSource(receipt, key) {
+    if (key === "receipt")
+        return receipt.receiptLocator;
+    if (key === "session")
+        return receipt.sessionLocator;
+    if (key === "pending")
+        return receipt.pendingLocator;
+    return receipt.runtimeStateLocator;
+}
+function safeSourcePath(agentRoot, locator, key, expectedPrefix) {
+    const normalizedInput = locator.replace(/\\/g, "/");
+    const normalized = path.posix.normalize(normalizedInput);
+    const unsafe = path.isAbsolute(locator)
+        || normalizedInput.startsWith("/")
+        || normalized === "."
+        || normalized === ".."
+        || normalized.startsWith("../")
+        || normalized !== normalizedInput
+        || !normalized.startsWith(expectedPrefix);
+    if (unsafe) {
+        return { ok: false, warning: `${key} locator unsafe: ${locator}` };
+    }
+    const root = path.resolve(agentRoot);
+    const filePath = path.resolve(agentRoot, normalized);
+    /* v8 ignore next -- defensive containment check after normalized bundle-relative locator validation @preserve */
+    if (filePath !== root && !filePath.startsWith(`${root}${path.sep}`)) {
+        return { ok: false, warning: `${key} locator escaped bundle: ${locator}` };
+    }
+    return { ok: true, filePath };
+}
+function safeExistingRealPath(agentRoot, filePath, key, locator) {
+    try {
+        const root = fs.realpathSync.native(agentRoot);
+        const realPath = fs.realpathSync.native(filePath);
+        if (realPath !== root && !realPath.startsWith(`${root}${path.sep}`)) {
+            return { ok: false, warning: `${key} locator escaped bundle via symlink: ${locator}` };
+        }
+        return { ok: true, filePath: realPath };
+    }
+    catch {
+        /* v8 ignore next -- defensive realpath race/permission guard; existence is checked before callers invoke this @preserve */
+        return { ok: false, warning: `${key} locator unreadable: ${locator}` };
+    }
+}
+function sessionSummaryFromMessages(messages) {
+    const toolsUsed = new Set();
+    for (const message of messages) {
+        /* v8 ignore next -- defensive: session projection returns message records; this protects malformed direct projection callers @preserve */
+        if (!isRecord(message))
+            continue;
+        const name = stringValue(message.name) ?? stringValue(message.toolName);
+        /* v8 ignore next -- defensive: canonical projections expose tool names from assistant tool_calls; legacy direct tool-name projections still count if present @preserve */
+        if (name && message.role === "tool")
+            toolsUsed.add(name);
+        if (Array.isArray(message.tool_calls)) {
+            /* v8 ignore start -- defensive: projected provider messages normally expose structured tool calls; malformed direct envelopes are kept inert @preserve */
+            for (const toolCall of message.tool_calls) {
+                if (!isRecord(toolCall))
+                    continue;
+                const fn = isRecord(toolCall.function) ? toolCall.function : null;
+                const toolName = fn ? stringValue(fn.name) : null;
+                if (toolName)
+                    toolsUsed.add(toolName);
+            }
+            /* v8 ignore stop @preserve */
+        }
+    }
+    const warnings = messages.length === 0 ? ["session file had no usable messages"] : [];
+    return {
+        decisions: [],
+        nextLikelyStep: null,
+        toolsUsed: [...toolsUsed].sort(),
+        warnings,
+    };
+}
+function readSessionEnrichment(agentRoot, receipt) {
+    const source = safeSourcePath(agentRoot, receipt.sessionLocator, "session", "state/habit-sessions/");
+    if (!source.ok) {
+        return { decisions: [], nextLikelyStep: null, toolsUsed: [], warnings: [source.warning] };
+    }
+    if (!fs.existsSync(source.filePath)) {
+        return { decisions: [], nextLikelyStep: null, toolsUsed: [], warnings: ["session file missing"] };
+    }
+    const realSource = safeExistingRealPath(agentRoot, source.filePath, "session", receipt.sessionLocator);
+    if (!realSource.ok) {
+        return { decisions: [], nextLikelyStep: null, toolsUsed: [], warnings: [realSource.warning] };
+    }
+    const envelope = (0, session_events_1.loadSessionEnvelopeFile)(realSource.filePath);
+    if (!envelope) {
+        return { decisions: [], nextLikelyStep: null, toolsUsed: [], warnings: ["session file malformed"] };
+    }
+    return sessionSummaryFromMessages((0, session_events_1.projectProviderMessages)(envelope));
+}
+function readPending(agentRoot, receipt) {
+    const source = safeSourcePath(agentRoot, receipt.pendingLocator, "pending", "state/habit-sessions/");
+    if (!source.ok)
+        return { pending: { count: 0, files: [] }, warnings: [source.warning] };
+    try {
+        if (!fs.existsSync(source.filePath))
+            return { pending: { count: 0, files: [] }, warnings: [] };
+        const realSource = safeExistingRealPath(agentRoot, source.filePath, "pending", receipt.pendingLocator);
+        if (!realSource.ok)
+            return { pending: { count: 0, files: [] }, warnings: [realSource.warning] };
+        const entries = fs.readdirSync(realSource.filePath, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .sort();
+        return { pending: { count: entries.length, files: entries }, warnings: [] };
+    }
+    catch {
+        return { pending: { count: 0, files: [] }, warnings: [] };
+    }
+}
+function runtimeOperationId(agentRoot, receipt) {
+    const source = safeSourcePath(agentRoot, receipt.runtimeStateLocator, "runtimeState", "state/habits/");
+    if (!source.ok)
+        return { operationId: null, warnings: [source.warning] };
+    try {
+        if (!fs.existsSync(source.filePath))
+            return { operationId: null, warnings: [] };
+        const realSource = safeExistingRealPath(agentRoot, source.filePath, "runtimeState", receipt.runtimeStateLocator);
+        if (!realSource.ok)
+            return { operationId: null, warnings: [realSource.warning] };
+        const parsed = JSON.parse(fs.readFileSync(realSource.filePath, "utf-8"));
+        if (!isRecord(parsed))
+            return { operationId: null, warnings: [] };
+        if (parsed.schemaVersion !== 1)
+            return { operationId: null, warnings: [] };
+        if (stringValue(parsed.name) !== receipt.habitName)
+            return { operationId: null, warnings: [] };
+        if (stringValue(parsed.latestRunId) !== receipt.runId)
+            return { operationId: null, warnings: [] };
+        if (stringValue(parsed.latestReceiptLocator) !== receipt.receiptLocator)
+            return { operationId: null, warnings: [] };
+        return { operationId: stringValue(parsed.activeOperationId), warnings: [] };
+    }
+    catch {
+        return { operationId: null, warnings: [] };
+    }
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function truncateSummary(value) {
+    if (value.length <= MAX_SUMMARY_CHARS)
+        return value;
+    return `${value.slice(0, MAX_SUMMARY_CHARS - TRUNCATION_SUFFIX.length)}${TRUNCATION_SUFFIX}`;
+}
+function legacySummaryWarnings(receipt) {
+    return receipt.permissionEnvelope.warnings.some((warning) => warning.includes("legacy receipt normalized"))
+        ? ["legacy receipt normalized"]
+        : [];
+}
+function readHabitSessionSummary(agentRoot, selector) {
+    const selection = selectHabitRunReceipt((0, flight_recorder_1.listHabitRunReceipts)(agentRoot), selector);
+    if (!selection.ok)
+        return null;
+    const receipt = selection.receipt;
+    const snapshot = summarySnapshot(receipt);
+    const session = readSessionEnrichment(agentRoot, receipt);
+    const pending = readPending(agentRoot, receipt);
+    const runtime = runtimeOperationId(agentRoot, receipt);
+    const operationId = receipt.operationId ?? runtime.operationId;
+    const decisions = uniqueStrings([
+        ...snapshot.decisions,
+        ...session.decisions,
+    ]);
+    const summary = truncateSummary(snapshot.summary);
+    const nextLikelyStep = snapshot.nextLikelyStep ?? session.nextLikelyStep;
+    const result = {
+        runId: receipt.runId,
+        habitName: receipt.habitName,
+        operationId: operationId ?? null,
+        status: receipt.outcome,
+        triggeredAt: receipt.startedAt,
+        completedAt: receipt.endedAt,
+        summary,
+        decisions,
+        pending: pending.pending,
+        messagesSent: receipt.surfaceAttempts,
+        toolsUsed: session.toolsUsed,
+        producedRefs: receipt.producedRefs,
+        errors: receipt.errors,
+        nextLikelyStep: nextLikelyStep ?? null,
+        sources: {
+            receipt: relativeSource(receipt, "receipt"),
+            session: relativeSource(receipt, "session"),
+            pending: relativeSource(receipt, "pending"),
+            runtimeState: relativeSource(receipt, "runtimeState"),
+        },
+        warnings: [
+            ...legacySummaryWarnings(receipt),
+            ...session.warnings,
+            ...pending.warnings,
+            ...runtime.warnings,
+        ],
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.habit_session_summary_read",
+        message: "habit session summary read",
+        meta: { agentRoot, runId: receipt.runId, habitName: receipt.habitName, warningCount: result.warnings.length },
+    });
+    return result;
+}