@jungjaehoon/mama-os 0.48.0 → 0.48.2

package/dist/operator/task-ledger.js

@@ -7,7 +7,8 @@
  * workorder state. Implements the pre-existing `TaskSource` interface
  * (operator-interfaces.ts) so the board projects one task model, not two.
  *
- * Reconcile runs create/update rows through the task_create/task_update gateway
+ * Owner conversations create rows through task_create. Reconcile runs update or
+ * reclassify existing rows through the task_update/task_reclassify gateway
  * tools; the pipeline board slot is a projection of `list({order:
  * 'deadline_priority'})`. The agent proposes task changes, while this ledger
  * enforces revisions, temporal ownership, idempotency, and atomic receipts.
@@ -20,11 +21,12 @@
  * (start.ts opens and closes it once) - deliberately no close() here.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskLedger = exports.WORKORDER_CHANNEL_PREFIX = exports.TEMPORAL_WORKORDER_MAX_ATTEMPTS = exports.WORKORDER_KINDS = exports.TASK_KINDS = exports.TASK_PRIORITIES = exports.TASK_STATUSES = void 0;
+exports.TaskLedger = exports.TASK_COMPLETION_CRITERIA_MAX_LENGTH = exports.TASK_RECLASSIFY_REASON_MAX_LENGTH = exports.TASK_RECLASSIFY_DISPOSITIONS = exports.TASK_RESOLUTION_KINDS = exports.WORKORDER_CHANNEL_PREFIX = exports.TEMPORAL_WORKORDER_MAX_ATTEMPTS = exports.WORKORDER_KINDS = exports.TASK_KINDS = exports.TASK_PRIORITIES = exports.TASK_STATUSES = void 0;
 const node_crypto_1 = require("node:crypto");
 const operator_task_temporal_js_1 = require("../db/migrations/operator-task-temporal.js");
 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 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");
@@ -73,6 +75,28 @@ exports.WORKORDER_CHANNEL_PREFIX = 'workorder:';
 const EFFECT_CAUSE_CHUNK = 500;
 const KNOWN_WORKORDER_CHANNELS = exports.WORKORDER_KINDS.map((workKind) => `${exports.WORKORDER_CHANNEL_PREFIX}${workKind}`);
 const KNOWN_WORKORDER_CHANNELS_SQL = KNOWN_WORKORDER_CHANNELS.map(() => '?').join(',');
+/**
+ * Why a row reached its terminal state. Without this the agent cannot tell
+ * completed work from an item that was never a task, which is how connector
+ * observations, principles and open questions accumulated as owner rows.
+ */
+exports.TASK_RESOLUTION_KINDS = [
+    'completed_evidence',
+    'completed_no_issue',
+    'non_task_record',
+    'non_task_memory',
+];
+/** The recorrection an agent may apply to an existing owner row. */
+exports.TASK_RECLASSIFY_DISPOSITIONS = [
+    'completed_evidence',
+    'completed_no_issue',
+    'non_task_record',
+    'non_task_memory',
+    'reopen',
+];
+/** Upper bound on the preserved reason, matching latest_event's practical size. */
+exports.TASK_RECLASSIFY_REASON_MAX_LENGTH = 2000;
+exports.TASK_COMPLETION_CRITERIA_MAX_LENGTH = 500;
 const PRIORITY_RANK = { high: 0, normal: 1, low: 2 };
 function encodeListCursor(payload) {
     return Buffer.from(JSON.stringify(payload), 'utf8').toString('base64url');
@@ -122,6 +146,18 @@ function assertIsoDate(value, field) {
         throw new Error(`${field} must be an ISO date (YYYY-MM-DD), got: ${value}`);
     }
 }
+function normalizeCompletionCriteria(value, operation) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${operation}: completion_criteria must be a non-empty string`);
+    }
+    const normalized = value.trim();
+    if (normalized.length > exports.TASK_COMPLETION_CRITERIA_MAX_LENGTH) {
+        throw new Error(`${operation}: completion_criteria must be at most ${exports.TASK_COMPLETION_CRITERIA_MAX_LENGTH} characters`);
+    }
+    return normalized;
+}
 function rowToRecord(row, now, timeZone) {
     return {
         id: row.id,
@@ -153,6 +189,8 @@ function rowToRecord(row, now, timeZone) {
         }, now, timeZone),
         reviewStartedAt: row.review_started_at,
         reviewAnchorEventId: row.review_anchor_event_id,
+        completionCriteria: row.completion_criteria ?? null,
+        resolutionKind: (row.resolution_kind ?? null),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -226,6 +264,8 @@ class TaskLedger {
         last_temporal_attempt_id INTEGER,
         review_started_at INTEGER,
         review_anchor_event_id TEXT,
+        completion_criteria TEXT,
+        resolution_kind TEXT,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL`;
     // Unique-index predicate excludes terminal rows so a terminal keyed workorder
@@ -292,6 +332,7 @@ class TaskLedger {
             (0, operator_task_temporal_js_1.applyOperatorTaskTemporalMigration)(this.db);
             (0, operator_task_external_lifecycle_js_1.applyOperatorTaskExternalLifecycleMigration)(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.
             const idxRow = this.db
                 .prepare(`SELECT sql FROM sqlite_master WHERE type='index' AND name='idx_operator_tasks_source'`)
@@ -377,6 +418,16 @@ class TaskLedger {
             where.push('updated_at >= ?');
             params.push(filter.updatedSinceMs);
         }
+        if (filter.updatedBeforeMs !== undefined) {
+            where.push('updated_at < ?');
+            params.push(filter.updatedBeforeMs);
+        }
+        if (filter.qualification === 'qualified') {
+            where.push('completion_criteria IS NOT NULL');
+        }
+        else if (filter.qualification === 'legacy_unqualified') {
+            where.push('completion_criteria IS NULL');
+        }
         return { where, params };
     }
     /** ORDER BY for both list() and listPage(); the trailing id makes it a TOTAL order,
@@ -873,7 +924,15 @@ class TaskLedger {
                     outcome = 'superseded';
                 }
                 else if (input.decision === 'apply') {
-                    const transitioned = this.transitionTaskInTransaction(candidate.taskId, { status: candidate.proposedStatus, latest_event: candidate.evidenceSummary }, origin, true);
+                    const terminalEvidence = candidate.proposedStatus === 'done' || candidate.proposedStatus === 'cancelled';
+                    const transitioned = this.transitionTaskInTransaction(candidate.taskId, {
+                        status: candidate.proposedStatus,
+                        latest_event: candidate.evidenceSummary,
+                        // This candidate is a host-issued current authoritative lifecycle
+                        // observation. Preserve its semantic completion, or clear an earlier
+                        // terminal classification when later feedback reopens the same row.
+                        resolution_kind: terminalEvidence ? 'completed_evidence' : null,
+                    }, origin, true);
                     taskRevisionAfter = transitioned.revision;
                     outcome = 'applied';
                 }
@@ -1053,6 +1112,9 @@ class TaskLedger {
         }
         const normalizedDeadline = exactDue?.deadline ?? input.deadline ?? null;
         const initialTemporalEpoch = normalizedDeadline !== null ? 1 : 0;
+        // Optional HERE on purpose: the PUBLIC task_create boundary requires it, while
+        // internal/system seeding and legacy callers stay backward compatible.
+        const normalizedCompletionCriteria = normalizeCompletionCriteria(input.completion_criteria, 'task_create');
         const now = this.now();
         if (input.source_channel && input.source_event_id) {
             // kind='owner' probe: an agent-supplied (channel, event) pair can never
@@ -1073,6 +1135,9 @@ class TaskLedger {
                     ...(input.due_at !== undefined ? { due_at: input.due_at } : {}),
                     ...(input.confirmed !== undefined ? { confirmed: input.confirmed } : {}),
                     ...(input.latest_event !== undefined ? { latest_event: input.latest_event } : {}),
+                    ...(normalizedCompletionCriteria !== null
+                        ? { completion_criteria: normalizedCompletionCriteria }
+                        : {}),
                     ...(input.expected_revision !== undefined
                         ? { expected_revision: input.expected_revision }
                         : {}),
@@ -1084,6 +1149,7 @@ class TaskLedger {
                 // carried nothing.
                 {
                     ...origin,
+                    taskCreateUpsert: true,
                     causeEventIds: origin.causeEventIds?.length
                         ? origin.causeEventIds
                         : input.source_event_id
@@ -1099,9 +1165,9 @@ class TaskLedger {
                 .prepare(`INSERT INTO operator_tasks
            (title, status, priority, assignee, deadline, due_at, deadline_offset_minutes,
             revision, temporal_epoch, source_channel, source_event_id, latest_event,
-            auto_created, confirmed, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(input.title.trim(), input.status ?? 'pending', input.priority ?? 'normal', input.assignee ?? null, normalizedDeadline, exactDue?.dueAt ?? null, exactDue?.offsetMinutes ?? null, initialTemporalEpoch, input.source_channel ?? null, input.source_event_id ?? null, input.latest_event ?? null, 1, input.confirmed ? 1 : 0, now, now);
+            auto_created, confirmed, completion_criteria, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.title.trim(), input.status ?? 'pending', input.priority ?? 'normal', input.assignee ?? null, normalizedDeadline, exactDue?.dueAt ?? null, exactDue?.offsetMinutes ?? null, initialTemporalEpoch, input.source_channel ?? null, input.source_event_id ?? null, input.latest_event ?? null, 1, input.confirmed ? 1 : 0, normalizedCompletionCriteria, now, now);
             createdId = Number(result.lastInsertRowid);
             this.recordTaskChange({
                 kind: 'task_create',
@@ -1142,6 +1208,7 @@ class TaskLedger {
                     source_event_id: input.source_event_id ?? null,
                     latest_event: input.latest_event ?? null,
                     confirmed: input.confirmed ? 1 : 0,
+                    completion_criteria: normalizedCompletionCriteria,
                 },
                 atMs: now,
             });
@@ -1203,6 +1270,148 @@ class TaskLedger {
             throw error;
         }
     }
+    /**
+     * Recorrect an existing owner row with a NAMED disposition.
+     *
+     * Records and tasks are separate. Without a semantic terminal reason the agent
+     * could not distinguish completed work from an item that was never a task, so
+     * connector observations, principles, lessons and open questions accumulated as
+     * 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
+     * `resolution_kind` and its effect receipt commit as ONE transaction.
+     */
+    reclassify(id, input, origin = {}) {
+        const disposition = input?.disposition;
+        if (!exports.TASK_RECLASSIFY_DISPOSITIONS.includes(disposition)) {
+            throw new Error(`task_reclassify: disposition must be one of ${exports.TASK_RECLASSIFY_DISPOSITIONS.join('|')}, got: ${String(disposition)}`);
+        }
+        const reason = typeof input.reason === 'string' ? input.reason.trim() : '';
+        if (reason.length === 0) {
+            throw new Error('task_reclassify: reason must be a non-empty string');
+        }
+        if (reason.length > exports.TASK_RECLASSIFY_REASON_MAX_LENGTH) {
+            throw new Error(`task_reclassify: reason must be at most ${exports.TASK_RECLASSIFY_REASON_MAX_LENGTH} characters`);
+        }
+        if (!Number.isSafeInteger(input.expected_revision) || input.expected_revision < 0) {
+            throw new Error('task_reclassify: expected_revision must be a non-negative integer');
+        }
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const existing = this.db.prepare('SELECT * FROM operator_tasks WHERE id = ?').get(id);
+            if (!existing)
+                throw new Error(`task_reclassify: no task with id ${id}`);
+            if (existing.kind === 'system') {
+                throw new Error(`task_reclassify: task ${id} is a system workorder row (owner rows only)`);
+            }
+            if (input.expected_revision !== existing.revision) {
+                throw new Error(`task_reclassify: expected revision ${input.expected_revision}, current ${existing.revision}`);
+            }
+            this.assertTaskReclassificationAuthorized(existing, 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);
+            this.db.exec('COMMIT');
+            return record;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    assertTaskReclassificationAuthorized(existing, 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`);
+            }
+        }
+        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`);
+            }
+        }
+    }
+    buildReclassifyPatch(existing, disposition, reason) {
+        const base = {
+            latest_event: reason,
+            expected_revision: existing.revision,
+        };
+        if (disposition === 'reopen') {
+            if (existing.status !== 'done' && existing.status !== 'cancelled') {
+                throw new Error(`task_reclassify: reopen requires a terminal owner row, task is '${existing.status}'`);
+            }
+            // A reopened row must not inherit a deadline that already passed: it would
+            // read as overdue the moment it reopens. A still-future deadline is kept.
+            const stale = this.isDeadlineInThePast(existing);
+            return {
+                ...base,
+                status: 'pending',
+                resolution_kind: null,
+                ...(stale ? { deadline: null, due_at: null } : {}),
+            };
+        }
+        if (existing.status === 'done' || existing.status === 'cancelled') {
+            throw new Error(`task_reclassify: ${disposition} requires an active owner row, task is '${existing.status}'`);
+        }
+        if (disposition === 'completed_evidence') {
+            return { ...base, status: 'done', resolution_kind: 'completed_evidence' };
+        }
+        if (disposition === 'completed_no_issue') {
+            // Owner policy: a PAST deadline plus a complete relevant-source check with no
+            // issue is enough. Without a passed deadline there is nothing to conclude from.
+            if (!this.isDeadlineInThePast(existing)) {
+                throw new Error('task_reclassify: completed_no_issue requires a deadline or due_at already in the past');
+            }
+            return { ...base, status: 'done', resolution_kind: 'completed_no_issue' };
+        }
+        // non_task_record / non_task_memory: this was never a task. Cancelled, not done,
+        // so accounting never reads it as finished work.
+        return {
+            ...base,
+            status: 'cancelled',
+            completion_criteria: null,
+            resolution_kind: disposition,
+        };
+    }
+    /** True when the row carries a deadline/due_at that has already passed. */
+    isDeadlineInThePast(existing) {
+        const state = (0, task_temporal_js_1.deriveTemporalState)({
+            // Terminal rows derive 'closed', which would hide a genuinely past deadline;
+            // ask the temporal question about the CLOCK fields only.
+            status: 'pending',
+            dueAt: existing.due_at,
+            deadlineIso: existing.deadline,
+            deadlineOffsetMinutes: existing.deadline_offset_minutes,
+        }, this.now(), this.timeZone);
+        return state === 'exact_overdue' || state === 'date_overdue';
+    }
     /**
      * The one mutation primitive for owner-task state. Callers own the outer
      * transaction so lifecycle receipts, effects, generation ownership, and the
@@ -1224,7 +1433,8 @@ class TaskLedger {
             : 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, '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})`);
@@ -1276,6 +1486,8 @@ 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,
+            completion_criteria: existing.completion_criteria,
+            resolution_kind: existing.resolution_kind,
         };
         if (patch.title !== undefined)
             next.title = patch.title.trim();
@@ -1289,6 +1501,12 @@ class TaskLedger {
             next.latest_event = patch.latest_event;
         if (patch.confirmed !== undefined)
             next.confirmed = patch.confirmed ? 1 : 0;
+        if (patch.completion_criteria !== undefined) {
+            next.completion_criteria = normalizeCompletionCriteria(patch.completion_criteria, 'task_update');
+        }
+        // Host-internal (reclassify only); the public task_update surface rejects it.
+        if (patch.resolution_kind !== undefined)
+            next.resolution_kind = patch.resolution_kind;
         const leavingVerifiedReview = existing.status === 'review' &&
             patch.status !== undefined &&
             patch.status !== 'review' &&
@@ -1353,6 +1571,16 @@ class TaskLedger {
         const terminalToOpen = (existing.status === 'done' || existing.status === 'cancelled') &&
             next.status !== 'done' &&
             next.status !== 'cancelled';
+        if (terminalToOpen && existing.resolution_kind !== null && patch.resolution_kind !== null) {
+            throw new Error('task_update: a classified terminal row must reopen through task_reclassify');
+        }
+        if (patch.status !== undefined &&
+            next.status !== existing.status &&
+            patch.resolution_kind === undefined) {
+            // A generic status change has no semantic reclassification authority. Clear an
+            // old terminal meaning rather than rendering contradictory status/reason pairs.
+            next.resolution_kind = null;
+        }
         const openToTerminal = existing.status !== 'done' &&
             existing.status !== 'cancelled' &&
             (next.status === 'done' || next.status === 'cancelled');
@@ -1380,6 +1608,8 @@ class TaskLedger {
             'last_temporal_attempt_id',
             'review_started_at',
             'review_anchor_event_id',
+            'completion_criteria',
+            'resolution_kind',
         ];
         const changedColumns = persistedColumns.filter((column) => next[column] !== existing[column]);
         if (changedColumns.length === 0) {
@@ -1424,7 +1654,8 @@ class TaskLedger {
     assertCandidateTaskMutationAllowed(taskId, patch, origin) {
         if (origin.workOrderAttemptId === undefined ||
             (!Object.prototype.hasOwnProperty.call(patch, 'status') &&
-                !Object.prototype.hasOwnProperty.call(patch, 'latest_event'))) {
+                !Object.prototype.hasOwnProperty.call(patch, 'latest_event') &&
+                !Object.prototype.hasOwnProperty.call(patch, 'completion_criteria'))) {
             return;
         }
         const attempt = this.getWorkOrderById(origin.workOrderAttemptId);
@@ -1439,6 +1670,18 @@ class TaskLedger {
         }
         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;
         }
@@ -1546,6 +1789,40 @@ class TaskLedger {
             completedAt: row.updated_at,
         };
     }
+    /**
+     * The newest COMPLETED wiki run - the baseline the wiki daily-continuity
+     * planner gates against (wiki-continuity.ts). Only `status='done'` rows count.
+     *
+     * `ownerDate`/`sourceWatermark` are read straight from the completed run's
+     * payload and are null for a LEGACY row (one enqueued before the continuity
+     * fields existed): the planner treats a null-field baseline as "no baseline"
+     * and re-runs from the owner day's start rather than fabricating a boundary.
+     */
+    lastCompletedWikiRun() {
+        const row = this.db
+            .prepare(`SELECT json_extract(payload, '$.ownerDate') AS owner_date,
+                json_extract(payload, '$.sourceWatermark') AS source_watermark,
+                json_extract(payload, '$.range.end_ms') AS covered_through_ms,
+                updated_at
+           FROM operator_tasks
+          WHERE kind = 'system' AND source_channel = ? AND status = 'done'
+          ORDER BY id DESC LIMIT 1`)
+            .get(`${exports.WORKORDER_CHANNEL_PREFIX}wiki`);
+        if (!row)
+            return null;
+        return {
+            ownerDate: typeof row.owner_date === 'string' && row.owner_date.length > 0 ? row.owner_date : null,
+            sourceWatermark: typeof row.source_watermark === 'string' && row.source_watermark.length > 0
+                ? row.source_watermark
+                : null,
+            // The prior run's range.end_ms - where the next same-day run resumes.
+            // Null for a legacy row with no range; never fabricated.
+            coveredThroughMs: typeof row.covered_through_ms === 'number' && Number.isFinite(row.covered_through_ms)
+                ? row.covered_through_ms
+                : null,
+            completedAt: row.updated_at,
+        };
+    }
     /**
      * Board-input term for the NATIVE owner task ledger - the pipeline slot's
      * projection source. Reuses payloadHash(): it already digests exactly the