@ouro.bot/cli 0.1.0-alpha.767 → 0.1.0-alpha.769

package/dist/heart/external-events/router.js

@@ -45,6 +45,8 @@ exports.claimExternalEvent = claimExternalEvent;
 exports.renewExternalEventClaim = renewExternalEventClaim;
 exports.commitExternalEventDisposition = commitExternalEventDisposition;
 exports.failExternalEventAttempt = failExternalEventAttempt;
+exports.externalEventRecoveryFailure = externalEventRecoveryFailure;
+exports.reviveExternalEventAfterRecovery = reviveExternalEventAfterRecovery;
 exports.reconcileExternalEvent = reconcileExternalEvent;
 exports.advanceExternalEventFromAwait = advanceExternalEventFromAwait;
 exports.advanceExternalEventsFromAwait = advanceExternalEventsFromAwait;
@@ -305,11 +307,19 @@ function isRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const candidate = value;
+    const failure = candidate.failureProvenance;
+    const grant = candidate.recoveryGrant;
+    const validFailure = failure === undefined || (failure !== null && typeof failure === "object"
+        && (failure.class === "provider_lane_unavailable" || failure.class === "managed_runtime_unavailable") && canonicalIso(failure.failedAt));
+    const validGrant = grant === undefined || (grant !== null && typeof grant === "object"
+        && Number.isSafeInteger(grant.generation) && grant.generation === candidate.generation && canonicalIso(grant.consumedAt));
     return candidate.schemaVersion === 2
         && typeof candidate.recordPath === "string"
         && Number.isSafeInteger(candidate.version)
         && Number.isSafeInteger(candidate.generation)
-        && typeof candidate.observationRevision === "string";
+        && typeof candidate.observationRevision === "string"
+        && validFailure
+        && validGrant;
 }
 function readExternalEventRecord(recordPath) {
     const parsed = JSON.parse(fs.readFileSync(recordPath, "utf8"));
@@ -359,6 +369,8 @@ function listExternalEventStatus(root) {
                         careId: record.disposition?.careId ?? null,
                         awaitId: record.disposition?.awaitId ?? null,
                         lastError: record.lastError,
+                        failureProvenance: record.failureProvenance ?? null,
+                        recoveryGrant: record.recoveryGrant ?? null,
                         nextAttemptAt: record.nextAttemptAt,
                         claimOwner: record.claimOwner,
                         claimExpiresAt: record.claimExpiresAt,
@@ -390,6 +402,8 @@ function listExternalEventStatus(root) {
                         careId: null,
                         awaitId: null,
                         lastError: `invalid receipt: ${error instanceof Error ? error.message : /* v8 ignore next -- filesystem and JSON parsers throw Error objects @preserve */ String(error)}`,
+                        failureProvenance: null,
+                        recoveryGrant: null,
                         nextAttemptAt: null,
                         claimOwner: null,
                         claimExpiresAt: null,
@@ -533,6 +547,8 @@ function recordExternalEventInternal(input, options = {}) {
                     claimExpiresAt: shouldWake || quietInitialReceipt ? null : existing.claimExpiresAt,
                     nextAttemptAt: shouldWake || quietInitialReceipt ? null : existing.nextAttemptAt,
                     lastError: shouldWake || quietInitialReceipt ? null : existing.lastError,
+                    ...(!shouldWake && !quietInitialReceipt && existing?.failureProvenance ? { failureProvenance: existing.failureProvenance } : {}),
+                    ...(!shouldWake && !quietInitialReceipt && existing?.recoveryGrant ? { recoveryGrant: existing.recoveryGrant } : {}),
                     disposition: shouldWake || quietInitialReceipt ? null : existing.disposition,
                     pendingObservation: shouldWake || quietInitialReceipt ? null : existing.pendingObservation,
                     dispatchEnabled: options.dispatchEnabled ?? existing?.dispatchEnabled ?? true,
@@ -1032,12 +1048,13 @@ function commitExternalEventDisposition(recordPath, input) {
             disposition: wakePending ? null : input.disposition,
             pendingObservation: null,
             pendingPrivilegedProtectiveAction: undefined,
+            ...(wakePending ? { failureProvenance: undefined, recoveryGrant: undefined } : {}),
             shouldWake: wakePending,
         }, now);
     });
 }
-function retryState(record, now, maxAttempts, baseDelayMs, error) {
-    const dead = record.attemptCount >= maxAttempts;
+function retryState(record, now, maxAttempts, baseDelayMs, error, failureClass) {
+    const dead = record.recoveryGrant?.generation === record.generation || record.attemptCount >= maxAttempts;
     return {
         ...record,
         executionState: dead ? "dead_letter" : "retry_wait",
@@ -1045,6 +1062,7 @@ function retryState(record, now, maxAttempts, baseDelayMs, error) {
         claimExpiresAt: null,
         nextAttemptAt: dead ? null : new Date(Date.parse(now) + baseDelayMs * 2 ** Math.max(0, record.attemptCount - 1)).toISOString(),
         lastError: error.slice(0, 1_000),
+        ...(dead && failureClass && !record.failureProvenance ? { failureProvenance: { class: failureClass, failedAt: now } } : {}),
         shouldWake: false,
     };
 }
@@ -1055,9 +1073,73 @@ function failExternalEventAttempt(recordPath, input) {
         const now = input.now?.() ?? new Date().toISOString();
         const maxAttempts = input.maxAttempts ?? 5;
         const baseDelayMs = input.baseDelayMs ?? 1_000;
+        if (input.failureClass !== undefined && input.failureClass !== "provider_lane_unavailable" && input.failureClass !== "managed_runtime_unavailable")
+            throw new Error("External event failure class is invalid");
         if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1 || !Number.isSafeInteger(baseDelayMs) || baseDelayMs < 1)
             throw new Error("External event retry policy is invalid");
-        return commitMutation(recordPath, retryState(record, now, maxAttempts, baseDelayMs, input.error), now);
+        return commitMutation(recordPath, retryState(record, now, maxAttempts, baseDelayMs, input.error, input.failureClass), now);
+    });
+}
+function exactLegacyProviderFailure(record) {
+    const escapedAgent = record.agent.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const canonical = new RegExp(`^private-runtime wake denied for ${escapedAgent}: provider lane resolution failed$`, "u");
+    return record.lastError && canonical.test(record.lastError)
+        ? { class: "provider_lane_unavailable", failedAt: record.updatedAt }
+        : null;
+}
+function externalEventRecoveryFailure(record) {
+    return record.failureProvenance ?? exactLegacyProviderFailure(record);
+}
+function recoveryIneligible(record, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.external_event_recovery_ineligible",
+        message: "external event dead-letter recovery was ineligible or exhausted",
+        meta: { agent: record.agent, source: record.source, eventId: record.eventId, generation: record.generation, reason },
+    });
+    return { revived: false, reason, record };
+}
+function reviveExternalEventAfterRecovery(recordPath, input) {
+    return withRecordLock(recordPath, () => {
+        const record = readExternalEventRecord(recordPath);
+        assertCas(record, input);
+        if (input.evidence.class !== "provider_lane_unavailable" && input.evidence.class !== "managed_runtime_unavailable")
+            throw new Error("External event recovery evidence class is invalid");
+        if (!canonicalIso(input.evidence.observedAt))
+            throw new Error("External event recovery evidence time is invalid");
+        if (record.executionState !== "dead_letter")
+            return recoveryIneligible(record, "not_dead_letter");
+        if (record.dispatchEnabled === false)
+            return recoveryIneligible(record, "dispatch_disabled");
+        if (record.recoveryGrant?.generation === record.generation)
+            return recoveryIneligible(record, "grant_consumed");
+        const failure = externalEventRecoveryFailure(record);
+        if (!failure)
+            return recoveryIneligible(record, "ineligible_failure");
+        if (failure.class !== input.evidence.class)
+            return recoveryIneligible(record, "evidence_mismatch");
+        if (Date.parse(input.evidence.observedAt) <= Date.parse(failure.failedAt))
+            return recoveryIneligible(record, "stale_evidence");
+        const now = input.now?.() ?? new Date().toISOString();
+        if (!canonicalIso(now))
+            throw new Error("External event recovery grant consumed time is invalid");
+        const revived = commitMutation(recordPath, {
+            ...record,
+            executionState: "queued",
+            claimOwner: null,
+            claimExpiresAt: null,
+            nextAttemptAt: null,
+            shouldWake: true,
+            failureProvenance: failure,
+            recoveryGrant: { generation: record.generation, consumedAt: now },
+        }, now);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.external_event_requeued",
+            message: "requeued external event after infrastructure recovery",
+            meta: { agent: revived.agent, source: revived.source, eventId: revived.eventId, generation: revived.generation, failureClass: failure.class },
+        });
+        return { revived: true, record: revived };
     });
 }
 function reconcileExternalEvent(recordPath, options = {}) {
@@ -1084,6 +1166,8 @@ function advanceExternalEventFromAwait(recordPath, input) {
             generation: record.generation + 1,
             executionState: "queued",
             attemptCount: 0,
+            failureProvenance: undefined,
+            recoveryGrant: undefined,
             disposition: null,
             shouldWake: true,
         }, now);

package/dist/heart/private-runtime/decision-renderer.js

@@ -57,6 +57,7 @@ function sanitizePrivateDecision(row, ledgerPath) {
         ? row
         : {};
     const deniedReason = stringField(record.deniedReason);
+    const denialCode = record.denialCode === "provider_lane_unavailable" ? record.denialCode : undefined;
     const duplicateOf = stringField(record.duplicateOf);
     const error = stringField(record.error);
     return {
@@ -76,6 +77,7 @@ function sanitizePrivateDecision(row, ledgerPath) {
         decidedAt: stringField(record.decidedAt),
         ledgerLocator: ledgerLocatorField(record.ledgerLocator, ledgerPath),
         ...(deniedReason ? { deniedReason } : {}),
+        ...(denialCode ? { denialCode } : {}),
         ...(duplicateOf ? { duplicateOf } : {}),
         ...(error ? { error } : {}),
     };

package/dist/heart/private-runtime/ledger.js

@@ -137,6 +137,7 @@ function mismatchDecision(candidate, existing) {
         result: "deny",
         executable: false,
         deniedReason: "idempotency-key fingerprint mismatch",
+        denialCode: undefined,
         duplicateOf: existing.receiptId,
     };
 }
@@ -159,6 +160,7 @@ function ledgerWriteFailedDecision(candidate, ledgerPath, error) {
         result: "deny",
         executable: false,
         deniedReason: "ledger write failed",
+        denialCode: undefined,
         ledgerLocator: { path: ledgerPath },
         error: String(error),
     };
@@ -194,7 +196,8 @@ function recordPrivateTurnDecision(decision, deps = {}) {
             if (latestSameFingerprint
                 && latestSameFingerprint.result === candidate.result
                 && latestSameFingerprint.executable === candidate.executable
-                && latestSameFingerprint.deniedReason === candidate.deniedReason) {
+                && latestSameFingerprint.deniedReason === candidate.deniedReason
+                && latestSameFingerprint.denialCode === candidate.denialCode) {
                 return latestSameFingerprint;
             }
             if (priorExecutable && !candidate.executable) {

package/dist/heart/private-runtime/policy.js

@@ -167,12 +167,6 @@ async function requestPrivateTurnDecision(request, deps = {}) {
     let evaluation;
     try {
         providerLane = await resolveProviderLaneMetadata(normalizedRequest, deps);
-        requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
-        evaluation = await evaluatePolicy(normalizedRequest, {
-            requestFingerprint,
-            idempotencyKey,
-            providerLane,
-        }, deps);
     }
     catch (error) {
         providerLane = {
@@ -181,13 +175,30 @@ async function requestPrivateTurnDecision(request, deps = {}) {
             model: "-",
             source: "agent.json",
         };
-        requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
         evaluation = {
             result: "deny",
             reason: error instanceof Error ? error.message : String(error),
             deniedReason: "provider lane resolution failed",
+            denialCode: "provider_lane_unavailable",
         };
     }
+    requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
+    if (evaluation === undefined) {
+        try {
+            evaluation = await evaluatePolicy(normalizedRequest, {
+                requestFingerprint,
+                idempotencyKey,
+                providerLane,
+            }, deps);
+        }
+        catch (error) {
+            evaluation = {
+                result: "deny",
+                reason: error instanceof Error ? error.message : String(error),
+                deniedReason: "private runtime policy evaluation failed",
+            };
+        }
+    }
     const result = evaluation.result;
     emitPolicyEvaluated(deps, { request: normalizedRequest, result, requestFingerprint, idempotencyKey });
     const reason = evaluation.reason ?? normalizedRequest.reason;
@@ -208,7 +219,10 @@ async function requestPrivateTurnDecision(request, deps = {}) {
         executable: result === "allow",
         decidedAt: nowIso(deps),
         ledgerLocator: { path: deps.ledgerPath ?? "" },
-        ...(result === "deny" ? { deniedReason: evaluation.deniedReason ?? reason } : {}),
+        ...(result === "deny" ? {
+            deniedReason: evaluation.deniedReason ?? reason,
+            ...(evaluation.denialCode ? { denialCode: evaluation.denialCode } : {}),
+        } : {}),
     };
     return (0, ledger_1.recordPrivateTurnDecision)(decision, deps);
 }

package/dist/heart/start-of-turn-packet.js

@@ -42,6 +42,7 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 const bundle_state_1 = require("./bundle-state");
 const tempo_1 = require("./tempo");
+const cares_1 = require("../arc/cares");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("./context-loss-sentinel");
 const orientation_frame_1 = require("./orientation-frame");
@@ -82,11 +83,14 @@ function buildObligationsSection(obligations) {
     })
         .join("\n");
 }
-function buildCaresSection(cares) {
+function buildCaresSection(cares, now) {
     if (cares.length === 0)
         return "";
     return cares
-        .map((c) => {
+        .map((care) => {
+        const c = (0, cares_1.projectCareEvidence)(care, now);
+        if ("recheckRequired" in c)
+            return `- system care [${c.salience}] evidence stale; recheck required`;
         const parts = [`- ${c.label}`];
         if (c.salience !== "low") {
             parts.push(` [${c.salience}]`);
@@ -192,7 +196,7 @@ function buildStartOfTurnPacket(view, opts) {
     const packet = {
         plotLine: buildPlotLine(view.recentEpisodes, tempo),
         obligations: buildObligationsSection(effectiveObligations),
-        cares: buildCaresSection(view.activeCares),
+        cares: buildCaresSection(view.activeCares, opts?.careEvidenceNow ?? Date.now()),
         presence: buildPresenceSection(view.peerPresence),
         arcResume: opts?.flightRecorderResume ? (0, flight_recorder_1.formatFlightRecorderResume)(opts.flightRecorderResume) : undefined,
         recoverySentinel: opts?.recoverySentinel,

package/dist/repertoire/tools-continuity.js

@@ -45,24 +45,6 @@ const presence_1 = require("../arc/presence");
 const intentions_1 = require("../arc/intentions");
 const steward_policy_1 = require("../heart/steward-policy");
 const await_parser_1 = require("../heart/awaiting/await-parser");
-function presentCare(care) {
-    const staleAt = care.nextCheckAt ? Date.parse(care.nextCheckAt) : Number.NaN;
-    if (care.kind !== "system" || !["active", "watching"].includes(care.status) || care.nextCheckAt === null)
-        return care;
-    if (Number.isFinite(staleAt) && staleAt >= Date.now())
-        return care;
-    return {
-        id: care.id,
-        kind: care.kind,
-        status: care.status,
-        salience: care.salience,
-        steward: care.steward,
-        evidenceStatus: "stale",
-        recheckRequired: true,
-        staleAt: care.nextCheckAt,
-        lastAssessedAt: care.updatedAt,
-    };
-}
 exports.continuityToolDefinitions = [
     // ── Continuity tools ──────────────────────────────────────────────
     {
@@ -326,7 +308,8 @@ exports.continuityToolDefinitions = [
         },
         handler: (a) => {
             const agentRoot = (0, identity_1.getAgentRoot)();
-            const cares = (a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot)).map(presentCare);
+            const now = Date.now();
+            const cares = (a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot)).map((care) => (0, cares_1.projectCareEvidence)(care, now));
             (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_cares", message: `queried ${cares.length} cares`, meta: { count: cares.length } });
             return JSON.stringify(cares, null, 2);
         },
@@ -346,6 +329,7 @@ exports.continuityToolDefinitions = [
                         why: { type: "string", description: "Why this matters" },
                         salience: { type: "string", description: "low, medium, high, or critical" },
                         kind: { type: "string", description: "person, agent, project, mission, or system" },
+                        status: { type: "string", enum: ["active", "watching", "resolved", "dormant"], description: "active, watching, resolved, or dormant" },
                         stewardship: { type: "string", description: "mine, shared, or delegated" },
                         source: { type: "string", description: "Machine evidence source for an incident binding" },
                         incidentKey: { type: "string", description: "Stable incident key within the source" },
@@ -367,7 +351,7 @@ exports.continuityToolDefinitions = [
                     label: a.label ?? "untitled",
                     why: a.why ?? "",
                     kind: a.kind ?? "project",
-                    status: "active",
+                    status: a.status ?? "active",
                     salience: a.salience ?? "medium",
                     steward: a.stewardship ?? "mine",
                     relatedFriendIds: [],
@@ -412,22 +396,33 @@ exports.continuityToolDefinitions = [
                     source: a.source,
                     incidentKey: a.incidentKey,
                     expectedUpdatedAt: a.expectedUpdatedAt,
+                    ...((a.label !== undefined || a.why !== undefined || a.currentRisk !== undefined || a.nextCheckAt !== undefined) ? {
+                        display: {
+                            ...(a.label !== undefined ? { label: String(a.label) } : {}),
+                            ...(a.why !== undefined ? { why: String(a.why) } : {}),
+                            ...(a.currentRisk !== undefined ? { currentRisk: a.currentRisk ? String(a.currentRisk) : null } : {}),
+                            ...(a.nextCheckAt !== undefined ? { nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null } : {}),
+                        },
+                    } : {}),
                 });
             }
             else if (a.action === "upsert_incident") {
                 result = (0, cares_1.upsertCareForIncident)(agentRoot, {
-                    label: a.label ?? "untitled",
-                    why: a.why ?? "",
-                    kind: a.kind ?? "system",
-                    status: "active",
-                    salience: a.salience ?? "medium",
-                    steward: a.stewardship ?? "mine",
+                    ...(a.id ? { id: String(a.id) } : {}),
+                    ...(!a.id ? {
+                        label: a.label ?? "untitled", why: a.why ?? "", kind: a.kind ?? "system", status: a.status ?? "active",
+                        salience: a.salience ?? "medium", steward: a.stewardship ?? "mine",
+                    } : {
+                        ...(a.label !== undefined ? { label: String(a.label) } : {}), ...(a.why !== undefined ? { why: String(a.why) } : {}),
+                        ...(a.kind !== undefined ? { kind: a.kind } : {}), ...(a.status !== undefined ? { status: a.status } : {}),
+                        ...(a.salience !== undefined ? { salience: a.salience } : {}), ...(a.stewardship !== undefined ? { steward: a.stewardship } : {}),
+                    }),
                     relatedFriendIds: [],
                     relatedAgentIds: [],
                     relatedObligationIds: [],
                     relatedEpisodeIds: [],
-                    currentRisk: a.currentRisk ? String(a.currentRisk) : null,
-                    nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null,
+                    ...(!a.id || a.currentRisk !== undefined ? { currentRisk: a.currentRisk ? String(a.currentRisk) : null } : {}),
+                    ...(!a.id || a.nextCheckAt !== undefined ? { nextCheckAt: a.nextCheckAt ? String(a.nextCheckAt) : null } : {}),
                     ...(a.expectedUpdatedAt ? { expectedUpdatedAt: String(a.expectedUpdatedAt) } : {}),
                     incident: {
                         source: a.source,

package/dist/senses/pipeline.js

@@ -72,6 +72,7 @@ const provider_visibility_1 = require("../heart/provider-visibility");
 const orientation_frame_1 = require("../heart/orientation-frame");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("../heart/context-loss-sentinel");
+const cares_1 = require("../arc/cares");
 const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
 function pendingExpirationReason(channel, message, now) {
     /* v8 ignore start -- pending expiry edge permutations are covered by the stale voice queue tests; this helper keeps defensive non-voice fallbacks @preserve */
@@ -809,11 +810,14 @@ async function handleInboundTurn(input) {
                 : undefined);
         // Step 4b: Continuity pipeline — derive tempo, build start-of-turn packet, snapshot obligations
         let renderedStartOfTurnPacket;
+        const careEvidenceNow = Date.now();
+        const activeCaresSnapshot = ctx.activeCares;
         const preTurnObligationIds = new Set(pendingObligations.map((ob) => `${ob.id}:${ob.status}`));
         try {
             const agentRoot = (0, identity_1.getAgentRoot)();
             const agentName = (0, identity_1.getAgentName)();
-            const { recentEpisodes, activeCares } = ctx;
+            const { recentEpisodes } = ctx;
+            const projectedCares = activeCaresSnapshot.map((care) => (0, cares_1.projectCareEvidence)(care, careEvidenceNow));
             const tempoState = (0, tempo_1.deriveTempo)({
                 activeSessions: sessionActivity.length + 1,
                 openObligations: pendingObligations.length,
@@ -823,15 +827,15 @@ async function handleInboundTurn(input) {
                     : 0,
                 hasBlockers: false, // obligations use specific statuses, not "blocked"
                 highSalienceEpisodes: recentEpisodes.filter((ep) => ep.salience === "high" || ep.salience === "critical").length,
-                activeCareCount: activeCares.length,
-                atRiskCareCount: activeCares.filter((c) => c.currentRisk != null).length,
+                activeCareCount: activeCaresSnapshot.length,
+                atRiskCareCount: projectedCares.filter((care) => !("recheckRequired" in care) && care.currentRisk != null).length,
             });
             const temporalView = (0, temporal_view_1.buildTemporalView)(agentRoot, {
                 tempo: tempoState.mode,
                 preloaded: {
                     recentEpisodes,
                     activeObligations: pendingObligations,
-                    activeCares,
+                    activeCares: activeCaresSnapshot,
                 },
             });
             const startOfTurnPacket = (0, start_of_turn_packet_1.buildStartOfTurnPacket)(temporalView, {
@@ -843,6 +847,7 @@ async function handleInboundTurn(input) {
                 friendContactTiming,
                 flightRecorderResume: ctx.flightRecorderResume,
                 recoverySentinel: ctx.recoverySentinel,
+                careEvidenceNow,
             });
             /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
             if (syncFailure) {
@@ -928,6 +933,8 @@ async function handleInboundTurn(input) {
             currentUserMessages,
             resolvedContext,
             runAgentOptions,
+            activeCares: activeCaresSnapshot,
+            careEvidenceNow,
         }));
         const checkpointCurrentAsk = selectCheckpointCurrentAsk({
             currentUserMessage: runAgentOptions.toolContext?.currentUserMessage ?? currentUserMessage,