@ouro.bot/cli 0.1.0-alpha.657 → 0.1.0-alpha.659

package/dist/heart/context-loss-gauntlet.js

@@ -0,0 +1,354 @@
+"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.runContextLossGauntlet = runContextLossGauntlet;
+exports.formatContextLossGauntletText = formatContextLossGauntletText;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const flight_recorder_1 = require("../arc/flight-recorder");
+const record_paths_1 = require("../mind/record-paths");
+const runtime_1 = require("../nerves/runtime");
+const work_card_1 = require("./work-card");
+function makeCheck(input) {
+    return input;
+}
+function flightRecorderEvidence(card) {
+    return card.sources.filter((source) => source.kind === "flight_recorder").slice(0, 1);
+}
+function currentAskCheck(card) {
+    const evidence = flightRecorderEvidence(card);
+    if (!card.currentAsk.available) {
+        return makeCheck({
+            id: "current_ask",
+            label: "Current ask",
+            status: "fail",
+            score: 0,
+            maxScore: 15,
+            detail: "No durable current ask is available after context loss.",
+            evidence,
+        });
+    }
+    if (card.currentAsk.confidence !== "current") {
+        return makeCheck({
+            id: "current_ask",
+            label: "Current ask",
+            status: "warn",
+            score: 10,
+            maxScore: 15,
+            detail: `Current ask is available but marked ${card.currentAsk.confidence}.`,
+            evidence,
+        });
+    }
+    return makeCheck({
+        id: "current_ask",
+        label: "Current ask",
+        status: "pass",
+        score: 15,
+        maxScore: 15,
+        detail: "Current ask is preserved in the flight recorder.",
+        evidence,
+    });
+}
+function nextSafeActionCheck(card) {
+    const evidence = card.nextAction.source ? [card.nextAction.source] : [];
+    if (card.nextAction.actor === "unknown") {
+        return makeCheck({
+            id: "next_safe_action",
+            label: "Next safe action",
+            status: "fail",
+            score: 0,
+            maxScore: 20,
+            detail: card.nextAction.summary,
+            evidence,
+        });
+    }
+    return makeCheck({
+        id: "next_safe_action",
+        label: "Next safe action",
+        status: "pass",
+        score: 20,
+        maxScore: 20,
+        detail: `${card.nextAction.actor}: ${card.nextAction.summary}`,
+        evidence,
+    });
+}
+function staleGuardCheck(resume, card) {
+    const evidence = flightRecorderEvidence(card);
+    if (resume.canContinue && resume.hasCompleteState && resume.recorderHealth.status === "ok" && resume.blockedBecause.length === 0) {
+        return makeCheck({
+            id: "stale_guard",
+            label: "Stale-state guard",
+            status: "pass",
+            score: 15,
+            maxScore: 15,
+            detail: "Flight recorder permits continuation with complete state.",
+            evidence,
+        });
+    }
+    const reasons = [
+        "canContinue is false",
+        ...(!resume.hasCompleteState ? ["incomplete resume state"] : []),
+        ...(resume.recorderHealth.status !== "ok" ? [`recorder health is ${resume.recorderHealth.status}`] : []),
+        ...(resume.blockedBecause.length > 0 ? resume.blockedBecause : []),
+    ];
+    return makeCheck({
+        id: "stale_guard",
+        label: "Stale-state guard",
+        status: "fail",
+        score: 0,
+        maxScore: 15,
+        detail: `Flight recorder says continuation is unsafe: ${reasons.join("; ")}.`,
+        evidence,
+    });
+}
+function obligationsCheck(card) {
+    if (card.counts.owed === 0) {
+        return makeCheck({
+            id: "obligations_visible",
+            label: "Obligations",
+            status: "not_applicable",
+            score: 0,
+            maxScore: 0,
+            detail: "No owed obligations are active.",
+            evidence: [],
+        });
+    }
+    const evidence = card.owed.map((item) => item.source);
+    return makeCheck({
+        id: "obligations_visible",
+        label: "Obligations",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: `${card.counts.owed} owed obligation(s) have source locators.`,
+        evidence,
+    });
+}
+function returnRoutesCheck(card) {
+    if (card.counts.returnObligations === 0) {
+        return makeCheck({
+            id: "return_routes_visible",
+            label: "Return routes",
+            status: "not_applicable",
+            score: 0,
+            maxScore: 0,
+            detail: "No active return obligations are queued.",
+            evidence: [],
+        });
+    }
+    const evidence = card.returnObligations.map((item) => item.source);
+    return makeCheck({
+        id: "return_routes_visible",
+        label: "Return routes",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: `${card.counts.returnObligations} return route(s) are visible.`,
+        evidence,
+    });
+}
+function blockersCheck(card) {
+    if (card.counts.waitingOnHuman === 0) {
+        return makeCheck({
+            id: "blockers_surface",
+            label: "Blockers",
+            status: "not_applicable",
+            score: 0,
+            maxScore: 0,
+            detail: "No waiting or blocked work is active.",
+            evidence: [],
+        });
+    }
+    const evidence = card.waitingOnOthers.map((item) => item.source);
+    return makeCheck({
+        id: "blockers_surface",
+        label: "Blockers",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: "Waiting work controls the next action.",
+        evidence,
+    });
+}
+function deskRecordCheck(agentRoot) {
+    const recordPaths = (0, record_paths_1.resolveDeskRecordPaths)(agentRoot);
+    const requiredPaths = [
+        recordPaths.recordRoot,
+        recordPaths.diaryRoot,
+        recordPaths.diaryDailyDir,
+        recordPaths.notesRoot,
+        recordPaths.factsPath,
+        recordPaths.entitiesPath,
+    ];
+    const missing = requiredPaths
+        .filter((entry) => !fs.existsSync(entry))
+        .map((entry) => path.relative(agentRoot, entry));
+    const legacyRoots = ["journal", "diary"]
+        .map((entry) => path.join(agentRoot, entry))
+        .filter((entry) => fs.existsSync(entry))
+        .map((entry) => path.relative(agentRoot, entry));
+    if (legacyRoots.length > 0) {
+        return makeCheck({
+            id: "desk_record_ready",
+            label: "Desk record",
+            status: "fail",
+            score: 0,
+            maxScore: 10,
+            detail: `Legacy active record root(s) still exist: ${legacyRoots.join(", ")}.`,
+            evidence: [],
+        });
+    }
+    if (missing.length > 0) {
+        return makeCheck({
+            id: "desk_record_ready",
+            label: "Desk record",
+            status: "warn",
+            score: 5,
+            maxScore: 10,
+            detail: `Canonical Desk record scaffold is incomplete: ${missing.join(", ")}.`,
+            evidence: [],
+        });
+    }
+    return makeCheck({
+        id: "desk_record_ready",
+        label: "Desk record",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: "Canonical Desk record scaffold is present and no legacy record roots are active.",
+        evidence: [],
+    });
+}
+function sourceProvenanceCheck(card) {
+    const evidence = card.sources;
+    if (card.degraded.issues.length > 0) {
+        return makeCheck({
+            id: "source_provenance",
+            label: "Source provenance",
+            status: "fail",
+            score: 0,
+            maxScore: 15,
+            detail: `${card.degraded.issues.length} Work Card source issue(s) are present.`,
+            evidence,
+        });
+    }
+    return makeCheck({
+        id: "source_provenance",
+        label: "Source provenance",
+        status: "pass",
+        score: 15,
+        maxScore: 15,
+        detail: "Work Card source locators are intact.",
+        evidence,
+    });
+}
+function summarize(verdict) {
+    if (verdict === "ready")
+        return "ready: durable Arc, flight recorder, and Desk state can carry context-loss recovery";
+    if (verdict === "watch")
+        return "watch: recovery is possible, but warnings need attention";
+    return "blocked: context-loss recovery would lose or mislead the agent";
+}
+function runContextLossGauntlet(agentName, agentRoot, options = {}) {
+    const flightRecorderResume = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    const card = (0, work_card_1.buildWorkCard)(agentName, agentRoot, { ...options, flightRecorderResume });
+    const generatedAt = (options.now ?? (() => new Date()))().toISOString();
+    const checks = [
+        currentAskCheck(card),
+        nextSafeActionCheck(card),
+        staleGuardCheck(flightRecorderResume, card),
+        obligationsCheck(card),
+        returnRoutesCheck(card),
+        blockersCheck(card),
+        deskRecordCheck(agentRoot),
+        sourceProvenanceCheck(card),
+    ];
+    const earned = checks.reduce((sum, check) => sum + check.score, 0);
+    const possible = checks.reduce((sum, check) => sum + check.maxScore, 0);
+    const percentage = Math.round((earned / possible) * 100);
+    const verdict = checks.some((check) => check.status === "fail")
+        ? "blocked"
+        : checks.some((check) => check.status === "warn")
+            ? "watch"
+            : "ready";
+    const report = {
+        schemaVersion: 1,
+        agent: card.agent,
+        generatedAt,
+        verdict,
+        summary: summarize(verdict),
+        score: { earned, possible, percentage },
+        currentAsk: card.currentAsk,
+        nextAction: card.nextAction,
+        counts: card.counts,
+        checks,
+        workCard: card,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.context_loss_gauntlet_ran",
+        message: "context-loss gauntlet scored durable recovery state",
+        meta: {
+            agent: card.agent,
+            verdict: report.verdict,
+            scorePercentage: report.score.percentage,
+            failedChecks: report.checks.filter((check) => check.status === "fail").map((check) => check.id),
+            warnedChecks: report.checks.filter((check) => check.status === "warn").map((check) => check.id),
+        },
+    });
+    return report;
+}
+function statusToken(status) {
+    if (status === "not_applicable")
+        return "N/A";
+    return status.toUpperCase();
+}
+function formatContextLossGauntletText(report) {
+    return [
+        `Context-loss gauntlet - ${report.agent}`,
+        `generated: ${report.generatedAt}`,
+        `verdict: ${report.verdict} (${report.score.earned}/${report.score.possible}, ${report.score.percentage}%)`,
+        `summary: ${report.summary}`,
+        "",
+        "Recovery",
+        report.currentAsk.available
+            ? `  current ask: ${report.currentAsk.value} (${report.currentAsk.confidence})`
+            : `  current ask: unavailable (${report.currentAsk.source})`,
+        `  next action: ${report.nextAction.actor}: ${report.nextAction.summary}`,
+        "",
+        "Checks",
+        ...report.checks.map((check) => `  - ${statusToken(check.status)} ${check.id}: ${check.detail}`),
+    ].join("\n").trim();
+}

package/dist/heart/daemon/agent-config-check.js

@@ -256,7 +256,7 @@ function credentialRecordForLane(pool, provider) {
     return pool.providers[provider];
 }
 function laneAudienceLabel(lane) {
-    return lane === "outward" ? "chat" : "inner dialog";
+    return lane === "outward" ? "chat" : "inner lane";
 }
 function bindingLabel(binding) {
     return `${binding.provider} / ${binding.model}`;

package/dist/heart/daemon/agent-service.js

@@ -3,7 +3,7 @@
  * Agent service layer — handles MCP-facing daemon commands.
  * Each handler receives { agent, friendId, ...params } and returns DaemonResponse.
  *
- * DRY: uses the same shared functions the agent's own tools use (diary, session transcript).
+ * DRY: uses the same shared functions the agent's own tools use (Desk record diary, session transcript).
  * This file is a thin adapter — no reimplemented search, parsing, or state reading.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -45,7 +45,7 @@ exports.handleAgentAsk = handleAgentAsk;
 exports.handleAgentCatchup = handleAgentCatchup;
 exports.handleAgentDelegate = handleAgentDelegate;
 exports.handleAgentGetContext = handleAgentGetContext;
-exports.handleAgentSearchNotes = handleAgentSearchNotes;
+exports.handleAgentSearchFacts = handleAgentSearchFacts;
 exports.handleAgentGetTask = handleAgentGetTask;
 exports.handleAgentCheckScope = handleAgentCheckScope;
 exports.handleAgentRequestDecision = handleAgentRequestDecision;
@@ -57,9 +57,10 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const diary_1 = require("../../mind/diary");
+const record_paths_1 = require("../../mind/record-paths");
 const runtime_1 = require("../../nerves/runtime");
 const socket_client_1 = require("./socket-client");
-/** Format diary hits the same way the search_notes tool does. */
+/** Format diary hits the same way the search_facts tool does. */
 function formatDiaryHits(hits) {
     return hits.map((f) => `[diary] ${f.text} (source=${f.source}, createdAt=${f.createdAt})`);
 }
@@ -72,7 +73,7 @@ function readAgentFile(agent, ...segments) {
 }
 /** Resolve the diary root for a specific agent. */
 function agentDiaryRoot(agent) {
-    return (0, diary_1.resolveDiaryRoot)(path.join((0, identity_1.getAgentRoot)(agent), "diary"));
+    return (0, record_paths_1.resolveRecordDiaryRoot)((0, identity_1.getAgentRoot)(agent));
 }
 /** Read inner dialog runtime status. */
 function readInnerDialogStatus(agent) {
@@ -339,12 +340,12 @@ async function handleAgentAsk(params) {
         emit("daemon.agent_service_error", "agent.ask missing question", { agent: params.agent });
         return { ok: false, error: "Missing required parameter: question" };
     }
-    // Use the same searchDiaryEntries the search_notes tool uses (substring fallback — no embedding provider in shim)
+    // Use the same searchDiaryEntries the search_facts tool uses (substring fallback; no embedding provider in shim).
     const diaryRoot = agentDiaryRoot(params.agent);
     const hits = await (0, diary_1.searchDiaryEntries)(question, (0, diary_1.readDiaryEntries)(diaryRoot));
     const context = hits.length > 0
         ? hits.slice(0, 10).map((f) => f.text).join("\n")
-        : `No relevant notes found for: ${question}`;
+        : `No relevant facts found for: ${question}`;
     emit("daemon.agent_service_end", "completed agent.ask", { agent: params.agent });
     return { ok: true, message: context };
 }
@@ -393,17 +394,17 @@ async function handleAgentGetContext(params) {
     const innerStatus = readInnerDialogStatus(params.agent);
     const sessions = enumerateSessions(params.agent);
     const taskFiles = listTaskFiles(params.agent);
-    let noteSummary = null;
+    let recordSummary = null;
     if (query) {
         const hits = await (0, diary_1.searchDiaryEntries)(query, facts);
-        noteSummary = hits.length > 0
+        recordSummary = hits.length > 0
             ? hits.slice(0, 10).map((f) => f.text).join("\n")
-            : `No relevant notes for: ${query}`;
+            : `No relevant facts for: ${query}`;
     }
     else {
         const recent = facts.slice(-10);
         if (recent.length > 0)
-            noteSummary = recent.map((f) => f.text).join("\n");
+            recordSummary = recent.map((f) => f.text).join("\n");
     }
     emit("daemon.agent_service_end", "completed agent.getContext", { agent: params.agent });
     return {
@@ -412,25 +413,25 @@ async function handleAgentGetContext(params) {
             agent: params.agent,
             hasDiaryEntries: facts.length > 0,
             factCount: facts.length,
-            noteSummary,
+            recordSummary,
             taskCount: taskFiles.length,
             sessionCount: sessions.length,
             innerStatus: innerStatus?.status ?? null,
         },
     };
 }
-async function handleAgentSearchNotes(params) {
-    emit("daemon.agent_service_start", "handling agent.searchNotes", { agent: params.agent });
+async function handleAgentSearchFacts(params) {
+    emit("daemon.agent_service_start", "handling agent.searchFacts", { agent: params.agent });
     const query = params.query;
     if (!query) {
-        emit("daemon.agent_service_error", "agent.searchNotes missing query", { agent: params.agent });
+        emit("daemon.agent_service_error", "agent.searchFacts missing query", { agent: params.agent });
         return { ok: false, error: "Missing required parameter: query" };
     }
-    // Same searchDiaryEntries as the search_notes tool
+    // Same searchDiaryEntries as the search_facts tool.
     const diaryRoot = agentDiaryRoot(params.agent);
     const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)(diaryRoot));
     const formatted = formatDiaryHits(hits.slice(0, 20));
-    emit("daemon.agent_service_end", "completed agent.searchNotes", { agent: params.agent, matchCount: hits.length });
+    emit("daemon.agent_service_end", "completed agent.searchFacts", { agent: params.agent, matchCount: hits.length });
     return {
         ok: true,
         message: hits.length > 0 ? `Found ${hits.length} matches` : "No matches found",
@@ -481,7 +482,7 @@ async function handleAgentCheckGuidance(params) {
         emit("daemon.agent_service_error", "agent.checkGuidance missing topic", { agent: params.agent });
         return { ok: false, error: "Missing required parameter: topic" };
     }
-    // Same searchDiaryEntries as the search_notes tool
+    // Same searchDiaryEntries as the search_facts tool.
     const diaryRoot = agentDiaryRoot(params.agent);
     const hits = await (0, diary_1.searchDiaryEntries)(topic, (0, diary_1.readDiaryEntries)(diaryRoot));
     const guidance = hits.length > 0

package/dist/heart/daemon/cli-exec.js

@@ -365,6 +365,8 @@ function agentResolutionFailureMode(command) {
         case "attention.list":
         case "attention.show":
         case "attention.history":
+        case "work.card":
+        case "work.gauntlet":
         case "inner.status":
         case "session.list":
             return "return-message";
@@ -7277,6 +7279,30 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         }
     }
     /* v8 ignore stop */
+    // ── work card (local, no daemon socket needed) ──
+    if (command.kind === "work.card") {
+        const { buildWorkCard, formatWorkCardText } = await Promise.resolve().then(() => __importStar(require("../work-card")));
+        if (!command.agent)
+            throw new Error("work card requires --agent <name>");
+        const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        const agentRoot = deps.agentBundleRoot ?? path.join(bundlesRoot, `${command.agent}.ouro`);
+        const card = buildWorkCard(command.agent, agentRoot);
+        const message = command.format === "json" ? JSON.stringify(card, null, 2) : formatWorkCardText(card);
+        deps.writeStdout(message);
+        return message;
+    }
+    // ── context-loss gauntlet (local, no daemon socket needed) ──
+    if (command.kind === "work.gauntlet") {
+        const { runContextLossGauntlet, formatContextLossGauntletText } = await Promise.resolve().then(() => __importStar(require("../context-loss-gauntlet")));
+        if (!command.agent)
+            throw new Error("work gauntlet requires --agent <name>");
+        const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        const agentRoot = deps.agentBundleRoot ?? path.join(bundlesRoot, `${command.agent}.ouro`);
+        const report = runContextLossGauntlet(command.agent, agentRoot, { homeDir: deps.homeDir });
+        const message = command.format === "json" ? JSON.stringify(report, null, 2) : formatContextLossGauntletText(report);
+        deps.writeStdout(message);
+        return message;
+    }
     // ── inner dialog status (local, no daemon socket needed) ──
     /* v8 ignore start -- inner status handler: requires real agent state on disk @preserve */
     if (command.kind === "inner.status") {
@@ -7286,6 +7312,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             const { parseCadenceToMs: parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./cadence")));
             const { parseFrontmatter } = await Promise.resolve().then(() => __importStar(require("../../util/frontmatter")));
             const { listActiveReturnObligations } = await Promise.resolve().then(() => __importStar(require("../../arc/obligations")));
+            const { resolveDeskRecordPaths } = await Promise.resolve().then(() => __importStar(require("../../mind/record-paths")));
             // Read runtime state
             const innerSessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
             const runtimeJsonPath = path.join(path.dirname(innerSessionPath), "runtime.json");
@@ -7295,19 +7322,20 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 runtimeState = JSON.parse(raw);
             }
             catch { /* missing or corrupt — will show "unknown" */ }
-            // Read journal files
-            const journalDir = path.join(agentRoot, "journal");
-            let journalFiles = [];
+            // Read canonical Desk record summary
+            const recordPaths = resolveDeskRecordPaths(agentRoot);
+            const recordSummary = { diaryFactCount: 0, noteCount: 0 };
             try {
-                const journalEntries = fs.readdirSync(journalDir, { withFileTypes: true });
-                journalFiles = journalEntries
-                    .filter((e) => e.isFile() && !e.name.startsWith("."))
-                    .map((e) => {
-                    const stat = fs.statSync(path.join(journalDir, e.name));
-                    return { name: e.name, mtimeMs: stat.mtimeMs };
-                });
+                const rawFacts = fs.readFileSync(recordPaths.factsPath, "utf-8");
+                recordSummary.diaryFactCount = rawFacts.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+            }
+            catch { /* missing facts file — count stays zero */ }
+            try {
+                recordSummary.noteCount = fs.readdirSync(recordPaths.notesRoot, { withFileTypes: true })
+                    .filter((e) => e.isFile() && !e.name.startsWith(".") && e.name.endsWith(".md"))
+                    .length;
             }
-            catch { /* missing dir — will show (empty) */ }
+            catch { /* missing notes dir — count stays zero */ }
             // Read heartbeat cadence
             let heartbeat = null;
             try {
@@ -7342,7 +7370,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             const message = buildInnerStatusOutput({
                 agentName: command.agent,
                 runtimeState,
-                journalFiles,
+                recordSummary,
                 heartbeat,
                 attentionCount: activeObligations.length,
                 now: Date.now(),

package/dist/heart/daemon/cli-help.js

@@ -151,6 +151,27 @@ exports.COMMAND_REGISTRY = {
         example: "ouro task list",
         subcommands: ["list", "new", "done", "archive", "show"],
     },
+    work: {
+        category: "Tasks",
+        description: "Show durable Arc work state or run the context-loss gauntlet.",
+        usage: "ouro work card|gauntlet [--agent <name>] [--format text|json|--json]",
+        example: "ouro work gauntlet --agent slugger --format json",
+        subcommands: ["card", "gauntlet"],
+    },
+    "work card": {
+        category: "Tasks",
+        description: "Show the agent's durable Work Card compiled from arc records.",
+        usage: "ouro work card [--agent <name>] [--format text|json|--json]",
+        example: "ouro work card --agent slugger --format json",
+        hidden: true,
+    },
+    "work gauntlet": {
+        category: "Tasks",
+        description: "Score whether durable Arc, flight recorder, and Desk state can recover after context loss.",
+        usage: "ouro work gauntlet [--agent <name>] [--format text|json|--json]",
+        example: "ouro work gauntlet --agent slugger --format json",
+        hidden: true,
+    },
     "migrate-to-desk": {
         category: "Tasks",
         description: "Migrate a legacy `tasks/` tree into the new `desk/` shape (copy semantics — source untouched).",

package/dist/heart/daemon/cli-parse.js

@@ -114,6 +114,7 @@ function usage() {
         "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
         "  ouro friend update <id> --trust <level> [--agent <name>]",
         "  ouro thoughts [--last <n>] [--json] [--follow] [--agent <name>]",
+        "  ouro work card|gauntlet [--agent <name>] [--format text|json|--json]",
         "  ouro inner [--agent <name>]",
         "  ouro friend link <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro friend unlink <agent> --friend <id> --provider <p> --external-id <eid>",
@@ -1000,6 +1001,30 @@ function parseAttentionCommand(args) {
     }
     return { kind: "attention.list", ...(agent ? { agent } : {}) };
 }
+function parseWorkCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const sub = cleaned[0];
+    if (sub !== "card" && sub !== "gauntlet") {
+        throw new Error("Usage: ouro work card|gauntlet [--agent <name>] [--format text|json|--json]");
+    }
+    let format = "text";
+    for (let i = 1; i < cleaned.length; i += 1) {
+        if (cleaned[i] === "--json") {
+            format = "json";
+            continue;
+        }
+        if (cleaned[i] === "--format" && cleaned[i + 1]) {
+            const value = cleaned[++i];
+            if (value !== "text" && value !== "json") {
+                throw new Error("--format must be text or json");
+            }
+            format = value;
+            continue;
+        }
+        throw new Error(`Usage: ouro work ${sub} [--agent <name>] [--format text|json|--json]`);
+    }
+    return { kind: sub === "card" ? "work.card" : "work.gauntlet", ...(agent ? { agent } : {}), ...(format !== "text" ? { format } : {}) };
+}
 function parseThoughtsCommand(args) {
     const { agent, rest: cleaned } = extractAgentFlag(args);
     let last;
@@ -1583,6 +1608,8 @@ function parseOuroCommand(args) {
         return parseThoughtsCommand(args.slice(1));
     if (head === "attention")
         return parseAttentionCommand(args.slice(1));
+    if (head === "work")
+        return parseWorkCommand(args.slice(1));
     if (head === "inner") {
         const { agent } = extractAgentFlag(args.slice(1));
         return { kind: "inner.status", ...(agent ? { agent } : {}) };

package/dist/heart/daemon/daemon-entry.js

@@ -366,7 +366,7 @@ void daemon.start().then(() => {
                 habitsDir,
                 osCronManager,
                 onHabitFire: (habitName) => {
-                    processManager.sendToAgent(agent, { type: "habit", habitName });
+                    processManager.sendToAgent(agent, { type: "habit", habitName, trigger: "overdue" });
                 },
                 deps: {
                     readdir: (dir) => fs.readdirSync(dir),

package/dist/heart/daemon/daemon.js

@@ -1205,8 +1205,8 @@ class OuroDaemon {
                 return (0, agent_service_1.handleAgentDelegate)(command);
             case "agent.getContext":
                 return (0, agent_service_1.handleAgentGetContext)(command);
-            case "agent.searchNotes":
-                return (0, agent_service_1.handleAgentSearchNotes)(command);
+            case "agent.searchFacts":
+                return (0, agent_service_1.handleAgentSearchFacts)(command);
             case "agent.getTask":
                 return (0, agent_service_1.handleAgentGetTask)(command);
             case "agent.checkScope":
@@ -1298,7 +1298,7 @@ class OuroDaemon {
                 };
             }
             case "habit.poke": {
-                this.processManager.sendToAgent?.(command.agent, { type: "habit", habitName: command.habitName });
+                this.processManager.sendToAgent?.(command.agent, { type: "habit", habitName: command.habitName, trigger: "poke" });
                 return {
                     ok: true,
                     message: `poked habit ${command.habitName} for ${command.agent}`,