maka-agent 0.2.0-dev.21.20260905 → 0.2.0-dev.22.20260905

package/node_modules/@maka/runtime-host/dist/protocol/index.js

@@ -62,7 +62,9 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 116;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 117;
+// 117: WorkHub exposes only one correction linkage per bounded candidate and
+// no longer returns the Host's complete active-link set.
 // 116: User deletion rejects workflow-owned Artifacts with operation_conflict.
 // 115: Artifact creation requires explicit source ownership.
 // 114: Artifacts are physically deleted and no longer expose tombstone status.

package/node_modules/@maka/runtime-host/dist/protocol/workhub-coordination.js

@@ -277,14 +277,7 @@ export function decodeWorkHubCoordinationActResult(value) {
     throw invalidProtocolFrame('Invalid WorkHub Coordination action disposition');
 }
 function decodeWorkHubCoordinationCandidate(value) {
-    const candidate = requireExactRecord(value, 'WorkHub Coordination candidate', [
-        'candidateRef',
-        'sessionId',
-        'sessionName',
-        'workspace',
-        'state',
-        'updatedAt',
-    ]);
+    const candidate = requireShapedRecord(value, 'WorkHub Coordination candidate', ['candidateRef', 'sessionId', 'sessionName', 'workspace', 'state', 'updatedAt'], ['latestDelegationActionId']);
     return {
         candidateRef: requireEntityId(candidate.candidateRef, 'WorkHub candidate ref'),
         sessionId: requireEntityId(candidate.sessionId, 'WorkHub candidate Session id'),
@@ -292,6 +285,11 @@ function decodeWorkHubCoordinationCandidate(value) {
         workspace: decodeWorkspaceProjection(candidate.workspace),
         state: candidateState(candidate.state),
         updatedAt: requireCount(candidate.updatedAt, 'WorkHub candidate update time'),
+        ...(candidate.latestDelegationActionId === undefined
+            ? {}
+            : {
+                latestDelegationActionId: requireEntityId(candidate.latestDelegationActionId, 'WorkHub latest delegation action id'),
+            }),
     };
 }
 function decodeWorkHubCoordinationProposal(value) {

package/node_modules/@maka/runtime-host/dist/server/execution-composition.js

@@ -1038,8 +1038,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             continuity: continuityCoordinator,
             executions: coordinator,
             sessionActions: {
-                readDelegationRetirement: async (assignment) => {
-                    const disposition = await messages.readMessageExecutionDisposition(assignment.targetSessionId, assignment.targetMessageId);
+                readDelegationRetirement: async (assignment, admission) => {
+                    const disposition = admission
+                        ? await messages.readMessageExecutionDispositionAdmitted(assignment.targetSessionId, assignment.targetMessageId, admission)
+                        : await messages.readMessageExecutionDisposition(assignment.targetSessionId, assignment.targetMessageId);
                     if (disposition.kind === 'recovering')
                         return 'recovering';
                     if (disposition.kind === 'pending')
@@ -1394,6 +1396,14 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 recovery: {
                     state: async () => {
                         await skills.recover();
+                        try {
+                            await openedArtifactStore.reclaimUpgradeResidue();
+                        }
+                        catch (error) {
+                            // Leftover bytes are not worth refusing to start over; the next
+                            // start tries again.
+                            console.error(`[runtime-host] upgrade residue could not be reclaimed: ${generalizedErrorMessage(error)}`);
+                        }
                     },
                 },
                 drain: [

package/node_modules/@maka/runtime-host/dist/server/message-coordinator.js

@@ -187,6 +187,9 @@ export class HostMessageCoordinator {
     readMessageExecutionDisposition(sessionId, messageId) {
         return this.#sessionAdmission.run(sessionId, () => this.#resolveMessageExecution(sessionId, messageId));
     }
+    readMessageExecutionDispositionAdmitted(sessionId, messageId, admission) {
+        return this.#sessionAdmission.runAdmitted(sessionId, admission, () => this.#resolveMessageExecution(sessionId, messageId));
+    }
     async #resolveMessageExecution(sessionId, messageId) {
         const receipt = await this.#durableProof.readRootTurnSourceMessageReceipt(sessionId, messageId);
         if (receipt?.admission.sessionId === sessionId &&

package/node_modules/@maka/runtime-host/dist/server/workhub-coordination-action-gate.js

@@ -259,8 +259,7 @@ export class WorkHubCoordinationActionGate {
                 return claimed;
             }
         }
-        const active = await this.#effects.listActiveAssignments();
-        const onTarget = active.filter((assignment) => assignment.targetSessionId === targetSessionId);
+        const onTarget = await this.#effects.listActiveAssignments(targetSessionId);
         if (onTarget.length === 0) {
             throw new WorkHubActionGateFailure('action_conflict', 'WorkHub has no active durable delegation to stop on that Session');
         }

package/node_modules/@maka/runtime-host/dist/server/workhub-coordination-coordinator.js

@@ -79,7 +79,9 @@ export class HostWorkHubCoordinationCoordinator {
             readActionClaim: (actionId) => this.#stores.readWorkHubActionClaim(actionId),
             probeTargetRemoval: async (sessionId) => (await this.#stores.probeSessionRemoval(sessionId)).kind,
             readAssignment: (actionId) => this.#stores.readWorkHubAssignment(actionId),
-            listActiveAssignments: () => this.#listActiveAssignments(),
+            // This lookup is advisory. Stop and replacement both repeat their exact
+            // proof under the Coordination and target admissions before writing.
+            listActiveAssignments: (targetSessionId) => this.#stores.readActiveWorkHubAssignmentsByTarget([targetSessionId]),
             readReplacement: (delegationId) => this.#stores.readWorkHubReplacement(delegationId),
             readReplacementAbort: (delegationId) => this.#stores.readWorkHubReplacementAbort(delegationId),
             readSupersession: (delegationId) => this.#stores.readWorkHubSupersession(delegationId),
@@ -113,6 +115,7 @@ export class HostWorkHubCoordinationCoordinator {
     #prepareReplacement(input) {
         const suffix = workHubDestructiveClaimIdentitySuffix(input.replacesDelegationId);
         return this.#commitCoordinationFact({
+            admissionSessionIds: [WORKHUB_COORDINATION_SESSION_ID, input.replacedTargetSessionId],
             read: () => this.#stores.readWorkHubReplacement(input.replacesDelegationId),
             build: (existing) => ({
                 type: 'workhub_coordination',
@@ -136,6 +139,11 @@ export class HostWorkHubCoordinationCoordinator {
             }),
             conflictMessage: 'WorkHub action identity belongs to a different replacement',
             beforeAppend: async () => {
+                const latest = (await this.#stores.readActiveWorkHubAssignmentsByTarget([input.replacedTargetSessionId], 1))[0];
+                if (latest?.actionId !== input.replacesActionId ||
+                    latest.delegationId !== input.replacesDelegationId) {
+                    throw new WorkHubActionGateFailure('action_conflict', 'WorkHub correction source is no longer the latest active delegation');
+                }
                 const stopRequest = await this.#stores.readWorkHubStopRequest(input.replacesDelegationId);
                 if (stopRequest) {
                     const resolution = await this.#stores.readWorkHubStopResolution(input.replacesDelegationId);
@@ -179,21 +187,19 @@ export class HostWorkHubCoordinationCoordinator {
                 userText: input.userText,
             }),
             conflictMessage: 'WorkHub delegation already has a different stop claim',
-            beforeAppend: async () => {
-                const [replacement, supersession, messages] = await Promise.all([
+            beforeAppend: async (lease) => {
+                const [replacement, supersession, activeAssignments] = await Promise.all([
                     this.#stores.readWorkHubReplacement(input.stopsDelegationId),
                     this.#stores.readWorkHubSupersession(input.stopsDelegationId),
-                    this.#stores.readMessagesSnapshot(WORKHUB_COORDINATION_SESSION_ID),
+                    this.#stores.readActiveWorkHubAssignmentsByTarget([input.targetSessionId]),
                 ]);
                 if (replacement || supersession) {
                     throw new WorkHubActionGateFailure('action_conflict', 'WorkHub delegation is already being replaced');
                 }
-                const activeAssignments = activeWorkHubAssignments(messages);
                 // Held lanes make this the last moment the one-target proof can change.
                 // It is proved from opaque delegation identity, so a concurrent rename
                 // is harmless while a concurrent delegation to the same Session is not.
-                const targetActive = activeAssignments.filter((assignment) => assignment.targetSessionId === input.targetSessionId);
-                const source = targetActive.find((assignment) => assignment.actionId === input.stopsActionId &&
+                const source = activeAssignments.find((assignment) => assignment.actionId === input.stopsActionId &&
                     assignment.delegationId === input.stopsDelegationId);
                 if (!source) {
                     throw new WorkHubActionGateFailure('action_conflict', 'WorkHub stop target does not identify one active durable delegation');
@@ -201,10 +207,10 @@ export class HostWorkHubCoordinationCoordinator {
                 // A delegation whose work already finished stays linked but competes
                 // for nothing; only work that could still be stopped makes the target
                 // ambiguous.
-                for (const competitor of targetActive) {
+                for (const competitor of activeAssignments) {
                     if (competitor.delegationId === source.delegationId)
                         continue;
-                    if ((await this.#readDelegationRetirement(competitor)) !== 'retired') {
+                    if ((await this.#readDelegationRetirement(competitor, lease)) !== 'retired') {
                         throw new WorkHubActionGateFailure('action_conflict', 'WorkHub stop target does not identify one active durable delegation');
                     }
                 }
@@ -212,9 +218,6 @@ export class HostWorkHubCoordinationCoordinator {
             unknownOutcomeMessage: 'WorkHub stop request outcome is unknown',
         });
     }
-    async #listActiveAssignments() {
-        return activeWorkHubAssignments(await this.#stores.readMessagesSnapshot(WORKHUB_COORDINATION_SESSION_ID));
-    }
     #resolveStop(input) {
         const request = input.request;
         const suffix = workHubDestructiveClaimIdentitySuffix(request.stopsDelegationId);
@@ -286,7 +289,7 @@ export class HostWorkHubCoordinationCoordinator {
                 }
                 return existing;
             }
-            await options.beforeAppend();
+            await options.beforeAppend(lease);
             try {
                 await this.#stores.appendMessages(WORKHUB_COORDINATION_SESSION_ID, [requested]);
                 await this.#continuity.refreshCanonical(WORKHUB_COORDINATION_SESSION_ID, lease);
@@ -303,7 +306,22 @@ export class HostWorkHubCoordinationCoordinator {
     }
     async #candidates() {
         try {
-            return { ok: true, result: await this.#actionGate.candidates() };
+            const result = await this.#actionGate.candidates();
+            // One bounded read for the whole page. The candidate set is already
+            // capped, and a per-candidate lookup would rescan each target's history.
+            const latestByTarget = new Map((await this.#stores.readActiveWorkHubAssignmentsByTarget(result.candidates.map(({ sessionId }) => sessionId), 1)).map((assignment) => [assignment.targetSessionId, assignment.actionId]));
+            return {
+                ok: true,
+                result: {
+                    candidateSetId: result.candidateSetId,
+                    candidates: result.candidates.map((candidate) => {
+                        const latestDelegationActionId = latestByTarget.get(candidate.sessionId);
+                        return latestDelegationActionId
+                            ? { ...candidate, latestDelegationActionId }
+                            : candidate;
+                    }),
+                },
+            };
         }
         catch {
             return {
@@ -562,27 +580,6 @@ function validCoordinationHeader(header) {
 function digest(value) {
     return `sha256:${createHash('sha256').update(JSON.stringify(value)).digest('hex')}`;
 }
-function activeWorkHubAssignments(messages) {
-    const terminalDelegationIds = new Set();
-    const assignments = [];
-    for (const message of messages) {
-        if (message.type !== 'workhub_coordination')
-            continue;
-        if (message.kind === 'delegation_assigned') {
-            assignments.push(message);
-        }
-        else if (message.kind === 'delegation_superseded') {
-            terminalDelegationIds.add(message.supersededDelegationId);
-        }
-        else if (message.kind === 'delegation_replacement_aborted') {
-            terminalDelegationIds.add(message.abortedDelegationId);
-        }
-        else if (message.kind === 'delegation_stop_resolved' && message.outcome !== 'not_owned') {
-            terminalDelegationIds.add(message.stopsDelegationId);
-        }
-    }
-    return assignments.filter(({ delegationId }) => !terminalDelegationIds.has(delegationId));
-}
 function workHubDestructiveClaimIdentitySuffix(delegationId) {
     return createHash('sha256').update(delegationId, 'utf8').digest('hex').slice(0, 48);
 }

package/node_modules/@maka/storage/dist/artifact-store.js

@@ -233,6 +233,48 @@ class SqliteArtifactStore {
             await this.purgeRecordsUnlocked(this.records.filter((record) => record.sessionId === sessionId));
         });
     }
+    /**
+     * Deletes the files the v1 upgrade recorded as no longer named by any record.
+     *
+     * A path some record has since claimed keeps its bytes. A note is discharged
+     * once its file is gone, and a file that will not go keeps only its own note
+     * rather than holding up the ones behind it.
+     */
+    async reclaimUpgradeResidue() {
+        await this.enqueueMutation(async () => {
+            await this.prepareMutationUnlocked();
+            const recorded = this.metadataRepository.readUpgradeOrphanPaths();
+            if (recorded.length === 0)
+                return;
+            const claimed = new Set(this.records.map((record) => record.relativePath));
+            const directories = new Set();
+            const discharged = [];
+            try {
+                for (const relativePath of recorded) {
+                    if (claimed.has(relativePath) || !isSafeRelativeArtifactPath(relativePath)) {
+                        discharged.push(relativePath);
+                        continue;
+                    }
+                    const target = join(this.artifactRoot, relativePath);
+                    try {
+                        await unlink(target);
+                        directories.add(dirname(target));
+                    }
+                    catch (error) {
+                        if (!isNotFound(error))
+                            continue;
+                    }
+                    discharged.push(relativePath);
+                }
+            }
+            finally {
+                for (const directory of directories)
+                    await syncDirectory(directory);
+            }
+            if (discharged.length > 0)
+                this.metadataRepository.forgetUpgradeOrphanPaths(discharged);
+        });
+    }
     async replayExistingArtifactUnlocked(existing, input, canonical) {
         const expectedBytes = Buffer.from(input.content);
         if (existing.id !== canonical.id ||
@@ -726,9 +768,6 @@ function assertArtifactTurnKey(value) {
 }
 const ARTIFACT_KIND_SET = new Set(ARTIFACT_KINDS);
 const ARTIFACT_SOURCE_SET = new Set(ARTIFACT_SOURCES);
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 async function assertArtifactDirectory(artifactRoot, directory) {
     const root = await ensureRealDirectory(artifactRoot);
     const resolvedDirectory = await realpath(directory);

package/node_modules/@maka/storage/dist/artifact-stores.js

@@ -103,6 +103,7 @@ function createWriterFacade(lease, authority) {
             return run(() => store.copyConversationArtifacts(acceptedInput));
         },
         purgeSessionArtifacts: (sessionId) => run(() => store.purgeSessionArtifacts(sessionId)),
+        reclaimUpgradeResidue: () => run(() => store.reclaimUpgradeResidue()),
         deleteUserArtifactInSession: (sessionId, artifactId) => run(() => store.deleteUserArtifactInSession(sessionId, artifactId)),
         close: () => {
             if (writerByLease.get(lease) === facade)

package/node_modules/@maka/storage/dist/execution-stores.js

@@ -124,6 +124,7 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             createStableSession: (request, initialBoundary) => run(() => sessionStore.createStableSession(request, initialBoundary)),
             assignWorkHubMessage: (request) => run(() => sessionStore.assignWorkHubMessage(request)),
             readWorkHubAssignment: (actionId) => run(() => sessionStore.readWorkHubAssignment(actionId)),
+            readActiveWorkHubAssignmentsByTarget: (targetSessionIds, maxAssignmentsPerTarget) => run(() => sessionStore.readActiveWorkHubAssignmentsByTarget(targetSessionIds, maxAssignmentsPerTarget)),
             readWorkHubReplacement: (delegationId) => run(() => sessionStore.readWorkHubReplacement(delegationId)),
             readWorkHubReplacementAbort: (delegationId) => run(() => sessionStore.readWorkHubReplacementAbort(delegationId)),
             readWorkHubSupersession: (delegationId) => run(() => sessionStore.readWorkHubSupersession(delegationId)),

package/node_modules/@maka/storage/dist/session-store.js

@@ -201,6 +201,10 @@ class SqliteSessionStore {
             ? message
             : undefined;
     }
+    async readActiveWorkHubAssignmentsByTarget(targetSessionIds, maxAssignmentsPerTarget) {
+        await this.ensureReady();
+        return this.metadata.readActiveWorkHubAssignmentsByTarget(targetSessionIds, maxAssignmentsPerTarget);
+    }
     async readWorkHubReplacement(delegationId) {
         const message = await this.readWorkHubCoordinationMessage(`whp_${workHubIdentitySuffix(delegationId)}`);
         return message?.type === 'workhub_coordination' &&
@@ -243,16 +247,7 @@ class SqliteSessionStore {
     }
     async readWorkHubCoordinationMessage(messageId) {
         await this.ensureReady();
-        const throughSequence = await this.metadata.readTranscriptHighWater(WORKHUB_COORDINATION_SESSION_ID);
-        if (throughSequence === null)
-            return undefined;
-        const messages = await this.metadata.readTranscriptMessages(WORKHUB_COORDINATION_SESSION_ID, {
-            messageIds: [messageId],
-            throughSequence,
-            maxMessages: 1,
-            maxBytes: 768 * 1024,
-        });
-        return messages[0];
+        return this.metadata.readMessageById(WORKHUB_COORDINATION_SESSION_ID, messageId);
     }
     async discardStableConversationCopy(sessionId, requestFingerprint) {
         await this.ensureReady();

package/node_modules/@maka/storage/dist/sqlite-artifact-metadata.js

@@ -68,6 +68,21 @@ class SqliteArtifactMetadataRepository {
             }
         });
     }
+    readUpgradeOrphanPaths() {
+        this.assertOpen();
+        const rows = this.#lease.database
+            .prepare('SELECT relative_path FROM artifact_upgrade_orphan_paths ORDER BY relative_path')
+            .all();
+        return rows.map((row) => row.relative_path);
+    }
+    forgetUpgradeOrphanPaths(relativePaths) {
+        this.assertOpen();
+        this.#lease.transaction('write', () => {
+            const forget = this.#lease.database.prepare('DELETE FROM artifact_upgrade_orphan_paths WHERE relative_path = ?');
+            for (const relativePath of relativePaths)
+                forget.run(relativePath);
+        });
+    }
     close() {
         if (this.#closed)
             return;

package/node_modules/@maka/storage/dist/sqlite-artifact-schema.js

@@ -16,28 +16,35 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { decodeArtifactRecordJsons } from './artifact-metadata-codec.js';
+import { decodeArtifactRecordJsons, isSafeRelativeArtifactPath, } from './artifact-metadata-codec.js';
 export const SQLITE_ARTIFACT_SCHEMA_VERSION = 3;
 export function migrateSqliteArtifactDatabase(db) {
     const columns = db.prepare('PRAGMA table_info(artifact_records)').all();
     const retained = [];
-    if (columns.some(({ name }) => name === 'status' || name === 'storage_key')) {
+    // Every path the old table named. Whatever is not carried over is a file no
+    // catalog will name again, and this is the last moment anything knows it is
+    // there. Unlinking here is not an option: a rollback after one would be
+    // unrecoverable, so the paths are recorded for the store to reclaim later.
+    const scanned = [];
+    const hasStatusColumn = columns.some(({ name }) => name === 'status');
+    if (hasStatusColumn || columns.some(({ name }) => name === 'storage_key')) {
         const rows = db.prepare('SELECT * FROM artifact_records').all();
         for (const row of rows) {
-            if (columns.some(({ name }) => name === 'status') && row.status !== 'live')
-                continue;
+            if (typeof row.relative_path === 'string' && isSafeRelativeArtifactPath(row.relative_path)) {
+                scanned.push(row.relative_path);
+            }
             try {
                 const parsed = JSON.parse(String(row.record_json));
                 if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
                     continue;
-                if (parsed.status !== undefined && parsed.status !== 'live')
-                    continue;
-                delete parsed.status;
                 if (parsed.id !== row.artifact_id ||
                     parsed.sessionId !== row.session_id ||
                     parsed.createdAt !== row.created_at ||
                     parsed.relativePath !== row.relative_path)
                     continue;
+                if ([hasStatusColumn ? row.status : undefined, parsed.status].some((value) => value !== undefined && value !== null && value !== 'live'))
+                    continue;
+                delete parsed.status;
                 retained.push(JSON.stringify(parsed));
             }
             catch { }
@@ -58,11 +65,24 @@ export function migrateSqliteArtifactDatabase(db) {
 
     CREATE UNIQUE INDEX IF NOT EXISTS artifact_records_relative_path
       ON artifact_records(relative_path);
+
+    CREATE TABLE IF NOT EXISTS artifact_upgrade_orphan_paths (
+      relative_path TEXT PRIMARY KEY
+    );
+  `);
+    const carried = decodeArtifactRecordJsons(retained);
+    const kept = new Set(carried.map((record) => record.relativePath));
+    const orphan = db.prepare(`
+    INSERT INTO artifact_upgrade_orphan_paths VALUES (?)
+    ON CONFLICT(relative_path) DO NOTHING
   `);
+    for (const relativePath of scanned)
+        if (!kept.has(relativePath))
+            orphan.run(relativePath);
     const insert = db.prepare(`
     INSERT INTO artifact_records VALUES (?, ?, ?, ?, ?)
   `);
-    for (const record of decodeArtifactRecordJsons(retained)) {
+    for (const record of carried) {
         insert.run(record.id, record.sessionId, record.createdAt, record.relativePath, JSON.stringify(record));
     }
 }

package/node_modules/@maka/storage/dist/sqlite-session-metadata-store.js

@@ -45,6 +45,9 @@ const SQLITE_TRANSCRIPT_MESSAGE_LOOKUP_BATCH_SIZE = 256;
 const SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_MESSAGES = 1_024;
 const SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_BYTES = 4 * 1024 * 1024;
 const SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES = 32;
+// Each target Session binds three parameters in the linkage query. Stay well
+// inside SQLite's bound-parameter limit.
+const WORKHUB_TARGET_LINKAGE_MAX_SESSIONS = 256;
 function decodeStoredMessage(value) {
     return decodePersistedStoredMessage(markPersisted(value));
 }
@@ -1474,6 +1477,108 @@ export class SqliteSessionMetadataStore {
             return rows.map((row) => decodeMessageAdmissionRow(sessionId, row));
         });
     }
+    async readActiveWorkHubAssignmentsByTarget(targetSessionIds, maxAssignmentsPerTarget) {
+        this.assertOpen();
+        for (const sessionId of targetSessionIds)
+            assertSafeSessionId(sessionId);
+        if (targetSessionIds.length > WORKHUB_TARGET_LINKAGE_MAX_SESSIONS) {
+            throw new Error('Invalid WorkHub target Session count');
+        }
+        if (maxAssignmentsPerTarget !== undefined &&
+            (!Number.isSafeInteger(maxAssignmentsPerTarget) ||
+                maxAssignmentsPerTarget < 1 ||
+                maxAssignmentsPerTarget > 256)) {
+            throw new Error('Invalid WorkHub target Message limit');
+        }
+        const targets = [...new Set(targetSessionIds)];
+        if (targets.length === 0)
+            return [];
+        return this.readTransaction(() => {
+            const list = targets.map(() => '?').join(', ');
+            // One Message moves between these lifecycle tables. Combine every target's
+            // identities once, then resolve activity from the canonical Coordination
+            // ledger in this same read transaction. That avoids rebuilding the target
+            // set once per page or once per candidate, without introducing another
+            // durable representation.
+            const rows = this.db
+                .prepare(`
+          WITH target_messages(session_id, message_id) AS (
+            SELECT session_id, message_id
+            FROM message_admissions
+            WHERE session_id IN (${list})
+              AND message_id GLOB 'whm_*'
+              AND length(message_id) = 52
+            UNION
+            SELECT session_id, message_id
+            FROM session_messages
+            WHERE session_id IN (${list})
+              AND message_id GLOB 'whm_*'
+              AND length(message_id) = 52
+            UNION
+            SELECT session_id, message_id
+            FROM cancelled_message_admissions
+            WHERE session_id IN (${list})
+              AND message_id GLOB 'whm_*'
+              AND length(message_id) = 52
+          )
+          SELECT target.session_id, target.message_id
+          FROM target_messages AS target
+          CROSS JOIN session_messages AS assignment INDEXED BY session_messages_by_identity
+          WHERE assignment.session_id = ?
+            AND assignment.message_id = 'wha_' || substr(target.message_id, 5)
+          ORDER BY assignment.sequence DESC
+        `)
+                .iterate(...targets, ...targets, ...targets, WORKHUB_COORDINATION_SESSION_ID);
+            const assignments = [];
+            const acceptedPerTarget = new Map();
+            for (const row of rows) {
+                if (typeof row.message_id !== 'string' || typeof row.session_id !== 'string') {
+                    throw new SessionMetadataConflictError('Invalid WorkHub target Message identity');
+                }
+                const targetSessionId = row.session_id;
+                if (maxAssignmentsPerTarget !== undefined &&
+                    (acceptedPerTarget.get(targetSessionId) ?? 0) >= maxAssignmentsPerTarget) {
+                    continue;
+                }
+                const assignment = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `wha_${row.message_id.slice('whm_'.length)}`);
+                if (assignment?.type !== 'workhub_coordination' ||
+                    assignment.kind !== 'delegation_assigned' ||
+                    assignment.targetSessionId !== targetSessionId ||
+                    assignment.targetMessageId !== row.message_id) {
+                    continue;
+                }
+                const terminalSuffix = createHash('sha256')
+                    .update(assignment.delegationId, 'utf8')
+                    .digest('hex')
+                    .slice(0, 48);
+                const supersession = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whx_${terminalSuffix}`);
+                if (supersession?.type === 'workhub_coordination' &&
+                    supersession.kind === 'delegation_superseded') {
+                    continue;
+                }
+                const replacementAbort = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whb_${terminalSuffix}`);
+                if (replacementAbort?.type === 'workhub_coordination' &&
+                    replacementAbort.kind === 'delegation_replacement_aborted') {
+                    continue;
+                }
+                const stopResolution = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whz_${terminalSuffix}`);
+                if (stopResolution?.type === 'workhub_coordination' &&
+                    stopResolution.kind === 'delegation_stop_resolved' &&
+                    stopResolution.outcome !== 'not_owned') {
+                    continue;
+                }
+                assignments.push(assignment);
+                acceptedPerTarget.set(targetSessionId, (acceptedPerTarget.get(targetSessionId) ?? 0) + 1);
+            }
+            return assignments;
+        });
+    }
+    async readMessageById(sessionId, messageId) {
+        this.assertOpen();
+        assertSafeSessionId(sessionId);
+        assertSafeSessionId(messageId);
+        return this.readTransaction(() => this.readMessageByIdSync(sessionId, messageId));
+    }
     async markMessagesHandedOff(input) {
         this.assertOpen();
         assertSafeSessionId(input.sessionId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maka-agent",
-  "version": "0.2.0-dev.21.20260905",
+  "version": "0.2.0-dev.22.20260905",
   "description": "Apache Maka (Incubating) developer snapshot; not an Apache release.",
   "license": "Apache-2.0",
   "type": "module",