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

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

@@ -0,0 +1,810 @@
+"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.HabitCancellationError = exports.HISTORICAL_HABIT_EVIDENCE_BRIDGE_SHA256 = void 0;
+exports.resolveHistoricalHabitEvidenceBridgeTrust = resolveHistoricalHabitEvidenceBridgeTrust;
+exports.renderHabitCancellationAcknowledgement = renderHabitCancellationAcknowledgement;
+exports.validateHabitEvidenceBridge = validateHabitEvidenceBridge;
+exports.cancelHabit = cancelHabit;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const semantic_receipts_1 = require("../../senses/bluebubbles/semantic-receipts");
+const habit_parser_1 = require("./habit-parser");
+const habit_lifecycle_1 = require("./habit-lifecycle");
+const CAPTURE_LOCATOR_PATTERN = /^capture:([a-f0-9]{64})$/;
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const BRIDGE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const ISO_MILLISECONDS_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const retainedCancellationLeases = new Map();
+exports.HISTORICAL_HABIT_EVIDENCE_BRIDGE_SHA256 = "34a90f6ce3f7b092edb8114cf7ab640486fd7e6d7667acfd0249408fff394201";
+function resolveHistoricalHabitEvidenceBridgeTrust(bridgeSha256, actorDisplayName) {
+    if (bridgeSha256 !== exports.HISTORICAL_HABIT_EVIDENCE_BRIDGE_SHA256)
+        return null;
+    return {
+        cancellationReason: `Confirmed requester ${actorDisplayName} asked to end the RSVP report after the wedding.`,
+    };
+}
+class HabitCancellationError extends Error {
+    code;
+    constructor(code, options = {}) {
+        super(code, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "HabitCancellationError";
+        this.code = code;
+    }
+}
+exports.HabitCancellationError = HabitCancellationError;
+function renderHabitCancellationAcknowledgement(habitId, actorDisplayName, boundaryState) {
+    return (0, habit_lifecycle_1.renderHabitCancellationAcknowledgement)(habitId, actorDisplayName, boundaryState);
+}
+function validateHabitEvidenceBridge(input, deps = {}) {
+    const storeFs = deps.fs ?? fs;
+    const agentRoot = requiredString(input.agentRoot, "bridge_agent_root_required");
+    const bridgeId = validatedBridgeId(input.bridgeId);
+    const bridgeRoot = path.join(agentRoot, "state", "senses", "bluebubbles", "evidence-bridges");
+    const bridgePath = path.join(bridgeRoot, `${bridgeId}.json`);
+    const bridgeBytes = readUtf8(storeFs, bridgePath, "bridge_evidence_missing");
+    const bridgeSha256 = sha256(bridgeBytes);
+    const value = parseJsonRecord(bridgeBytes, "bridge_evidence_invalid");
+    if ((0, habit_lifecycle_1.serializeHabitLifecycleJson)(value) !== bridgeBytes) {
+        throw new HabitCancellationError("bridge_evidence_not_canonical");
+    }
+    requireExactKeys(value, [
+        "schemaVersion",
+        "bridgeId",
+        "sourceKind",
+        "createdAt",
+        "confirmedAt",
+        "actor",
+        "participants",
+        "request",
+        "evidence",
+    ], "bridge_evidence_invalid");
+    if (value.schemaVersion !== 1
+        || value.bridgeId !== bridgeId
+        || value.sourceKind !== "operator_confirmation"
+        || !isCanonicalTimestamp(value.createdAt)
+        || value.confirmedAt !== value.createdAt)
+        throw new HabitCancellationError("bridge_evidence_invalid");
+    const actor = requiredRecord(value.actor, "bridge_actor_invalid");
+    requireExactKeys(actor, ["displayName", "provider", "externalId"], "bridge_actor_invalid");
+    const actorDisplayName = requiredSingleLine(actor.displayName, "bridge_actor_invalid");
+    if (actor.provider !== null || actor.externalId !== null) {
+        throw new HabitCancellationError("bridge_actor_invalid");
+    }
+    const trusted = deps.trustedBridge
+        ? deps.trustedBridge(bridgeId, bridgeSha256)
+        : resolveHistoricalHabitEvidenceBridgeTrust(bridgeSha256, actorDisplayName);
+    if (!trusted)
+        throw new HabitCancellationError("bridge_trust_rejected");
+    const cancellationReason = requiredSingleLine(trusted.cancellationReason, "bridge_cancellation_reason_invalid");
+    if (!Array.isArray(value.participants) || value.participants.length === 0) {
+        throw new HabitCancellationError("bridge_participants_invalid");
+    }
+    for (const participantValue of value.participants) {
+        const participant = requiredRecord(participantValue, "bridge_participants_invalid");
+        requireExactKeys(participant, ["displayName", "provider", "externalId", "role"], "bridge_participants_invalid");
+        requiredSingleLine(participant.displayName, "bridge_participants_invalid");
+        if (participant.provider !== null
+            || participant.externalId !== null
+            || participant.role !== "group_participant_only")
+            throw new HabitCancellationError("bridge_participants_invalid");
+    }
+    const request = requiredRecord(value.request, "bridge_request_invalid");
+    requireExactKeys(request, ["eventGuid", "text", "sha256"], "bridge_request_invalid");
+    const eventGuid = requiredString(request.eventGuid, "bridge_request_invalid");
+    const requestText = requiredString(request.text, "bridge_request_invalid");
+    const requestSha256 = validatedHash(request.sha256, "bridge_request_invalid");
+    if (sha256(requestText) !== requestSha256) {
+        throw new HabitCancellationError("bridge_request_invalid");
+    }
+    const evidence = requiredRecord(value.evidence, "bridge_evidence_invalid");
+    requireExactKeys(evidence, ["operatorConfirmation", "screenshots", "sources"], "bridge_evidence_invalid");
+    validateOperatorConfirmation(bridgeRoot, evidence.operatorConfirmation, storeFs);
+    validateBridgeScreenshots(bridgeRoot, evidence.screenshots, storeFs);
+    validateBridgeSources({
+        value: evidence.sources,
+        eventGuid,
+        requestText,
+        requestSha256,
+        storeFs,
+    });
+    return {
+        locator: { kind: "bridge", id: bridgeId },
+        actor: { displayName: actorDisplayName, provider: null, externalId: null },
+        request: {
+            text: requestText,
+            sha256: requestSha256,
+            observedAt: value.confirmedAt,
+        },
+        cancellationReason,
+    };
+}
+async function cancelHabit(input, deps = {}) {
+    let operationId = null;
+    let evidenceKeyHash = null;
+    let started = false;
+    try {
+        const locator = validatedCancellationLocator(input);
+        const identity = (0, habit_lifecycle_1.buildHabitEvidenceIdentity)({
+            habitId: input.habitId,
+            kind: locator.kind,
+            id: locator.id,
+        });
+        evidenceKeyHash = identity.evidenceKeyHash;
+        operationId = (0, habit_lifecycle_1.buildHabitCancellationOperation)(evidenceKeyHash).operationId;
+        emitHabitCancellationStart(input.habitId, operationId, evidenceKeyHash);
+        started = true;
+        readDefinitionSnapshot(input.agentRoot, input.habitId, deps);
+        const preflightJournal = (0, habit_lifecycle_1.readHabitLifecycleJournal)({
+            agentRoot: input.agentRoot,
+            habitId: input.habitId,
+            operationId,
+        }, deps);
+        const initialEvidence = preflightJournal?.state === "cancellation_receipt_committed"
+            ? null
+            : resolveCancellationEvidence(input, deps);
+        const leaseKey = cancellationLeaseKey(input.agentRoot, input.habitId, operationId);
+        let lease = retainedCancellationLeases.get(leaseKey);
+        if (lease && !(0, habit_lifecycle_1.habitLifecycleLeaseIsCurrent)(lease, deps)) {
+            retainedCancellationLeases.delete(leaseKey);
+            lease = undefined;
+        }
+        if (!lease) {
+            const lock = await (0, habit_lifecycle_1.acquireHabitLifecycleLock)({
+                agentRoot: input.agentRoot,
+                habitId: input.habitId,
+                operationId,
+            }, deps);
+            if (lock.status !== "acquired") {
+                throw new HabitCancellationError(lock.error);
+            }
+            lease = lock.lease;
+        }
+        let receipt = null;
+        let primaryError;
+        try {
+            let evidence = null;
+            if (initialEvidence !== null) {
+                evidence = resolveCancellationEvidence(input, deps);
+                if ((0, habit_lifecycle_1.serializeHabitLifecycleJson)(evidence) !== (0, habit_lifecycle_1.serializeHabitLifecycleJson)(initialEvidence)) {
+                    throw new HabitCancellationError("cancellation_evidence_changed");
+                }
+            }
+            const definition = readDefinitionSnapshot(input.agentRoot, input.habitId, deps);
+            receipt = executeCancellationUnderLock({
+                lease,
+                definition,
+                evidence,
+                evidenceKeyHash,
+                operationId,
+            }, deps);
+        }
+        catch (error) {
+            primaryError = error;
+        }
+        let releaseError;
+        try {
+            await releaseCancellationLease(leaseKey, lease, deps);
+        }
+        catch (error) {
+            releaseError = error;
+        }
+        if (primaryError !== undefined)
+            throw primaryError;
+        if (releaseError !== undefined)
+            throw releaseError;
+        // executeCancellationUnderLock either returns a receipt or supplies primaryError.
+        const completedReceipt = receipt;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "habit_cancel_end",
+            message: "grounded habit cancellation completed",
+            meta: {
+                habitId: input.habitId,
+                operationId,
+                evidenceKeyHash,
+                boundaryState: completedReceipt.transition.boundaryState,
+            },
+        });
+        return completedReceipt;
+    }
+    catch (error) {
+        const wrapped = asCancellationError(error);
+        if (!started)
+            emitHabitCancellationStart(input.habitId, operationId, evidenceKeyHash);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "habit_cancel_error",
+            message: "grounded habit cancellation failed",
+            meta: {
+                habitId: input.habitId,
+                operationId,
+                evidenceKeyHash,
+                errorCode: wrapped.code,
+            },
+        });
+        throw wrapped;
+    }
+}
+function emitHabitCancellationStart(habitId, operationId, evidenceKeyHash) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "habit_cancel_start",
+        message: "grounded habit cancellation started",
+        meta: { habitId, operationId, evidenceKeyHash },
+    });
+}
+function executeCancellationUnderLock(input, deps) {
+    const { lease, evidence, evidenceKeyHash, operationId } = input;
+    let definition = input.definition;
+    let journal = (0, habit_lifecycle_1.readHabitLifecycleJournal)({
+        agentRoot: lease.agentRoot,
+        habitId: lease.habitId,
+        operationId,
+    }, deps);
+    const existingReceipt = (0, habit_lifecycle_1.readHabitLifecycleReceipt)({
+        agentRoot: lease.agentRoot,
+        habitId: lease.habitId,
+        evidenceKeyHash,
+    }, deps);
+    if (journal?.state === "cancellation_receipt_committed") {
+        if (!existingReceipt) {
+            throw new HabitCancellationError("cancellation_committed_state_invalid");
+        }
+        const committedPreparation = journal.cancellationPreparation;
+        assertPreparedReceipt(existingReceipt, committedPreparation.receipt, null);
+        if (definition.status !== "cancelled") {
+            throw new HabitCancellationError("cancellation_definition_state_invalid");
+        }
+        assertDefinitionMatches(definition.bytes, committedPreparation.definitionCancelledSha256);
+        confirmCancellationDurability(lease, definition.path, evidenceKeyHash, operationId, deps);
+        return existingReceipt;
+    }
+    if (evidence === null)
+        throw new HabitCancellationError("cancellation_evidence_required");
+    if (journal === null || journal.state === "lock_acquired") {
+        if (existingReceipt)
+            throw new HabitCancellationError("cancellation_receipt_without_intent");
+        if (definition.status !== "active" && definition.status !== "paused") {
+            throw new HabitCancellationError("habit_definition_already_cancelled");
+        }
+        const cancelledAt = cancellationNow(deps);
+        const boundaryState = classifyConcurrentSendBoundary(lease.agentRoot, lease.habitId, evidence.request.observedAt, cancelledAt, deps);
+        const cancelledBytes = renderCancelledDefinition(definition, evidence.locator, evidence.cancellationReason, cancelledAt);
+        const receipt = buildCancellationReceipt({
+            habitId: lease.habitId,
+            operationId,
+            evidenceKeyHash,
+            evidence,
+            fromStatus: definition.status,
+            cancelledAt,
+            boundaryState,
+        });
+        const preparation = {
+            receipt,
+            definitionBeforeSha256: sha256(definition.bytes),
+            definitionCancelledSha256: sha256(cancelledBytes),
+        };
+        if (journal === null) {
+            journal = (0, habit_lifecycle_1.createHabitLifecycleJournal)({
+                habitId: lease.habitId,
+                operationId,
+                operationKind: "cancel",
+                updatedAt: cancelledAt,
+            });
+            (0, habit_lifecycle_1.writeHabitLifecycleJournal)(lease, journal, deps);
+        }
+        journal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(journal, {
+            state: "cancellation_intent",
+            at: cancelledAt,
+            evidenceKeyHash,
+            cancellationPreparation: preparation,
+        });
+        (0, habit_lifecycle_1.writeHabitLifecycleJournal)(lease, journal, deps);
+    }
+    const preparation = journal.cancellationPreparation;
+    assertPreparedReceipt(preparation.receipt, preparation.receipt, evidence);
+    const journalPath = (0, habit_lifecycle_1.getHabitLifecyclePaths)({
+        agentRoot: lease.agentRoot,
+        habitId: lease.habitId,
+        operationId,
+    }).journal;
+    (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, journalPath, deps);
+    const definitionHash = sha256(definition.bytes);
+    if (definitionHash === preparation.definitionBeforeSha256) {
+        if ((definition.status !== "active" && definition.status !== "paused")
+            || definition.status !== preparation.receipt.transition.fromStatus) {
+            throw new HabitCancellationError("cancellation_definition_state_invalid");
+        }
+        if (journal.state !== "cancellation_intent") {
+            throw new HabitCancellationError("cancellation_definition_state_invalid");
+        }
+        const cancelledBytes = renderCancelledDefinition(definition, evidence.locator, evidence.cancellationReason, preparation.receipt.transition.cancelledAt);
+        if (sha256(cancelledBytes) !== preparation.definitionCancelledSha256) {
+            throw new HabitCancellationError("cancellation_definition_digest_mismatch");
+        }
+        (0, habit_lifecycle_1.writeHabitLifecycleDefinition)(lease, definition.path, cancelledBytes, deps);
+        definition = { path: definition.path, bytes: cancelledBytes, status: "cancelled" };
+    }
+    else {
+        if (definitionHash !== preparation.definitionCancelledSha256) {
+            throw new HabitCancellationError("cancellation_definition_digest_mismatch");
+        }
+        if (definition.status !== "cancelled") {
+            throw new HabitCancellationError("cancellation_definition_state_invalid");
+        }
+        (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, definition.path, deps);
+    }
+    if (journal.state === "cancellation_intent") {
+        journal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(journal, {
+            state: "definition_cancelled",
+            at: preparation.receipt.transition.cancelledAt,
+            boundaryState: preparation.receipt.transition.boundaryState,
+        });
+        (0, habit_lifecycle_1.writeHabitLifecycleJournal)(lease, journal, deps);
+    }
+    (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, journalPath, deps);
+    if (existingReceipt) {
+        assertPreparedReceipt(existingReceipt, preparation.receipt, evidence);
+        const receiptPath = (0, habit_lifecycle_1.getHabitLifecyclePaths)({
+            agentRoot: lease.agentRoot,
+            habitId: lease.habitId,
+            evidenceKeyHash,
+        }).receipt;
+        (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, receiptPath, deps);
+    }
+    else {
+        (0, habit_lifecycle_1.publishHabitLifecycleReceipt)(lease, evidenceKeyHash, preparation.receipt, deps);
+    }
+    journal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(journal, {
+        state: "cancellation_receipt_committed",
+        at: preparation.receipt.createdAt,
+    });
+    (0, habit_lifecycle_1.writeHabitLifecycleJournal)(lease, journal, deps);
+    return preparation.receipt;
+}
+function cancellationLeaseKey(agentRoot, habitId, operationId) {
+    return JSON.stringify([path.resolve(agentRoot), habitId, operationId]);
+}
+async function releaseCancellationLease(leaseKey, lease, deps) {
+    const attempts = Math.floor(habit_lifecycle_1.HABIT_LIFECYCLE_TIMEOUT_MS / habit_lifecycle_1.HABIT_LIFECYCLE_POLL_MS) + 1;
+    const wait = deps.sleep ?? ((milliseconds) => new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    }));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        let released;
+        try {
+            released = (0, habit_lifecycle_1.releaseHabitLifecycleLock)(lease, deps);
+        }
+        catch (error) {
+            retainedCancellationLeases.set(leaseKey, lease);
+            throw new HabitCancellationError("lifecycle_lock_release_failed", { cause: error });
+        }
+        if (released) {
+            retainedCancellationLeases.delete(leaseKey);
+            return;
+        }
+        if (attempt + 1 < attempts)
+            await wait(habit_lifecycle_1.HABIT_LIFECYCLE_POLL_MS);
+    }
+    retainedCancellationLeases.set(leaseKey, lease);
+    throw new HabitCancellationError("lifecycle_lock_release_failed");
+}
+function confirmCancellationDurability(lease, definitionPath, evidenceKeyHash, operationId, deps) {
+    const paths = (0, habit_lifecycle_1.getHabitLifecyclePaths)({
+        agentRoot: lease.agentRoot,
+        habitId: lease.habitId,
+        evidenceKeyHash,
+        operationId,
+    });
+    (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, paths.journal, deps);
+    (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, definitionPath, deps);
+    (0, habit_lifecycle_1.confirmHabitLifecyclePathDurability)(lease, paths.receipt, deps);
+}
+function resolveCancellationEvidence(input, deps) {
+    const locator = validatedCancellationLocator(input);
+    if (locator.kind === "capture")
+        return validateCaptureEvidence(input.agentRoot, locator.id, deps);
+    return validateHabitEvidenceBridge({
+        agentRoot: input.agentRoot,
+        bridgeId: locator.id,
+    }, deps);
+}
+function validatedCancellationLocator(input) {
+    if (!isRecord(input.authority))
+        throw new HabitCancellationError("cancellation_authority_invalid");
+    if (input.authority.kind === "current_ingress") {
+        const match = CAPTURE_LOCATOR_PATTERN.exec(input.evidenceLocator);
+        if (!match)
+            throw new HabitCancellationError("capture_evidence_locator_invalid");
+        const current = input.authority.currentIngressEvidence;
+        if (!isRecord(current)
+            || Object.keys(current).length !== 3
+            || current.schemaVersion !== 1
+            || current.provider !== "bluebubbles"
+            || typeof current.captureKeyHash !== "string"
+            || !HASH_PATTERN.test(current.captureKeyHash))
+            throw new HabitCancellationError("current_ingress_evidence_invalid");
+        if (match[1] !== current.captureKeyHash) {
+            throw new HabitCancellationError("evidence_capture_mismatch");
+        }
+        return { kind: "capture", id: match[1] };
+    }
+    if (input.authority.kind !== "offline_bridge") {
+        throw new HabitCancellationError("cancellation_authority_invalid");
+    }
+    if (CAPTURE_LOCATOR_PATTERN.test(input.evidenceLocator)) {
+        throw new HabitCancellationError("offline_capture_evidence_forbidden");
+    }
+    return { kind: "bridge", id: validatedBridgeId(input.evidenceLocator) };
+}
+function validateCaptureEvidence(agentRoot, captureKeyHash, deps) {
+    const cutover = (0, semantic_receipts_1.readBlueBubblesSemanticCutoverAtRoot)(agentRoot, deps);
+    if (!cutover)
+        throw new HabitCancellationError("capture_cutover_invalid");
+    const capture = (0, semantic_receipts_1.readBlueBubblesSemanticCaptureAtRoot)(agentRoot, captureKeyHash, deps);
+    if (!capture)
+        throw new HabitCancellationError("capture_evidence_missing_or_invalid");
+    const disposition = (0, semantic_receipts_1.classifyBlueBubblesRecoveryRecord)(capture, cutover);
+    if (disposition.disposition !== "handleable" || disposition.keyHash !== captureKeyHash) {
+        throw new HabitCancellationError("capture_evidence_not_handleable");
+    }
+    const event = capture.event;
+    if (capture.keyHash !== captureKeyHash
+        || capture.providerNamespace !== cutover.providerNamespace
+        || capture.capturedAt < cutover.effectiveAt
+        || event.provider !== "bluebubbles"
+        || event.kind !== "message"
+        || event.fromMe
+        || typeof event.text !== "string"
+        || event.text.length === 0
+        || typeof event.textSha256 !== "string"
+        || event.textSha256 !== sha256(event.text)
+        || event.actor.provider !== "imessage-handle"
+        || typeof event.actor.externalId !== "string"
+        || event.actor.externalId.trim().length === 0
+        || typeof event.actor.displayName !== "string")
+        throw new HabitCancellationError("capture_message_evidence_invalid");
+    const displayName = requiredSingleLine(event.actor.displayName, "capture_actor_invalid");
+    return {
+        locator: { kind: "capture", id: captureKeyHash },
+        actor: {
+            displayName,
+            provider: event.actor.provider,
+            externalId: event.actor.externalId,
+        },
+        request: {
+            text: event.text,
+            sha256: event.textSha256,
+            observedAt: capture.capturedAt,
+        },
+        cancellationReason: `Confirmed requester ${displayName} asked to end this habit.`,
+    };
+}
+function readDefinitionSnapshot(agentRoot, habitId, deps) {
+    const definitionPath = path.join(agentRoot, "habits", `${habitId}.md`);
+    let bytes;
+    try {
+        bytes = (deps.fs ?? fs).readFileSync(definitionPath, "utf8");
+    }
+    catch (error) {
+        throw new HabitCancellationError("habit_definition_missing_or_unreadable", { cause: error });
+    }
+    const parsed = (0, habit_parser_1.parseHabitFile)(bytes, definitionPath);
+    if (parsed.status === "degraded") {
+        throw new HabitCancellationError(`habit_definition_degraded:${parsed.degradedReason}`);
+    }
+    return { path: definitionPath, bytes, status: parsed.status };
+}
+function renderCancelledDefinition(definition, locator, cancellationReason, cancelledAt) {
+    const evidenceValue = locator.kind === "capture" ? `capture:${locator.id}` : locator.id;
+    const lineEnding = definition.bytes.includes("\r\n") ? "\r\n" : "\n";
+    const lifecycleLines = [
+        "status: cancelled",
+        `cancelledAt: ${cancelledAt}`,
+        `cancelledEvidence: ${evidenceValue}`,
+        `cancelledReason: ${requiredSingleLine(cancellationReason, "cancellation_reason_invalid")}`,
+    ].join(lineEnding);
+    const bomLength = definition.bytes.startsWith("\uFEFF") ? 1 : 0;
+    const lines = physicalLines(definition.bytes);
+    const closingIndex = lines.findIndex((line, index) => index > 0 && line.content.trim() === "---");
+    const hasFrontmatter = lines[0]?.content.trim() === "---" && closingIndex > 0;
+    const frontmatterLines = hasFrontmatter ? lines.slice(1, closingIndex) : [];
+    if (frontmatterLines.some((line) => /^(?:cancelledAt|cancelledEvidence|cancelledReason):/.test(line.content))) {
+        throw new HabitCancellationError("habit_definition_lifecycle_lines_invalid");
+    }
+    const statusLines = frontmatterLines.filter((line) => /^status:/.test(line.content));
+    if (statusLines.length > 1)
+        throw new HabitCancellationError("habit_definition_status_line_invalid");
+    if (statusLines.length === 1) {
+        const statusLine = statusLines[0];
+        return `${definition.bytes.slice(0, statusLine.start)}${lifecycleLines}${definition.bytes.slice(statusLine.contentEnd)}`;
+    }
+    if (hasFrontmatter) {
+        const closing = lines[closingIndex];
+        return `${definition.bytes.slice(0, closing.start)}${lifecycleLines}${lineEnding}${definition.bytes.slice(closing.start)}`;
+    }
+    return `${definition.bytes.slice(0, bomLength)}---${lineEnding}${lifecycleLines}${lineEnding}---${lineEnding}${definition.bytes.slice(bomLength)}`;
+}
+function physicalLines(value) {
+    const lines = [];
+    let start = 0;
+    while (start < value.length) {
+        const newline = value.indexOf("\n", start);
+        const end = newline === -1 ? value.length : newline + 1;
+        const raw = value.slice(start, end);
+        const content = raw.endsWith("\r\n")
+            ? raw.slice(0, -2)
+            : raw.endsWith("\n")
+                ? raw.slice(0, -1)
+                : raw;
+        lines.push({ content, start, contentEnd: start + content.length });
+        start = end;
+    }
+    return lines;
+}
+function buildCancellationReceipt(input) {
+    const acknowledgement = renderHabitCancellationAcknowledgement(input.habitId, input.evidence.actor.displayName, input.boundaryState);
+    return {
+        schemaVersion: 1,
+        habitId: input.habitId,
+        operationId: input.operationId,
+        evidenceKeyHash: input.evidenceKeyHash,
+        evidenceLocator: input.evidence.locator,
+        actor: input.evidence.actor,
+        request: input.evidence.request,
+        transition: {
+            fromStatus: input.fromStatus,
+            toStatus: "cancelled",
+            cancelledAt: input.cancelledAt,
+            boundaryState: input.boundaryState,
+        },
+        acknowledgement,
+        createdAt: input.cancelledAt,
+    };
+}
+function classifyConcurrentSendBoundary(agentRoot, habitId, requestObservedAt, cancelledAt, deps) {
+    const candidates = (0, habit_lifecycle_1.listHabitLifecycleJournals)({ agentRoot, habitId }, deps)
+        .filter((journal) => journal.operationKind === "send"
+        && journal.intentAt !== null
+        && journal.intentAt <= cancelledAt
+        && (journal.classifiedAt === null || journal.classifiedAt >= requestObservedAt));
+    if (candidates.some((journal) => journal.state === "crossed"))
+        return "crossed";
+    if (candidates.some((journal) => (journal.state === "crossing_unknown" || journal.state === "send_intent")))
+        return "crossing_unknown";
+    return "not_crossed";
+}
+function assertPreparedReceipt(actual, prepared, evidence) {
+    if ((0, habit_lifecycle_1.serializeHabitLifecycleJson)(actual) !== (0, habit_lifecycle_1.serializeHabitLifecycleJson)(prepared)
+        || (evidence !== null && ((0, habit_lifecycle_1.serializeHabitLifecycleJson)(prepared.evidenceLocator) !== (0, habit_lifecycle_1.serializeHabitLifecycleJson)(evidence.locator)
+            || (0, habit_lifecycle_1.serializeHabitLifecycleJson)(prepared.actor) !== (0, habit_lifecycle_1.serializeHabitLifecycleJson)(evidence.actor)
+            || (0, habit_lifecycle_1.serializeHabitLifecycleJson)(prepared.request) !== (0, habit_lifecycle_1.serializeHabitLifecycleJson)(evidence.request))))
+        throw new HabitCancellationError("cancellation_prepared_receipt_mismatch");
+}
+function assertDefinitionMatches(bytes, expectedSha256) {
+    if (sha256(bytes) !== expectedSha256) {
+        throw new HabitCancellationError("cancellation_definition_digest_mismatch");
+    }
+}
+function validateOperatorConfirmation(bridgeRoot, raw, storeFs) {
+    const value = requiredRecord(raw, "bridge_confirmation_invalid");
+    requireExactKeys(value, ["path", "sha256"], "bridge_confirmation_invalid");
+    const relativePath = validatedArtifactPath(value.path, "bridge_confirmation_invalid");
+    const expectedSha256 = validatedHash(value.sha256, "bridge_confirmation_invalid");
+    const bytes = readUtf8(storeFs, path.join(bridgeRoot, relativePath), "bridge_confirmation_invalid");
+    if (sha256(bytes) !== expectedSha256 || !bytes.endsWith("\n") || bytes.endsWith("\n\n") || bytes.includes("\r")) {
+        throw new HabitCancellationError("bridge_confirmation_invalid");
+    }
+}
+function validateBridgeScreenshots(bridgeRoot, raw, storeFs) {
+    if (!Array.isArray(raw) || raw.length !== 2) {
+        throw new HabitCancellationError("bridge_screenshots_invalid");
+    }
+    raw.forEach((entry, index) => {
+        const value = requiredRecord(entry, "bridge_screenshots_invalid");
+        requireExactKeys(value, ["index", "sourcePath", "artifactPath", "sha256"], "bridge_screenshots_invalid");
+        if (value.index !== index + 1)
+            throw new HabitCancellationError("bridge_screenshots_invalid");
+        const sourcePath = requiredString(value.sourcePath, "bridge_screenshots_invalid");
+        if (!path.isAbsolute(sourcePath))
+            throw new HabitCancellationError("bridge_screenshots_invalid");
+        const artifactPath = validatedArtifactPath(value.artifactPath, "bridge_screenshots_invalid");
+        const expectedSha256 = validatedHash(value.sha256, "bridge_screenshots_invalid");
+        const artifactBytes = readBuffer(storeFs, path.join(bridgeRoot, artifactPath), "bridge_screenshots_invalid");
+        if (sha256(artifactBytes) !== expectedSha256) {
+            throw new HabitCancellationError("bridge_screenshots_invalid");
+        }
+    });
+}
+function validateBridgeSources(input) {
+    if (!Array.isArray(input.value) || input.value.length !== 3) {
+        throw new HabitCancellationError("bridge_sources_invalid");
+    }
+    const [inboundRaw, sessionRaw, contextRaw] = input.value;
+    const inbound = requiredRecord(inboundRaw, "bridge_inbound_evidence_invalid");
+    requireExactKeys(inbound, ["role", "path", "fileSha256", "eventGuid", "requestSha256"], "bridge_inbound_evidence_invalid");
+    if (inbound.role !== "inbound_request"
+        || inbound.eventGuid !== input.eventGuid
+        || inbound.requestSha256 !== input.requestSha256)
+        throw new HabitCancellationError("bridge_inbound_evidence_invalid");
+    const inboundBytes = validatedSourceBytes(inbound, input.storeFs, "bridge_inbound_evidence_invalid");
+    const inboundRows = inboundBytes.split("\n").filter((line) => line.length > 0).map((line) => {
+        const row = parseJsonRecord(line, "bridge_inbound_evidence_invalid");
+        return row;
+    }).filter((row) => row.messageGuid === input.eventGuid);
+    if (inboundRows.length !== 1
+        || inboundRows[0].textForAgent !== input.requestText
+        || sha256(String(inboundRows[0].textForAgent)) !== input.requestSha256)
+        throw new HabitCancellationError("bridge_inbound_request_invalid");
+    const session = requiredRecord(sessionRaw, "bridge_session_evidence_invalid");
+    requireExactKeys(session, ["role", "path", "fileSha256", "eventId", "normalizedRequestSha256"], "bridge_session_evidence_invalid");
+    if (session.role !== "session_rendering"
+        || session.normalizedRequestSha256 !== input.requestSha256)
+        throw new HabitCancellationError("bridge_session_evidence_invalid");
+    const sessionBytes = validatedSourceBytes(session, input.storeFs, "bridge_session_evidence_invalid");
+    const sessionValue = parseJsonRecord(sessionBytes, "bridge_session_evidence_invalid");
+    if (!Array.isArray(sessionValue.events))
+        throw new HabitCancellationError("bridge_session_evidence_invalid");
+    const sessionEvents = sessionValue.events.filter((entry) => (isRecord(entry) && entry.id === session.eventId));
+    if (sessionEvents.length !== 1 || typeof sessionEvents[0].content !== "string") {
+        throw new HabitCancellationError("bridge_session_evidence_invalid");
+    }
+    const prefixEnd = sessionEvents[0].content.indexOf(": ");
+    if (prefixEnd < 0)
+        throw new HabitCancellationError("bridge_session_normalization_invalid");
+    const normalized = sessionEvents[0].content.slice(prefixEnd + 2);
+    if (normalized !== input.requestText || sha256(normalized) !== input.requestSha256) {
+        throw new HabitCancellationError("bridge_session_normalization_invalid");
+    }
+    const context = requiredRecord(contextRaw, "bridge_context_evidence_invalid");
+    requireExactKeys(context, ["role", "path", "fileSha256", "eventGuid"], "bridge_context_evidence_invalid");
+    if (context.role !== "context_chronology" || context.eventGuid !== input.eventGuid) {
+        throw new HabitCancellationError("bridge_context_evidence_invalid");
+    }
+    const contextBytes = validatedSourceBytes(context, input.storeFs, "bridge_context_evidence_invalid");
+    const contextValue = parseJsonRecord(contextBytes, "bridge_context_evidence_invalid");
+    if (contextValue.anchorMessageGuid !== input.eventGuid
+        || !Array.isArray(contextValue.messages)
+        || contextValue.messages.length !== 2
+        || contextValue.messages.some((entry) => (!isRecord(entry)
+            || typeof entry.authorLabel !== "string"
+            || typeof entry.bodyPreview !== "string"
+            || typeof entry.timestamp !== "string")))
+        throw new HabitCancellationError("bridge_context_evidence_invalid");
+}
+function validatedSourceBytes(value, storeFs, code) {
+    const sourcePath = requiredString(value.path, code);
+    const expectedSha256 = validatedHash(value.fileSha256, code);
+    const bytes = readUtf8(storeFs, sourcePath, code);
+    if (sha256(bytes) !== expectedSha256)
+        throw new HabitCancellationError(code);
+    return bytes;
+}
+function validatedArtifactPath(value, code) {
+    const relativePath = requiredString(value, code);
+    if (path.basename(relativePath) !== relativePath || relativePath === "." || relativePath === "..") {
+        throw new HabitCancellationError(code);
+    }
+    return relativePath;
+}
+function cancellationNow(deps) {
+    return (deps.now ?? (() => new Date()))().toISOString();
+}
+function requiredRecord(value, code) {
+    if (!isRecord(value))
+        throw new HabitCancellationError(code);
+    return value;
+}
+function requireExactKeys(value, keys, code) {
+    const actual = Object.keys(value);
+    if (actual.length !== keys.length || actual.some((key, index) => key !== keys[index])) {
+        throw new HabitCancellationError(code);
+    }
+}
+function requiredString(value, code) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new HabitCancellationError(code);
+    }
+    return value;
+}
+function requiredSingleLine(value, code) {
+    const text = requiredString(value, code);
+    if (/[\r\n]/.test(text))
+        throw new HabitCancellationError(code);
+    return text;
+}
+function validatedHash(value, code) {
+    if (typeof value !== "string" || !HASH_PATTERN.test(value)) {
+        throw new HabitCancellationError(code);
+    }
+    return value;
+}
+function validatedBridgeId(value) {
+    const bridgeId = requiredString(value, "bridge_id_invalid");
+    if (!BRIDGE_ID_PATTERN.test(bridgeId) || bridgeId === "." || bridgeId === "..") {
+        throw new HabitCancellationError("bridge_id_invalid");
+    }
+    return bridgeId;
+}
+function isCanonicalTimestamp(value) {
+    if (typeof value !== "string" || !ISO_MILLISECONDS_PATTERN.test(value))
+        return false;
+    const parsed = new Date(value);
+    return !Number.isNaN(parsed.getTime()) && parsed.toISOString() === value;
+}
+function readUtf8(storeFs, filePath, code) {
+    try {
+        return storeFs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        throw new HabitCancellationError(code, { cause: error });
+    }
+}
+function readBuffer(storeFs, filePath, code) {
+    try {
+        return storeFs.readFileSync(filePath);
+    }
+    catch (error) {
+        throw new HabitCancellationError(code, { cause: error });
+    }
+}
+function parseJsonRecord(bytes, code) {
+    let value;
+    try {
+        value = JSON.parse(bytes);
+    }
+    catch (error) {
+        throw new HabitCancellationError(code, { cause: error });
+    }
+    return requiredRecord(value, code);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sha256(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value).digest("hex");
+}
+function asCancellationError(error) {
+    if (error instanceof HabitCancellationError)
+        return error;
+    if (error instanceof habit_lifecycle_1.HabitLifecycleError) {
+        return new HabitCancellationError(error.code, { cause: error });
+    }
+    return new HabitCancellationError("habit_cancellation_failed", { cause: error });
+}