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

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

@@ -18,7 +18,7 @@
  */
 import { RuntimeHostProtocolError } from '../protocol/errors.js';
 import { createHash } from 'node:crypto';
-import { authorizeConnectionModel } from '@maka/core/llm-connections';
+import { authorizeConnectionModel, connectionEnabledModelIds } from '@maka/core/llm-connections';
 import { isModelExplicitlyUnsupportedForChat } from '@maka/core/model-catalog';
 import { thinkingVariantsForConnection } from '@maka/core/model-thinking';
 import { executionBoundaryDisplayMode, } from '@maka/core/sandbox-boundary';
@@ -37,6 +37,84 @@ export class SessionOperationFailure extends Error {
         this.name = 'SessionOperationFailure';
     }
 }
+/**
+ * The import path found no ready connection+model to attach the task to. A
+ * distinct type (not just a message) so `#importSession` can map it to the
+ * stable `model_unavailable` wire code without inspecting the message — the
+ * generic `operation_unavailable` code it carries is also used for an
+ * unavailable source, which is a different failure.
+ */
+export class NoUsableImportModelError extends SessionOperationFailure {
+    constructor(message) {
+        super('operation_unavailable', message);
+        this.name = 'NoUsableImportModelError';
+    }
+}
+/**
+ * Connection+model candidates for an imported task, most-preferred first: the
+ * configured default (kept at its exact precedence), then one ready model per
+ * enabled connection in catalog order. Model-level readiness that is a pure
+ * catalog fact — enabled, not quarantined, chat-capable — is applied here so an
+ * unusable connection costs one `#resolveModel` attempt, not one per enabled
+ * model (a connection may enable hundreds). Connection-level readiness
+ * (credential, retired provider, identity) stays in `#resolveModel`, which
+ * remains the sole arbiter of those.
+ */
+function importModelCandidates(snapshot) {
+    const byId = new Map(snapshot.connections.map((connection) => [connection.connectionId, connection]));
+    const candidates = [];
+    const seen = new Set();
+    const push = (connection, modelId, isDefault) => {
+        const key = `${connection.connectionId} ${modelId}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        candidates.push({
+            connectionId: connection.connectionId,
+            connectionSlug: connection.slug,
+            modelId,
+            isDefault,
+        });
+    };
+    // The connection's first enabled model that is a valid chat target, by pure
+    // catalog facts alone (no credential or provider-liveness read). Emitting only
+    // this one — rather than every enabled model — bounds the enumeration to one
+    // candidate per connection, so a connection-level failure (missing credential,
+    // retired provider) costs a single `#resolveModel` round trip.
+    const firstReadyModel = (connection) => {
+        for (const modelId of connectionEnabledModelIds(connection)) {
+            // Mirror `#resolveModel`'s pure-catalog gates, the wire byte cap included:
+            // a model id can be within the catalog's code-unit limit yet exceed the
+            // byte cap (e.g. emoji), and taking it as the connection's sole candidate
+            // would let `#resolveModel` reject it and mask the connection's shorter,
+            // usable models. Skip it here so the next enabled model is considered.
+            if (Buffer.byteLength(modelId, 'utf8') > SESSION_CATALOG_MODEL_MAX_BYTES)
+                continue;
+            const model = authorizeConnectionModel(connection, modelId);
+            if (model && !isModelExplicitlyUnsupportedForChat(model))
+                return modelId;
+        }
+        return undefined;
+    };
+    // Default first, so a configured-and-ready default keeps today's behavior.
+    // `retainedDefaultTarget` + `isValidTarget` guarantee a persisted default is
+    // enabled and present in `enabledModelIds`, so its exact model is taken at its
+    // precedence rather than re-picked from the connection.
+    const preferred = snapshot.defaultTarget;
+    if (preferred) {
+        const connection = byId.get(preferred.connectionId);
+        if (connection?.enabled)
+            push(connection, preferred.modelId, true);
+    }
+    for (const connection of snapshot.connections) {
+        if (!connection.enabled)
+            continue;
+        const modelId = firstReadyModel(connection);
+        if (modelId !== undefined)
+            push(connection, modelId, false);
+    }
+    return candidates;
+}
 /** Host-owned Session catalog, creation, and configuration authority. */
 export class HostSessionCatalogCoordinator {
     handlers = {
@@ -69,11 +147,29 @@ export class HostSessionCatalogCoordinator {
         this.#requestDrain = options.requestDrain;
         this.#sessionAccessAuthority = options.sessionAccessAuthority;
     }
+    /**
+     * Target for a task imported from another agent's conversation. Import is an
+     * explicit, one-off user action on a specific conversation, so it prefers the
+     * configured default but falls back to any ready connection+model — see
+     * `#resolveImportModel`.
+     */
     async resolveExternalSessionImportTarget() {
-        const [model, policy] = await Promise.all([
-            this.#resolveModel({ kind: 'default' }, undefined),
-            this.#readRuntimePolicy(),
-        ]);
+        return this.#composeCreateTarget(this.#resolveImportModel());
+    }
+    /**
+     * Target for the autonomous WorkHub coordination create path (its
+     * `resolveCreateTarget`). Unlike import there is no user in the loop to pick a
+     * model, so this fails closed when no default is configured rather than binding
+     * a connection the user never chose. Import's fallback deliberately does not
+     * reach here; keeping the two resolvers apart is what confines the guess to an
+     * explicit user
+     * action.
+     */
+    async resolveDefaultCreateTarget() {
+        return this.#composeCreateTarget(this.#resolveModel({ kind: 'default' }, undefined));
+    }
+    async #composeCreateTarget(modelResolution) {
+        const [model, policy] = await Promise.all([modelResolution, this.#readRuntimePolicy()]);
         return {
             llmConnectionId: model.connectionId,
             llmConnectionSlug: model.connectionSlug,
@@ -511,6 +607,56 @@ export class HostSessionCatalogCoordinator {
             throw error;
         }
     }
+    /**
+     * Model for an imported task. Prefers the configured default but falls back to
+     * any ready connection+model, because a default is only auto-set during
+     * onboarding bootstrap (`setDefaultIfMissing`) and a self-configured profile
+     * legitimately has `defaultTarget: null` while holding perfectly usable
+     * connections. Without the fallback, every import fails before the source is
+     * even read. Unlike interactive session creation, import has no model picker,
+     * so this is the only place that can choose one.
+     */
+    async #resolveImportModel() {
+        let snapshot;
+        try {
+            snapshot = await this.#runtimePolicy.connectionCatalog.getSnapshot();
+        }
+        catch {
+            throw new SessionOperationFailure('persistence_failed', 'Connection catalog is unavailable');
+        }
+        for (const candidate of importModelCandidates(snapshot)) {
+            try {
+                return await this.#resolveModel({
+                    kind: 'explicit',
+                    connectionId: candidate.connectionId,
+                    connectionSlug: candidate.connectionSlug,
+                    model: candidate.modelId,
+                }, undefined);
+            }
+            catch (error) {
+                if (!(error instanceof SessionOperationFailure))
+                    throw error;
+                // The configured default is never substituted away from: if it is set
+                // but unusable (e.g. its credential was revoked), surface its failure
+                // exactly as an explicit default target does today, rather than silently
+                // attaching the task to a connection the user did not choose. The
+                // fallback below runs only when no default is set — the null-default
+                // state this fix is for, where there is nothing to substitute for.
+                if (candidate.isDefault)
+                    throw error;
+                // Otherwise, only a genuinely unusable candidate is skippable:
+                // `invalid_request` (disabled / retired / not-enabled / non-chat) and
+                // `operation_unavailable` (no credential). Any other code — notably
+                // `operation_conflict`, thrown when the connection was deleted or
+                // renamed after the snapshot — is a real fault the caller must see, not
+                // a reason to silently fall through to a lower-priority connection.
+                if (error.code !== 'invalid_request' && error.code !== 'operation_unavailable') {
+                    throw error;
+                }
+            }
+        }
+        throw new NoUsableImportModelError('No usable Session model connection is available for import');
+    }
     async #resolveModel(target, thinkingLevel) {
         const selected = await this.#selectModelTarget(target);
         const readiness = await this.#runtimePolicy.operations.resolveExecutionConnection({

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

@@ -23,7 +23,7 @@ import { BUILTIN_PRICING } from '@maka/runtime/telemetry';
 import { authenticateInteractiveUsageStoresWriter, classifyInteractiveUsageStoresFailure, } from '@maka/storage/usage-stores';
 import { isSessionNotFoundError } from '@maka/storage/execution-stores';
 import { encodePricingQueryResult, encodeUsageQueryResult, PRICING_PAGE_MAX_BYTES, PRICING_PAGE_MAX_ITEMS, USAGE_PAGE_MAX_BYTES, USAGE_PAGE_MAX_ITEMS, USAGE_PROJECTION_TEXT_MAX_BYTES, } from '../protocol/index.js';
-import { readCanonicalUsage } from './canonical-usage-reader.js';
+import { readCanonicalUsageBuckets, readCanonicalUsageLogs, readCanonicalUsageSummary, } from './canonical-usage-reader.js';
 /** Root-scoped projection over the authentic lease-bound usage stores. */
 export class HostUsagePricingCoordinator {
     handlers = {
@@ -75,18 +75,11 @@ export class HostUsagePricingCoordinator {
         }));
         return titles;
     }
-    /**
-     * Reads the canonical ledger for the window a query addresses (#1679). The
-     * range is resolved once here so both sources answer the same window.
-     */
-    async #canonicalUsage(query, now, repair = true) {
-        return readCanonicalUsage(this.#stores, query, now, repair);
-    }
     async #queryUsage(input) {
         try {
             const now = Date.now();
             if (input.kind === 'summary') {
-                const merged = mergeUsageSummary(await this.#stores.telemetry.summary(input.query), await this.#canonicalUsage(input.query, now), input.query, now);
+                const merged = mergeUsageSummary(await this.#stores.telemetry.summary(input.query), await readCanonicalUsageSummary(this.#stores, input.query, now));
                 // Tool executions are in their own ledger, not the model-call one, so
                 // their totals ride beside the merged summary rather than inside it —
                 // the same owner split the tool buckets path already follows. A
@@ -117,7 +110,7 @@ export class HostUsagePricingCoordinator {
                     ? { buckets: [...legacy], provenance: EMPTY_PROVENANCE }
                     : mergeUsageBuckets(legacy, 
                     // Only the first page repairs; later pages reuse it.
-                    await this.#canonicalUsage(input.query, now, offset === 0), input.query, input.groupBy, now);
+                    await readCanonicalUsageBuckets(this.#stores, input.query, input.groupBy, now, offset === 0));
                 if (offset > merged.buckets.length)
                     return invalidUsageOffset();
                 return {
@@ -142,7 +135,7 @@ export class HostUsagePricingCoordinator {
             const legacy = await this.#stores.telemetry.logs(input.query, 0, offset + limit);
             const merged = mergeUsageLogs(legacy, 
             // Only the first page repairs; later pages reuse it.
-            await this.#canonicalUsage(input.query, now, offset === 0), input.query, now, offset, limit);
+            await readCanonicalUsageLogs(this.#stores, input.query, now, offset + limit, offset === 0), offset, limit);
             if (offset > merged.total)
                 return invalidUsageOffset();
             const titles = await this.#resolveSessionTitles(merged.rows);

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

@@ -18,7 +18,7 @@
  */
 import { createHash } from 'node:crypto';
 import { WORKHUB_COORDINATION_SESSION_ID, isWorkHubCoordinationSessionTarget, } from '@maka/core/session';
-import { readWorkHubRequestIntent, workHubCorrectionTargetsSession, workHubCreationAuthorizesTitle, } from '@maka/core/workhub-creation-intent';
+import { readWorkHubRequestIntent, workHubCorrectionTargetsSession, workHubCreationAuthorizesTitle, workHubNamedDelegationActionTargetsSession, } from '@maka/core/workhub-creation-intent';
 import { WORKHUB_COORDINATION_CANDIDATE_MAX_ITEMS } from '../protocol/index.js';
 const SIDE_CONVERSATION_LABEL = 'mode:side_conversation';
 const ACTION_REPLAY_MAX_ITEMS = 256;
@@ -74,9 +74,9 @@ export class WorkHubCoordinationActionGate {
         const action = { requestFingerprint, result };
         this.#actions.set(input.actionId, action);
         // Successful actions remain a Host-lifetime fast path. Rejections release
-        // the slot so a pre-assignment admission can retry; the durable action
-        // claim, not this map, is what owns the identity across that retry and
-        // across restarts.
+        // the slot so admission can retry. Durable identity belongs to the
+        // owning operation: action claims for coordination writes, Host Turn
+        // admission for resume.
         void result.catch(() => {
             if (this.#actions.get(input.actionId) === action) {
                 this.#actions.delete(input.actionId);
@@ -177,6 +177,26 @@ export class WorkHubCoordinationActionGate {
             });
             return this.#stop(requested, source);
         }
+        if (proposal.disposition === 'resume_work') {
+            if (!requestIntent.resume.imperative) {
+                throw new WorkHubActionGateFailure('action_conflict', 'WorkHub resume requires an explicit named command in trusted user text');
+            }
+            const candidates = await this.candidates();
+            const target = candidates.candidates.find((candidate) => candidate.sessionId === proposal.expects.targetSessionId);
+            if (!target)
+                throw new WorkHubActionGateFailure('candidate_unavailable', 'WorkHub resume target is unavailable');
+            this.#assertTarget(target);
+            const source = await this.#soleWorkingDelegation(target.sessionId, 'resume');
+            if (source.actionId !== proposal.resumesActionId) {
+                throw new WorkHubActionGateFailure('action_conflict', 'WorkHub resume target delegation changed');
+            }
+            const currentTargetName = target.sessionName;
+            if (!currentTargetName ||
+                !workHubNamedDelegationActionTargetsSession(requestIntent.resume, currentTargetName)) {
+                throw new WorkHubActionGateFailure('action_conflict', 'WorkHub resume target is not affirmed in trusted user text');
+            }
+            return this.#effects.resume({ actionId: input.actionId, source }, context);
+        }
         if (proposal.disposition === 'create_new') {
             if (!input.create || !workHubCreationAuthorizesTitle(requestIntent, proposal.title)) {
                 throw new WorkHubActionGateFailure('action_conflict', 'WorkHub creation requires an unambiguous instruction and creation context');
@@ -259,9 +279,22 @@ export class WorkHubCoordinationActionGate {
                 return claimed;
             }
         }
+        const resolved = await this.#soleWorkingDelegation(targetSessionId, 'stop');
+        // A claim with no request behind it resolves from the active links like a
+        // first attempt, but only while those links still name the delegation it
+        // bound itself to. If that one left and another took its place, the
+        // fingerprint derived here would no longer match the claim, and since
+        // claims are never deleted the refusal would be permanent and unexplained.
+        // Say why instead: the identity is spent, and the retry needs a new one.
+        if (claim?.operation === 'stop' && resolved.delegationId !== claim.subject) {
+            throw new WorkHubActionGateFailure('action_conflict', 'WorkHub stop identity is already bound to a different delegation');
+        }
+        return resolved;
+    }
+    async #soleWorkingDelegation(targetSessionId, operation) {
         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');
+            throw new WorkHubActionGateFailure('action_conflict', `WorkHub has no active durable delegation to ${operation} on that Session`);
         }
         // One link is the answer whatever state its work is in. Whether that work
         // finished, or was never WorkHub's to stop, is what the stop resolves to —
@@ -281,19 +314,10 @@ export class WorkHubCoordinationActionGate {
                 }
             }
             if (holdingWork.length !== 1) {
-                throw new WorkHubActionGateFailure('action_conflict', 'WorkHub stop target does not identify one active durable delegation');
+                throw new WorkHubActionGateFailure('action_conflict', `WorkHub ${operation} target does not identify one active durable delegation`);
             }
             resolved = holdingWork[0];
         }
-        // A claim with no request behind it resolves from the active links like a
-        // first attempt, but only while those links still name the delegation it
-        // bound itself to. If that one left and another took its place, the
-        // fingerprint derived here would no longer match the claim, and since
-        // claims are never deleted the refusal would be permanent and unexplained.
-        // Say why instead: the identity is spent, and the retry needs a new one.
-        if (claim?.operation === 'stop' && resolved.delegationId !== claim.subject) {
-            throw new WorkHubActionGateFailure('action_conflict', 'WorkHub stop identity is already bound to a different delegation');
-        }
         return resolved;
     }
     async #stop(request, source) {
@@ -608,6 +632,11 @@ function delegationAssignment(input, actionFingerprint, targetSessionId, targetS
 function workHubCreatedSessionId(actionId) {
     return `whs_${hash(`create\0${actionId}`).slice(0, 48)}`;
 }
+// One request cannot resume a later interruption after a lost response and restart.
+// Host admission rejects reuse of this Turn id for a different source boundary.
+export function workHubResumedTurnId(actionId) {
+    return `wht_${hash(`resume\0${actionId}`).slice(0, 48)}`;
+}
 function workspaceProjection(session) {
     return {
         target: typeof session.projectId === 'string'

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

@@ -110,6 +110,11 @@ export class HostWorkHubCoordinationCoordinator {
             resolveStop: (input) => this.#resolveStop(input),
             readDelegationRetirement: options.sessionActions.readDelegationRetirement,
             retireDelegation: options.sessionActions.retireDelegation,
+            resume: async (input, context) => ({
+                disposition: 'resume_work',
+                targetSessionId: input.source.targetSessionId,
+                ...(await options.sessionActions.resumeDelegation(input.source, context, input.actionId)),
+            }),
         });
     }
     #prepareReplacement(input) {
@@ -342,7 +347,7 @@ export class HostWorkHubCoordinationCoordinator {
                 return {
                     ok: false,
                     error: {
-                        code: error.code === 'unauthorized' ? 'operation_unavailable' : error.code,
+                        code: error.code,
                         message: error.message,
                     },
                 };

package/node_modules/@maka/storage/dist/agent-run-store.js

@@ -258,6 +258,26 @@ class SqliteAgentRunStore {
             if (readSqliteRootTurnStartRejection(this.#lease.database, admission.sessionId, admission.turnId)) {
                 throw new Error('Root Turn identity is already rejected');
             }
+            if (admission.execution.kind === 'safe_boundary_continuation') {
+                const sourceOwner = this.#lease.database
+                    .prepare(`
+            SELECT turn_id
+            FROM core_root_turn_admissions
+            WHERE session_id = ?
+              AND json_extract(record_json, '$.execution.sourceTurnId') = ?
+              AND json_extract(record_json, '$.execution.sourceRunId') = ?
+              AND json_extract(record_json, '$.execution.kind') = 'safe_boundary_continuation'
+            ORDER BY admitted_at, turn_id
+            LIMIT 1
+          `)
+                    .get(admission.sessionId, admission.execution.sourceTurnId, admission.execution.sourceRunId);
+                if (typeof sourceOwner?.turn_id === 'string') {
+                    const owner = readSqliteRootTurnAdmission(this.#lease.database, admission.sessionId, sourceOwner.turn_id);
+                    if (!owner)
+                        throw new Error('Root continuation index has no durable admission');
+                    return { kind: 'conflict', admission: owner };
+                }
+            }
             for (const source of admission.sourceMessages) {
                 const proof = this.#lease.database
                     .prepare(`
@@ -293,6 +313,30 @@ class SqliteAgentRunStore {
         assertSafeId(turnId, 'Invalid turn id');
         return readSqliteRootTurnAdmission(this.#lease.database, sessionId, turnId);
     }
+    async readRootTurnContinuationAdmission(sessionId, sourceTurnId, sourceRunId) {
+        assertSafeId(sessionId, 'Invalid session id');
+        assertSafeId(sourceTurnId, 'Invalid source turn id');
+        assertSafeId(sourceRunId, 'Invalid source run id');
+        const row = this.#lease.database
+            .prepare(`
+        SELECT turn_id, record_json
+        FROM core_root_turn_admissions
+        WHERE session_id = ?
+          AND json_extract(record_json, '$.execution.sourceTurnId') = ?
+          AND json_extract(record_json, '$.execution.sourceRunId') = ?
+          AND json_extract(record_json, '$.execution.kind') = 'safe_boundary_continuation'
+        ORDER BY admitted_at, turn_id
+        LIMIT 1
+      `)
+            .get(sessionId, sourceTurnId, sourceRunId);
+        if (!row)
+            return undefined;
+        if (typeof row.turn_id !== 'string' || typeof row.record_json !== 'string') {
+            throw new Error('Invalid SQLite root turn continuation admission row');
+        }
+        const admission = normalizeRootTurnAdmission(JSON.parse(row.record_json), sessionId, row.turn_id);
+        return admission;
+    }
     async readRootTurnStartRejection(sessionId, turnId) {
         assertSafeId(sessionId, 'Invalid session id');
         assertSafeId(turnId, 'Invalid turn id');

package/node_modules/@maka/storage/dist/conversation-operational-state.js

@@ -67,6 +67,10 @@ class SqliteConversationOperationalStateStore {
             database
                 .prepare('DELETE FROM core_root_turn_start_rejections WHERE session_id = ?')
                 .run(sessionId);
+            // Cascades this run's events and the Usage projection's checkpoints.
+            // `usage_model_call_attempts` is deliberately absent from this list:
+            // deleting a conversation must not erase its spend from all-time Usage
+            // totals, so those rows outlive the authority they were projected from.
             database.prepare('DELETE FROM core_agent_runs WHERE session_id = ?').run(sessionId);
             database
                 .prepare('DELETE FROM core_client_capability_session_grants WHERE session_id = ?')

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

@@ -210,6 +210,7 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             repairEventProjection: (sessionId, type, event, options) => run(() => agentRunStore.repairEventProjection(sessionId, type, event, options)),
             admitRootTurn: (input) => run(() => agentRunStore.admitRootTurn(input)),
             readRootTurnAdmission: (sessionId, turnId) => run(() => agentRunStore.readRootTurnAdmission(sessionId, turnId)),
+            readRootTurnContinuationAdmission: (sessionId, sourceTurnId, sourceRunId) => run(() => agentRunStore.readRootTurnContinuationAdmission(sessionId, sourceTurnId, sourceRunId)),
             readRootTurnStartRejection: (sessionId, turnId) => run(() => agentRunStore.readRootTurnStartRejection(sessionId, turnId)),
             commitRootTurnStartRejection: (input) => run(() => agentRunStore.commitRootTurnStartRejection(input)),
             readRootTurnSourceMessageReceipt: (sessionId, sourceMessageId) => run(() => agentRunStore.readRootTurnSourceMessageReceipt(sessionId, sourceMessageId)),
@@ -302,6 +303,7 @@ async function openExecutionStoresForRead(lease, kind, extension) {
             readEventsByTypeBounded: (sessionId, runId, type, budget) => run(() => agentRunStore.readEventsByTypeBounded(sessionId, runId, type, budget)),
             readEventProjection: (sessionId, type) => run(() => agentRunStore.readEventProjection(sessionId, type)),
             readRootTurnAdmission: (sessionId, turnId) => run(() => agentRunStore.readRootTurnAdmission(sessionId, turnId)),
+            readRootTurnContinuationAdmission: (sessionId, sourceTurnId, sourceRunId) => run(() => agentRunStore.readRootTurnContinuationAdmission(sessionId, sourceTurnId, sourceRunId)),
             readRootTurnSourceMessageReceipt: (sessionId, sourceMessageId) => run(() => agentRunStore.readRootTurnSourceMessageReceipt(sessionId, sourceMessageId)),
         },
         runtimeEventStore: {