@jungjaehoon/mama-os 0.49.2 → 0.50.0

package/dist/operator/task-ledger.js

@@ -27,6 +27,7 @@ const operator_task_temporal_js_1 = require("../db/migrations/operator-task-temp
 const operator_task_external_lifecycle_js_1 = require("../db/migrations/operator-task-external-lifecycle.js");
 const operator_task_review_lifecycle_js_1 = require("../db/migrations/operator-task-review-lifecycle.js");
 const operator_task_classification_js_1 = require("../db/migrations/operator-task-classification.js");
+const operator_owner_action_candidates_js_1 = require("../db/migrations/operator-owner-action-candidates.js");
 const effects_js_1 = require("../evidence/effects.js");
 const temporal_effect_js_1 = require("./temporal-effect.js");
 const task_temporal_js_1 = require("./task-temporal.js");
@@ -129,6 +130,40 @@ function isoToEpochMs(iso) {
     const ms = Date.parse(`${iso}T00:00:00Z`);
     return Number.isNaN(ms) ? null : ms;
 }
+const OWNER_ACTION_IDENTITY_MAX_LENGTH = 512;
+function requireOwnerActionIdentity(value, field) {
+    if (typeof value !== 'string') {
+        throw new Error(`owner action ${field} must be a non-blank string`);
+    }
+    if (value.trim().length === 0 || value.trim() !== value) {
+        throw new Error(`owner action ${field} must be a non-blank string without surrounding space`);
+    }
+    if (value.length > OWNER_ACTION_IDENTITY_MAX_LENGTH) {
+        throw new Error(`owner action ${field} must be at most ${OWNER_ACTION_IDENTITY_MAX_LENGTH} characters`);
+    }
+    return value;
+}
+/**
+ * Same identity rules as OwnerActionEffectLedger: every field is a trusted
+ * host identity, never model text. Checked before any storage is touched.
+ */
+function requireOwnerActionContext(context) {
+    if (context === null || typeof context !== 'object') {
+        throw new Error('owner action context is required');
+    }
+    const workOrderAttemptId = context.workOrderAttemptId;
+    if (workOrderAttemptId !== undefined &&
+        (!Number.isSafeInteger(workOrderAttemptId) || workOrderAttemptId <= 0)) {
+        throw new Error('owner action workOrderAttemptId must be a positive integer when present');
+    }
+    return {
+        ownerScope: requireOwnerActionIdentity(context.ownerScope, 'ownerScope'),
+        occurrenceKey: requireOwnerActionIdentity(context.occurrenceKey, 'occurrenceKey'),
+        modelRunId: requireOwnerActionIdentity(context.modelRunId, 'modelRunId'),
+        envelopeHash: requireOwnerActionIdentity(context.envelopeHash, 'envelopeHash'),
+        workOrderAttemptId: workOrderAttemptId ?? null,
+    };
+}
 function assertEnum(value, allowed, field) {
     if (!allowed.includes(value)) {
         throw new Error(`${field} must be one of ${allowed.join('|')}, got: ${value}`);
@@ -189,6 +224,7 @@ function rowToRecord(row, now, timeZone) {
         }, now, timeZone),
         reviewStartedAt: row.review_started_at,
         reviewAnchorEventId: row.review_anchor_event_id,
+        reviewAnchorSourceChannel: row.review_anchor_source_channel ?? null,
         completionCriteria: row.completion_criteria ?? null,
         resolutionKind: (row.resolution_kind ?? null),
         createdAt: row.created_at,
@@ -199,10 +235,14 @@ class TaskLedger {
     db;
     now;
     timeZone;
+    onOwnerTaskChangeCommitted;
+    pendingOwnerTaskGeneration = null;
+    ownerTaskNotificationScheduled = false;
     constructor(db, options = {}) {
         this.db = db;
         this.now = options.now ?? Date.now;
         this.timeZone = options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+        this.onOwnerTaskChangeCommitted = options.onOwnerTaskChangeCommitted;
         // Validate the injected or boot-resolved zone once, before reads depend on it.
         new Intl.DateTimeFormat('en-US', { timeZone: this.timeZone }).format(0);
         this.runMigration();
@@ -270,6 +310,7 @@ class TaskLedger {
         last_temporal_attempt_id INTEGER,
         review_started_at INTEGER,
         review_anchor_event_id TEXT,
+        review_anchor_source_channel TEXT,
         completion_criteria TEXT,
         resolution_kind TEXT,
         created_at INTEGER NOT NULL,
@@ -337,6 +378,7 @@ class TaskLedger {
             }
             (0, operator_task_temporal_js_1.applyOperatorTaskTemporalMigration)(this.db);
             (0, operator_task_external_lifecycle_js_1.applyOperatorTaskExternalLifecycleMigration)(this.db);
+            (0, operator_owner_action_candidates_js_1.applyOperatorOwnerActionCandidatesMigration)(this.db);
             (0, operator_task_review_lifecycle_js_1.applyOperatorTaskReviewLifecycleMigration)(this.db);
             (0, operator_task_classification_js_1.applyOperatorTaskClassificationMigration)(this.db);
             // Old-predicate unique index (no terminal exclusion) -> swap in place.
@@ -596,6 +638,37 @@ class TaskLedger {
             .digest('base64url')
             .slice(0, 22);
     }
+    notifyOwnerTaskCommit(previousGeneration) {
+        if (!this.onOwnerTaskChangeCommitted) {
+            return;
+        }
+        const generation = this.readGeneration();
+        if (generation === previousGeneration) {
+            return;
+        }
+        this.pendingOwnerTaskGeneration = generation;
+        if (this.ownerTaskNotificationScheduled) {
+            return;
+        }
+        this.ownerTaskNotificationScheduled = true;
+        queueMicrotask(() => this.flushOwnerTaskNotification());
+    }
+    flushOwnerTaskNotification() {
+        this.ownerTaskNotificationScheduled = false;
+        const expected = this.pendingOwnerTaskGeneration;
+        this.pendingOwnerTaskGeneration = null;
+        if (!expected || !this.onOwnerTaskChangeCommitted) {
+            return;
+        }
+        const current = this.readGeneration();
+        if (current !== expected) {
+            this.pendingOwnerTaskGeneration = current;
+            this.ownerTaskNotificationScheduled = true;
+            queueMicrotask(() => this.flushOwnerTaskNotification());
+            return;
+        }
+        this.onOwnerTaskChangeCommitted(current);
+    }
     /**
      * Aggregate counts over the same owner predicate `listPage` filters by. Facets
      * come from SQL GROUP BY (each partitions total); due buckets are computed in
@@ -679,7 +752,8 @@ class TaskLedger {
     getExternalBinding(taskId) {
         const row = this.db
             .prepare(`SELECT id, revision, task_id, connector, source_type, external_source_id,
-                last_observation_seq, created_by_attempt_id
+                last_observation_seq, created_by_attempt_id, created_by_run_id,
+                created_by_owner_scope, created_at
          FROM operator_external_task_bindings
          WHERE task_id = ? AND active = 1`)
             .get(taskId);
@@ -818,6 +892,218 @@ class TaskLedger {
         if (all.length === 0) {
             return { disposition: 'none' };
         }
+        // Receipts are global by candidate id, so a decision settled by an owner
+        // run is seen here exactly like one settled by this attempt.
+        return this.candidateReceiptDisposition(all);
+    }
+    /**
+     * Resolve one candidate decision's authority (Task B2).
+     *
+     * A plain attempt id is the legacy Board wrapper. A discriminated source is
+     * either that same Board path or a verified owner run whose host-attested
+     * snapshot must match the caller's scope, run and envelope exactly. Both
+     * return the SAME decision inputs; the receipt records which one settled it.
+     */
+    resolveExternalCandidateAuthority(source, kind, origin) {
+        const resolved = typeof source === 'number' ? { kind: 'board', attemptId: source } : source;
+        const label = kind === 'binding' ? 'external binding' : 'external lifecycle';
+        if (resolved.kind === 'board') {
+            const attemptId = resolved.attemptId;
+            if (origin.workOrderAttemptId !== attemptId) {
+                throw new Error(`${label} decision requires trusted attempt origin ${attemptId}`);
+            }
+            return {
+                source: resolved,
+                receiptOrigin: {
+                    attemptId,
+                    runId: origin.runId ?? null,
+                    ownerScope: null,
+                    envelopeHash: null,
+                },
+                load: (candidateId) => {
+                    const attempt = this.getWorkOrderById(attemptId);
+                    return {
+                        candidate: this.loadBoardCandidate(attemptId, candidateId, kind),
+                        snapshotAt: attempt?.createdAt ?? 0,
+                    };
+                },
+            };
+        }
+        const context = requireOwnerActionContext(resolved.context);
+        if (origin.runId !== context.modelRunId) {
+            throw new Error(`${label} decision requires trusted owner run origin ${context.modelRunId}`);
+        }
+        if ((origin.workOrderAttemptId ?? null) !== context.workOrderAttemptId) {
+            throw new Error(`${label} decision attempt ${String(origin.workOrderAttemptId)} does not match the attesting owner run`);
+        }
+        if (context.workOrderAttemptId !== null) {
+            this.assertWorkOrderAttemptActive(label, context.workOrderAttemptId);
+        }
+        return {
+            source: resolved,
+            receiptOrigin: {
+                attemptId: context.workOrderAttemptId,
+                runId: context.modelRunId,
+                ownerScope: context.ownerScope,
+                envelopeHash: context.envelopeHash,
+            },
+            load: (candidateId) => {
+                const attested = this.loadOwnerAttestedCandidate(context, candidateId, kind);
+                return { candidate: attested.candidate, snapshotAt: attested.attestedAt };
+            },
+        };
+    }
+    /** Same contract as loadBoardCandidate, for either authority source. */
+    loadExternalCandidate(source, candidateId, kind) {
+        const resolved = typeof source === 'number' ? { kind: 'board', attemptId: source } : source;
+        return resolved.kind === 'board'
+            ? this.loadBoardCandidate(resolved.attemptId, candidateId, kind)
+            : this.loadOwnerActionCandidate(resolved.context, candidateId, kind);
+    }
+    /**
+     * Persist host-built candidate snapshots under a verified owner run.
+     *
+     * Every snapshot is re-validated as host-built (exact shape, Kagemusha
+     * mapping, fixed evidence summary, content-derived id) before it is stored;
+     * model-authored bytes never enter this table. Rows are immutable. The same
+     * run attesting the same candidate again with identical bytes is a no-op;
+     * different bytes under the same id are a conflict, not a second row.
+     */
+    attestOwnerActionCandidates(context, candidates) {
+        const verified = requireOwnerActionContext(context);
+        const prepared = [
+            ...candidates.bindingCandidates.map((candidate) => (0, external_lifecycle_candidates_js_1.parseHostBuiltExternalLifecycleCandidate)('binding', candidate)),
+            ...candidates.lifecycleCandidates.map((candidate) => (0, external_lifecycle_candidates_js_1.parseHostBuiltExternalLifecycleCandidate)('lifecycle', candidate)),
+        ].map((candidate) => {
+            const json = (0, external_lifecycle_candidates_js_1.canonicalExternalLifecycleCandidateJson)(candidate);
+            return { candidate, json, sha256: (0, node_crypto_1.createHash)('sha256').update(json).digest('hex') };
+        });
+        let attested = 0;
+        let alreadyAttested = 0;
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            for (const entry of prepared) {
+                const existing = this.db
+                    .prepare(`SELECT owner_scope, envelope_hash, occurrence_key, workorder_attempt_id,
+                    candidate_kind, candidate_sha256
+               FROM ${operator_owner_action_candidates_js_1.OWNER_ACTION_CANDIDATES_TABLE}
+              WHERE model_run_id = ? AND candidate_id = ?`)
+                    .get(verified.modelRunId, entry.candidate.candidateId);
+                if (existing) {
+                    if (existing.owner_scope !== verified.ownerScope ||
+                        existing.envelope_hash !== verified.envelopeHash ||
+                        existing.occurrence_key !== verified.occurrenceKey ||
+                        existing.workorder_attempt_id !== verified.workOrderAttemptId ||
+                        existing.candidate_kind !== entry.candidate.kind ||
+                        existing.candidate_sha256 !== entry.sha256) {
+                        throw new Error(`owner action candidate ${entry.candidate.candidateId} attestation conflict: run ${verified.modelRunId} already holds a snapshot that differs`);
+                    }
+                    alreadyAttested += 1;
+                    continue;
+                }
+                const task = this.getRowById(entry.candidate.taskId);
+                if (!task || task.kind !== 'owner') {
+                    throw new Error(`owner action candidate ${entry.candidate.candidateId} references no owner task`);
+                }
+                this.db
+                    .prepare(`INSERT INTO ${operator_owner_action_candidates_js_1.OWNER_ACTION_CANDIDATES_TABLE}
+               (model_run_id, candidate_id, owner_scope, envelope_hash, occurrence_key,
+                workorder_attempt_id, candidate_kind, task_id, event_id, candidate_json,
+                candidate_sha256, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(verified.modelRunId, entry.candidate.candidateId, verified.ownerScope, verified.envelopeHash, verified.occurrenceKey, verified.workOrderAttemptId, entry.candidate.kind, entry.candidate.taskId, entry.candidate.eventId, entry.json, entry.sha256, this.now());
+                attested += 1;
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        return { attested, alreadyAttested };
+    }
+    /** Bounded, intent-free listing of what one owner run attested. */
+    listOwnerActionCandidates(context) {
+        const verified = requireOwnerActionContext(context);
+        return this.db
+            .prepare(`SELECT candidate_id, candidate_kind, task_id, event_id
+             FROM ${operator_owner_action_candidates_js_1.OWNER_ACTION_CANDIDATES_TABLE}
+            WHERE model_run_id = ? AND owner_scope = ? AND envelope_hash = ?
+              AND occurrence_key = ? AND workorder_attempt_id IS ?
+            ORDER BY created_at ASC, candidate_kind ASC, candidate_id ASC`)
+            .all(verified.modelRunId, verified.ownerScope, verified.envelopeHash, verified.occurrenceKey, verified.workOrderAttemptId).map((row) => ({
+            candidateId: row.candidate_id,
+            kind: row.candidate_kind,
+            taskId: row.task_id,
+            eventId: row.event_id,
+        }));
+    }
+    /**
+     * Receipt view of one owner run's attested candidates, in the same shape as
+     * inspectBoardCandidateAttempt so recovery can treat both sources alike.
+     */
+    inspectOwnerActionCandidateRun(context) {
+        const all = this.listOwnerActionCandidates(context);
+        if (all.length === 0) {
+            return { disposition: 'none' };
+        }
+        return this.candidateReceiptDisposition(all);
+    }
+    loadOwnerActionCandidate(context, candidateId, kind) {
+        return this.loadOwnerAttestedCandidate(requireOwnerActionContext(context), candidateId, kind)
+            .candidate;
+    }
+    /**
+     * Recover a candidate only from the attestation the exact owner run made.
+     * Stored bytes are revalidated: sha256 over the canonical JSON, exact shape,
+     * and the content-derived candidate id must all still agree.
+     */
+    loadOwnerAttestedCandidate(context, candidateId, kind) {
+        const row = this.db
+            .prepare(`SELECT owner_scope, envelope_hash, occurrence_key, workorder_attempt_id,
+                candidate_kind, task_id, event_id, candidate_json, candidate_sha256, created_at
+           FROM ${operator_owner_action_candidates_js_1.OWNER_ACTION_CANDIDATES_TABLE}
+          WHERE model_run_id = ? AND candidate_id = ?`)
+            .get(context.modelRunId, candidateId);
+        if (!row) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} is not attested for owner run ${context.modelRunId}`);
+        }
+        if (row.owner_scope !== context.ownerScope) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} was attested under a different owner scope`);
+        }
+        if (row.envelope_hash !== context.envelopeHash) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} was attested under a different envelope`);
+        }
+        if (row.occurrence_key !== context.occurrenceKey) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} was attested under a different occurrence`);
+        }
+        if (row.workorder_attempt_id !== context.workOrderAttemptId) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} was attested under a different workorder attempt`);
+        }
+        if (row.candidate_kind !== kind) {
+            throw new Error(`external lifecycle candidate ${candidateId} has the wrong kind (attested as ${row.candidate_kind})`);
+        }
+        const digest = (0, node_crypto_1.createHash)('sha256').update(row.candidate_json).digest('hex');
+        if (digest !== row.candidate_sha256) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} failed attestation integrity (sha256 mismatch)`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(row.candidate_json);
+        }
+        catch {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} failed attestation integrity (unreadable)`);
+        }
+        const candidate = (0, external_lifecycle_candidates_js_1.parseHostBuiltExternalLifecycleCandidate)(kind, parsed);
+        if (candidate.candidateId !== candidateId ||
+            candidate.taskId !== row.task_id ||
+            candidate.eventId !== row.event_id ||
+            (0, external_lifecycle_candidates_js_1.canonicalExternalLifecycleCandidateJson)(candidate) !== row.candidate_json) {
+            throw new Error(`external lifecycle ${kind} candidate ${candidateId} failed attestation integrity (identity mismatch)`);
+        }
+        return { candidate, attestedAt: row.created_at };
+    }
+    candidateReceiptDisposition(all) {
         const outcomes = [];
         const missingCandidateIds = [];
         for (const candidate of all) {
@@ -839,15 +1125,14 @@ class TaskLedger {
         }
         return { disposition: 'partial', missingCandidateIds };
     }
-    applyExternalBindingDecision(attemptId, input, origin) {
+    applyExternalBindingDecision(source, input, origin) {
         (0, external_lifecycle_candidates_js_1.validateExternalLifecycleDecision)('binding', input);
-        if (origin.workOrderAttemptId !== attemptId) {
-            throw new Error(`external binding decision requires trusted attempt origin ${attemptId}`);
-        }
+        const authority = this.resolveExternalCandidateAuthority(source, 'binding', origin);
+        const receiptOrigin = authority.receiptOrigin;
         let receipt = null;
         this.db.exec('BEGIN IMMEDIATE');
         try {
-            const candidate = this.loadBoardCandidate(attemptId, input.candidate_id, 'binding');
+            const { candidate } = authority.load(input.candidate_id);
             if (candidate.kind !== 'binding') {
                 throw new Error(`external lifecycle candidate ${input.candidate_id} has the wrong kind`);
             }
@@ -888,16 +1173,19 @@ class TaskLedger {
                     const inserted = this.db
                         .prepare(`INSERT INTO operator_external_task_bindings
                  (task_id, connector, source_type, external_source_id, last_observation_seq,
-                  created_by_attempt_id, active, created_at, updated_at)
-               VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`)
-                        .run(candidate.taskId, candidate.connector, candidate.sourceType, candidate.externalSourceId, candidate.operatorObservationSeq, attemptId, now, now);
+                  created_by_attempt_id, created_by_run_id, created_by_owner_scope,
+                  created_by_envelope_hash, active, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`)
+                        .run(candidate.taskId, candidate.connector, candidate.sourceType, candidate.externalSourceId, candidate.operatorObservationSeq, receiptOrigin.attemptId, receiptOrigin.runId, receiptOrigin.ownerScope, receiptOrigin.envelopeHash, now, now);
                     bindingId = Number(inserted.lastInsertRowid);
                 }
-                this.insertBindingReceipt(candidate, attemptId, input, outcome, bindingId, origin);
+                this.insertBindingReceipt(candidate, receiptOrigin, input, outcome, bindingId, origin);
                 receipt = {
                     kind: 'binding',
                     candidateId: candidate.candidateId,
-                    workOrderAttemptId: attemptId,
+                    workOrderAttemptId: receiptOrigin.attemptId,
+                    originRunId: receiptOrigin.runId,
+                    originOwnerScope: receiptOrigin.ownerScope,
                     taskId: candidate.taskId,
                     outcome,
                     reason: input.reason,
@@ -912,15 +1200,15 @@ class TaskLedger {
         }
         return receipt;
     }
-    applyExternalLifecycleDecision(attemptId, input, origin) {
+    applyExternalLifecycleDecision(source, input, origin) {
         (0, external_lifecycle_candidates_js_1.validateExternalLifecycleDecision)('lifecycle', input);
-        if (origin.workOrderAttemptId !== attemptId) {
-            throw new Error(`external lifecycle decision requires trusted attempt origin ${attemptId}`);
-        }
+        const authority = this.resolveExternalCandidateAuthority(source, 'lifecycle', origin);
+        const receiptOrigin = authority.receiptOrigin;
         let receipt = null;
+        const previousGeneration = this.onOwnerTaskChangeCommitted ? this.readGeneration() : null;
         this.db.exec('BEGIN IMMEDIATE');
         try {
-            const candidate = this.loadBoardCandidate(attemptId, input.candidate_id, 'lifecycle');
+            const { candidate, snapshotAt } = authority.load(input.candidate_id);
             if (candidate.kind !== 'lifecycle') {
                 throw new Error(`external lifecycle candidate ${input.candidate_id} has the wrong kind`);
             }
@@ -944,12 +1232,19 @@ class TaskLedger {
                 if (!task || task.kind !== 'owner' || !binding) {
                     throw new Error(`external lifecycle candidate ${candidate.candidateId} has no active binding`);
                 }
+                // A binding that came into being after this candidate's snapshot cannot
+                // be the binding the snapshot described. Board attempts keep the exact
+                // legacy ordering rule; when either side lacks an attempt id (owner-run
+                // decisions), the ledger clock decides.
+                const bindingPostdatesSnapshot = authority.source.kind === 'board' && binding.createdByAttemptId !== null
+                    ? binding.createdByAttemptId >= authority.source.attemptId
+                    : binding.createdAt > snapshotAt;
                 const superseded = binding.id !== candidate.bindingId ||
                     binding.revision !== candidate.bindingRevision ||
                     binding.connector !== candidate.connector ||
                     binding.sourceType !== candidate.sourceType ||
                     binding.externalSourceId !== candidate.externalSourceId ||
-                    binding.createdByAttemptId >= attemptId ||
+                    bindingPostdatesSnapshot ||
                     task.revision !== candidate.taskRevision ||
                     candidate.operatorObservationSeq <= binding.lastObservationSeq;
                 const taskRevisionBefore = task.revision;
@@ -984,11 +1279,13 @@ class TaskLedger {
                         throw new Error(`external lifecycle candidate ${candidate.candidateId} binding watermark changed`);
                     }
                 }
-                this.insertLifecycleReceipt(candidate, attemptId, input, outcome, taskRevisionBefore, taskRevisionAfter, origin);
+                this.insertLifecycleReceipt(candidate, receiptOrigin, input, outcome, taskRevisionBefore, taskRevisionAfter, origin);
                 receipt = {
                     kind: 'lifecycle',
                     candidateId: candidate.candidateId,
-                    workOrderAttemptId: attemptId,
+                    workOrderAttemptId: receiptOrigin.attemptId,
+                    originRunId: receiptOrigin.runId,
+                    originOwnerScope: receiptOrigin.ownerScope,
                     taskId: candidate.taskId,
                     outcome,
                     reason: input.reason,
@@ -1002,16 +1299,18 @@ class TaskLedger {
             this.db.exec('ROLLBACK');
             throw error;
         }
+        this.notifyOwnerTaskCommit(previousGeneration);
         return receipt;
     }
     getExternalCandidateReceipt(candidateId) {
         const binding = this.db
-            .prepare(`SELECT candidate_id, workorder_attempt_id, task_id, outcome, reason, binding_id
+            .prepare(`SELECT candidate_id, workorder_attempt_id, origin_run_id, origin_owner_scope, task_id,
+                outcome, reason, binding_id
          FROM operator_external_binding_receipts WHERE candidate_id = ?`)
             .get(candidateId);
         const lifecycle = this.db
-            .prepare(`SELECT candidate_id, workorder_attempt_id, task_id, outcome, reason,
-                task_revision_before, task_revision_after
+            .prepare(`SELECT candidate_id, workorder_attempt_id, origin_run_id, origin_owner_scope, task_id,
+                outcome, reason, task_revision_before, task_revision_after
          FROM operator_external_lifecycle_receipts WHERE candidate_id = ?`)
             .get(candidateId);
         if (binding && lifecycle) {
@@ -1035,6 +1334,8 @@ class TaskLedger {
                 kind: 'binding',
                 candidateId: binding.candidate_id,
                 workOrderAttemptId: binding.workorder_attempt_id,
+                originRunId: binding.origin_run_id,
+                originOwnerScope: binding.origin_owner_scope,
                 taskId: binding.task_id,
                 outcome: binding.outcome,
                 reason: binding.reason,
@@ -1046,6 +1347,8 @@ class TaskLedger {
                 kind: 'lifecycle',
                 candidateId: lifecycle.candidate_id,
                 workOrderAttemptId: lifecycle.workorder_attempt_id,
+                originRunId: lifecycle.origin_run_id,
+                originOwnerScope: lifecycle.origin_owner_scope,
                 taskId: lifecycle.task_id,
                 outcome: lifecycle.outcome,
                 reason: lifecycle.reason,
@@ -1064,6 +1367,9 @@ class TaskLedger {
             externalSourceId: row.external_source_id,
             lastObservationSeq: row.last_observation_seq,
             createdByAttemptId: row.created_by_attempt_id,
+            createdByRunId: row.created_by_run_id,
+            createdByOwnerScope: row.created_by_owner_scope,
+            createdAt: row.created_at,
         };
     }
     assertBindingReplayMatches(receipt, candidate, input) {
@@ -1077,15 +1383,16 @@ class TaskLedger {
             throw new Error(`external binding receipt ${candidate.candidateId} conflicts with replay decision`);
         }
     }
-    insertBindingReceipt(candidate, attemptId, input, outcome, bindingId, origin) {
+    insertBindingReceipt(candidate, receiptOrigin, input, outcome, bindingId, origin) {
         this.db
             .prepare(`INSERT INTO operator_external_binding_receipts
            (candidate_id, decision, workorder_attempt_id, task_id, event_id, connector, source_type,
             external_source_id, channel_partition, content_sha256, source_timestamp_ms,
             operator_ingest_seq, operator_observation_seq, task_revision, outcome, reason, binding_id,
-            origin_run_id, origin_cause_event_ids, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(candidate.candidateId, input.decision, attemptId, candidate.taskId, candidate.eventId, candidate.connector, candidate.sourceType, candidate.externalSourceId, candidate.channelPartition, candidate.contentSha256, candidate.sourceTimestampMs, candidate.operatorIngestSeq, candidate.operatorObservationSeq, candidate.taskRevision, outcome, input.reason, bindingId ?? null, origin.runId ?? null, JSON.stringify(origin.causeEventIds ?? []), this.now());
+            origin_run_id, origin_cause_event_ids, origin_owner_scope, origin_envelope_hash,
+            created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(candidate.candidateId, input.decision, receiptOrigin.attemptId, candidate.taskId, candidate.eventId, candidate.connector, candidate.sourceType, candidate.externalSourceId, candidate.channelPartition, candidate.contentSha256, candidate.sourceTimestampMs, candidate.operatorIngestSeq, candidate.operatorObservationSeq, candidate.taskRevision, outcome, input.reason, bindingId ?? null, receiptOrigin.runId, JSON.stringify(origin.causeEventIds ?? []), receiptOrigin.ownerScope, receiptOrigin.envelopeHash, this.now());
     }
     assertLifecycleReplayMatches(receipt, candidate, input) {
         const stored = this.db
@@ -1098,16 +1405,16 @@ class TaskLedger {
             throw new Error(`external lifecycle receipt ${candidate.candidateId} conflicts with replay decision`);
         }
     }
-    insertLifecycleReceipt(candidate, attemptId, input, outcome, taskRevisionBefore, taskRevisionAfter, origin) {
+    insertLifecycleReceipt(candidate, receiptOrigin, input, outcome, taskRevisionBefore, taskRevisionAfter, origin) {
         this.db
             .prepare(`INSERT INTO operator_external_lifecycle_receipts
            (candidate_id, decision, workorder_attempt_id, task_id, event_id, connector, source_type,
             external_source_id, channel_partition, content_sha256, source_timestamp_ms,
             operator_ingest_seq, operator_observation_seq, binding_id, binding_revision,
             task_revision_before, task_revision_after, outcome, reason, origin_run_id,
-            origin_cause_event_ids, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(candidate.candidateId, input.decision, attemptId, candidate.taskId, candidate.eventId, candidate.connector, candidate.sourceType, candidate.externalSourceId, candidate.channelPartition, candidate.contentSha256, candidate.sourceTimestampMs, candidate.operatorIngestSeq, candidate.operatorObservationSeq, candidate.bindingId, candidate.bindingRevision, taskRevisionBefore, taskRevisionAfter, outcome, input.reason, origin.runId ?? null, JSON.stringify(origin.causeEventIds ?? []), this.now());
+            origin_cause_event_ids, origin_owner_scope, origin_envelope_hash, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(candidate.candidateId, input.decision, receiptOrigin.attemptId, candidate.taskId, candidate.eventId, candidate.connector, candidate.sourceType, candidate.externalSourceId, candidate.channelPartition, candidate.contentSha256, candidate.sourceTimestampMs, candidate.operatorIngestSeq, candidate.operatorObservationSeq, candidate.bindingId, candidate.bindingRevision, taskRevisionBefore, taskRevisionAfter, outcome, input.reason, receiptOrigin.runId, JSON.stringify(origin.causeEventIds ?? []), receiptOrigin.ownerScope, receiptOrigin.envelopeHash, this.now());
     }
     /**
      * Create a task. Idempotent under at-least-once delivery: a duplicate
@@ -1194,8 +1501,8 @@ class TaskLedger {
             }
         }
         let createdId = 0;
-        this.db.exec('BEGIN IMMEDIATE');
-        try {
+        const previousGeneration = this.onOwnerTaskChangeCommitted ? this.readGeneration() : null;
+        const write = this.db.transaction(() => {
             const result = this.db
                 .prepare(`INSERT INTO operator_tasks
            (title, status, priority, assignee, deadline, due_at, deadline_offset_minutes,
@@ -1247,12 +1554,9 @@ class TaskLedger {
                 },
                 atMs: now,
             });
-            this.db.exec('COMMIT');
-        }
-        catch (error) {
-            this.db.exec('ROLLBACK');
-            throw error;
-        }
+        }, 'immediate');
+        write();
+        this.notifyOwnerTaskCommit(previousGeneration);
         const created = this.getById(createdId);
         if (!created)
             throw new Error('task_create: inserted row could not be read back');
@@ -1294,16 +1598,10 @@ class TaskLedger {
     }
     update(id, patch, origin = {}) {
         this.validateTaskUpdatePatch(patch);
-        this.db.exec('BEGIN IMMEDIATE');
-        try {
-            const task = this.transitionTaskInTransaction(id, patch, origin);
-            this.db.exec('COMMIT');
-            return task;
-        }
-        catch (error) {
-            this.db.exec('ROLLBACK');
-            throw error;
-        }
+        const previousGeneration = this.onOwnerTaskChangeCommitted ? this.readGeneration() : null;
+        const updated = this.db.transaction(() => this.transitionTaskInTransaction(id, patch, origin), 'immediate')();
+        this.notifyOwnerTaskCommit(previousGeneration);
+        return updated;
     }
     /**
      * Recorrect an existing owner row with a NAMED disposition.
@@ -1314,9 +1612,12 @@ class TaskLedger {
      * owner rows and could only be "closed" as if they had been done.
      *
      * Every path requires the exact current revision, a non-empty bounded reason
-     * preserved as `latest_event`, an OWNER row, and the same candidate/workorder
-     * authority checks as task_update (TG-03/TG-04/TG-06) - a terminal or foreign
-     * board attempt cannot mutate an unrelated row. The whole transition, its
+     * preserved as `latest_event`, an OWNER row, and the same workorder-attempt
+     * currency and causal-provenance checks as task_update (TG-03/TG-04/TG-06) -
+     * a terminal attempt of any kind cannot mutate a row, and an owner-event
+     * decision cannot rest on a fabricated cause. Scheduler hint pages and the
+     * causal batch's channel select what the host READS; they do not narrow the
+     * authenticated owner's decisions. The whole transition, its
      * `resolution_kind` and its effect receipt commit as ONE transaction.
      */
     reclassify(id, input, origin = {}) {
@@ -1334,6 +1635,8 @@ class TaskLedger {
         if (!Number.isSafeInteger(input.expected_revision) || input.expected_revision < 0) {
             throw new Error('task_reclassify: expected_revision must be a non-negative integer');
         }
+        const previousGeneration = this.onOwnerTaskChangeCommitted ? this.readGeneration() : null;
+        let record;
         this.db.exec('BEGIN IMMEDIATE');
         try {
             const existing = this.db.prepare('SELECT * FROM operator_tasks WHERE id = ?').get(id);
@@ -1345,54 +1648,67 @@ class TaskLedger {
             if (input.expected_revision !== existing.revision) {
                 throw new Error(`task_reclassify: expected revision ${input.expected_revision}, current ${existing.revision}`);
             }
-            this.assertTaskReclassificationAuthorized(existing, origin);
+            this.assertTaskReclassificationAuthorized(origin);
             const patch = this.buildReclassifyPatch(existing, disposition, reason);
             // Same primitive as task_update: candidate guard, board-attempt liveness,
             // revision-checked UPDATE, effect receipt, temporal generation supersession.
-            const record = this.transitionTaskInTransaction(id, patch, origin);
+            record = this.transitionTaskInTransaction(id, patch, origin);
             this.db.exec('COMMIT');
-            return record;
         }
         catch (error) {
             this.db.exec('ROLLBACK');
             throw error;
         }
+        this.notifyOwnerTaskCommit(previousGeneration);
+        return record;
     }
-    assertTaskReclassificationAuthorized(existing, origin) {
+    assertTaskReclassificationAuthorized(origin) {
         if (origin.workOrderAttemptId !== undefined) {
-            const attempt = this.getWorkOrderById(origin.workOrderAttemptId);
-            if (!attempt || attempt.workKind !== 'board' || attempt.status !== 'in_progress') {
-                throw new Error(`task_reclassify: Board workorder ${String(origin.workOrderAttemptId)} is no longer active`);
-            }
-            const { attempts: _attempts, ...payload } = attempt.payload;
-            (0, workorder_publishers_js_1.validateWorkOrderPayload)('board', payload);
-            const candidates = Array.isArray(payload.reclassificationCandidates)
-                ? payload.reclassificationCandidates
-                : [];
-            const candidate = candidates.find((item) => item.taskId === existing.id);
-            if (!candidate || candidate.taskRevision !== existing.revision) {
-                throw new Error(`task_reclassify: task ${existing.id} is outside this host-issued Board candidate set`);
-            }
+            // A carried attempt must be CURRENT. Its kind is scheduling metadata: a
+            // wiki or temporal run that discovers a record-shaped owner row may
+            // reclassify it under the same CAS rules as a Board run. Its candidate
+            // page is a bounded-read hint, so a row outside the page is not refused.
+            this.assertWorkOrderAttemptActive('task_reclassify', origin.workOrderAttemptId);
         }
         if (origin.reclassificationCauseBound) {
             const eventIds = (origin.causeEventIds ?? []).filter(effects_js_1.isUsableCause);
             if (eventIds.length === 0) {
                 throw new Error('task_reclassify: owner-event reclassification requires causal events');
             }
-            if (existing.source_event_id && eventIds.includes(existing.source_event_id))
-                return;
-            const placeholders = eventIds.map(() => '?').join(',');
-            const channels = this.db
-                .prepare(`SELECT DISTINCT inbox.channel_key
-             FROM owner_event_inbox AS inbox, json_each(inbox.event_ids_json) AS event
-            WHERE event.value IN (${placeholders})`)
-                .all(...eventIds);
-            if (existing.source_channel === null ||
-                !channels.some((row) => row.channel_key === existing.source_channel)) {
-                throw new Error(`task_reclassify: task ${existing.id} is outside this owner-event source channel`);
+            // Provenance: every cause must be an event a durable inbox batch actually
+            // carried. The batch's channel is not compared with the task's source -
+            // cross-source relevance is MAMA's judgment under the owner's grant.
+            const unknown = this.findCausalEventsWithoutInboxBatch(eventIds);
+            if (unknown.length > 0) {
+                throw new Error(`task_reclassify: causal event(s) ${unknown.join(', ')} were not carried by any owner-event inbox batch`);
             }
         }
     }
+    /**
+     * A retained attempt context outlives its workorder: a late direct or nested
+     * tool call can still carry it after the row reached a terminal status. Any
+     * lifecycle judgment made under a carried attempt requires that attempt to be
+     * the claimed, in-progress one, whatever its work kind.
+     */
+    assertWorkOrderAttemptActive(tool, attemptId) {
+        const attempt = this.getWorkOrderById(attemptId);
+        if (!attempt) {
+            throw new Error(`${tool}: workorder ${String(attemptId)} is no longer active (missing)`);
+        }
+        if (attempt.status !== 'in_progress') {
+            throw new Error(`${tool}: ${attempt.workKind} workorder ${String(attemptId)} is no longer active (${attempt.status})`);
+        }
+        return attempt;
+    }
+    findCausalEventsWithoutInboxBatch(eventIds) {
+        const placeholders = eventIds.map(() => '?').join(',');
+        const known = new Set(this.db
+            .prepare(`SELECT DISTINCT event.value AS event_id
+               FROM owner_event_inbox AS inbox, json_each(inbox.event_ids_json) AS event
+              WHERE event.value IN (${placeholders})`)
+            .all(...eventIds).map((row) => row.event_id));
+        return eventIds.filter((eventId) => !known.has(eventId));
+    }
     buildReclassifyPatch(existing, disposition, reason) {
         const base = {
             latest_event: reason,
@@ -1463,18 +1779,21 @@ class TaskLedger {
         if (existing.kind === 'system') {
             throw new Error(`task_update: task ${id} is a system workorder row (host-managed)`);
         }
-        const revisionAttempt = origin.requiresExpectedRevision
-            ? this.getWorkOrderById(origin.workOrderAttemptId ?? -1)
-            : null;
         const hasLifecyclePatch = Object.prototype.hasOwnProperty.call(patch, 'status') ||
             Object.prototype.hasOwnProperty.call(patch, 'due_at') ||
             Object.prototype.hasOwnProperty.call(patch, 'latest_event') ||
             Object.prototype.hasOwnProperty.call(patch, 'completion_criteria');
-        const isBoardWorkorderLifecycleJudgment = revisionAttempt?.workKind === 'board' && hasLifecyclePatch;
-        if (isBoardWorkorderLifecycleJudgment && revisionAttempt.status !== 'in_progress') {
-            throw new Error(`task_update: board workorder ${revisionAttempt.id} is no longer active (${revisionAttempt.status})`);
-        }
-        const isWorkorderLifecycleJudgment = isBoardWorkorderLifecycleJudgment && revisionAttempt.status === 'in_progress';
+        // Direct-ABI mutation under a carried attempt: the attempt must be current
+        // for EVERY patch shape (a stale attempt renaming a task is as stale as one
+        // closing it). Work kind is scheduling metadata, not owner authority.
+        // Internal receipted primitives (external lifecycle apply) do not set the
+        // direct-ABI guard and validate their own claimed attempt separately.
+        const isCarriedDirectMutation = origin.requiresExpectedRevision === true && origin.workOrderAttemptId !== undefined;
+        if (isCarriedDirectMutation) {
+            this.assertWorkOrderAttemptActive('task_update', origin.workOrderAttemptId);
+        }
+        // A lifecycle judgment additionally proves the revision actually read plus a reason.
+        const isWorkorderLifecycleJudgment = isCarriedDirectMutation && hasLifecyclePatch;
         if (isWorkorderLifecycleJudgment) {
             if (!Number.isSafeInteger(patch.expected_revision) || patch.expected_revision < 0) {
                 throw new Error('task_update: lifecycle workorder requires expected_revision');
@@ -1521,6 +1840,7 @@ class TaskLedger {
             last_temporal_attempt_id: existing.last_temporal_attempt_id,
             review_started_at: existing.review_started_at,
             review_anchor_event_id: existing.review_anchor_event_id,
+            review_anchor_source_channel: existing.review_anchor_source_channel,
             completion_criteria: existing.completion_criteria,
             resolution_kind: existing.resolution_kind,
         };
@@ -1551,6 +1871,7 @@ class TaskLedger {
         if (leavingVerifiedReview) {
             next.review_started_at = null;
             next.review_anchor_event_id = null;
+            next.review_anchor_source_channel = null;
             next.due_at = null;
             next.deadline = null;
             next.deadline_offset_minutes = null;
@@ -1569,14 +1890,15 @@ class TaskLedger {
             if (!evidence) {
                 throw new Error('task_update: review requires host-verified submission evidence');
             }
-            if (existing.source_channel !== evidence.sourceChannel) {
-                throw new Error('task_update: review evidence is outside the task source boundary');
+            if (!evidence.sourceChannel.trim()) {
+                throw new Error('task_update: review evidence source is required');
             }
             if (!Number.isSafeInteger(evidence.sourceTimestampMs) || evidence.sourceTimestampMs < 0) {
                 throw new Error('task_update: review evidence timestamp is invalid');
             }
             next.review_started_at = evidence.sourceTimestampMs;
             next.review_anchor_event_id = evidence.eventIndexId;
+            next.review_anchor_source_channel = evidence.sourceChannel;
             next.due_at = evidence.sourceTimestampMs + 14 * 24 * 60 * 60 * 1000;
             next.deadline = new Date(next.due_at).toISOString().slice(0, 10);
             next.deadline_offset_minutes = 0;
@@ -1643,6 +1965,7 @@ class TaskLedger {
             'last_temporal_attempt_id',
             'review_started_at',
             'review_anchor_event_id',
+            'review_anchor_source_channel',
             'completion_criteria',
             'resolution_kind',
         ];
@@ -1700,23 +2023,18 @@ class TaskLedger {
         // candidate payload must remain authoritative in that case. Decision
         // application still calls loadBoardCandidate(), which requires a claimed
         // in-progress attempt.
+        //
+        // The payload's reclassificationCandidates page is NOT consulted here: it is
+        // the scheduler's bounded-read hint, and qualifying a legacy row the owner
+        // discovered outside that page is an ordinary owner decision guarded by
+        // attempt currency, expected_revision and a plain reason (see
+        // transitionTaskInTransaction). Only host-attested external binding /
+        // lifecycle candidates keep their receipted-decision-only rule below.
         if (!attempt || attempt.workKind !== 'board') {
             return;
         }
         const { attempts: _attempts, ...payload } = attempt.payload;
         (0, workorder_publishers_js_1.validateWorkOrderPayload)('board', payload);
-        if (Object.prototype.hasOwnProperty.call(patch, 'completion_criteria') &&
-            !origin.taskCreateUpsert) {
-            const reclassificationCandidates = Array.isArray(payload.reclassificationCandidates)
-                ? payload.reclassificationCandidates
-                : [];
-            const qualificationCandidate = reclassificationCandidates.find((candidate) => candidate.taskId === taskId);
-            if (!qualificationCandidate ||
-                (patch.expected_revision !== undefined &&
-                    qualificationCandidate.taskRevision !== patch.expected_revision)) {
-                throw new Error(`task_update: task ${taskId} is outside this host-issued qualification candidate set`);
-            }
-        }
         if (payload.mode !== 'reconcile' || !payload.candidates) {
             return;
         }
@@ -1966,7 +2284,9 @@ class TaskLedger {
                     currentOccurrence !== input.occurrenceKey) {
                     throw new Error(`temporal generation: task occurrence no longer matches enqueue input`);
                 }
-                if (this.temporalSourceIdentifierRef(task.sourceChannel) !== sourceChannelRef ||
+                if (this.temporalSourceIdentifierRef(task.status === 'review'
+                    ? (task.reviewAnchorSourceChannel ?? task.sourceChannel)
+                    : task.sourceChannel) !== sourceChannelRef ||
                     this.temporalSourceIdentifierRef(task.status === 'review' && task.reviewAnchorEventId
                         ? task.reviewAnchorEventId
                         : task.sourceEventId) !== sourceEventIdRef) {
@@ -2328,6 +2648,7 @@ class TaskLedger {
             throw new Error('temporal effect requires a valid host evidence attestation');
         }
         let receipt = null;
+        const previousGeneration = this.onOwnerTaskChangeCommitted ? this.readGeneration() : null;
         this.db.exec('BEGIN IMMEDIATE');
         try {
             const context = this.assertTemporalWorkContextActive(suppliedContext);
@@ -2352,6 +2673,7 @@ class TaskLedger {
                 last_temporal_attempt_id: context.attemptId,
                 review_started_at: existing.review_started_at,
                 review_anchor_event_id: existing.review_anchor_event_id,
+                review_anchor_source_channel: existing.review_anchor_source_channel,
             };
             const auditParts = [`reason=${input.reason.trim()}`];
             if (input.outcome === 'final_no_update') {
@@ -2369,6 +2691,7 @@ class TaskLedger {
                     // as the task_update path clears them. A later reopen re-verifies.
                     next.review_started_at = null;
                     next.review_anchor_event_id = null;
+                    next.review_anchor_source_channel = null;
                     if (existing.review_started_at !== null &&
                         !Object.prototype.hasOwnProperty.call(input, 'due_at')) {
                         next.due_at = null;
@@ -2417,6 +2740,7 @@ class TaskLedger {
                 'last_temporal_attempt_id',
                 'review_started_at',
                 'review_anchor_event_id',
+                'review_anchor_source_channel',
             ];
             const changedFields = persistedColumns.filter((column) => next[column] !== existing[column]);
             const afterRevision = existing.revision + 1;
@@ -2503,6 +2827,7 @@ class TaskLedger {
             this.db.exec('ROLLBACK');
             throw error;
         }
+        this.notifyOwnerTaskCommit(previousGeneration);
         if (!receipt)
             throw new Error(`temporal effect produced no receipt`);
         return receipt;
@@ -2912,7 +3237,9 @@ class TaskLedger {
         }
         if (task.temporalEpoch !== temporalEpoch ||
             (0, task_temporal_js_1.occurrenceKeyForTask)(task) !== occurrenceKey ||
-            this.temporalSourceIdentifierRef(task.sourceChannel) !== sourceChannel ||
+            this.temporalSourceIdentifierRef(task.status === 'review'
+                ? (task.reviewAnchorSourceChannel ?? task.sourceChannel)
+                : task.sourceChannel) !== sourceChannel ||
             this.temporalSourceIdentifierRef(task.status === 'review' && task.reviewAnchorEventId
                 ? task.reviewAnchorEventId
                 : task.sourceEventId) !== sourceEventId ||