maka-agent 0.2.0-dev.43.20260919 → 0.2.0-dev.45.20260921

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

@@ -107,35 +107,53 @@ export class HostMessageCoordinator {
         }
         return success({ cancelledMessageIds });
     }
-    async queryMessageExecutions(input) {
-        const resolutions = [];
-        for (const messageId of input.messageIds) {
-            const disposition = await this.#resolveMessageExecution(input.sessionId, messageId);
-            if (disposition.kind === 'owned_root' || disposition.kind === 'shared_turn') {
-                // This read projects current execution, including safe-boundary
-                // continuations. The Message's durable admission ownership is unchanged.
-                const latest = await this.#root.readLatestRootTurnLineage({
-                    sessionId: input.sessionId,
-                    turnId: disposition.turnId,
-                    runId: disposition.runId,
-                });
-                resolutions.push({
-                    messageId,
-                    state: 'owned',
-                    turnId: latest.turnId,
-                    runId: latest.runId,
-                });
-                continue;
-            }
-            if (disposition.kind === 'cancelled') {
-                resolutions.push({ messageId, state: 'cancelled' });
-                continue;
-            }
-            if (disposition.kind === 'pending') {
-                resolutions.push({ messageId, state: 'pending' });
+    queryMessageExecutions(input) {
+        // Enter the Session admission the way every other admission reader does.
+        // `not_admitted` claims that no epoch ever admitted this identity, and it
+        // is only sound while no admission write can be in flight. WorkHub writes
+        // admission rows without an in-memory submit to observe, so the gate —
+        // not `#pendingSubmits` alone — is what makes the read atomic.
+        return this.#sessionAdmission.runOrJoin(input.sessionId, async () => {
+            const resolutions = [];
+            for (const messageId of input.messageIds) {
+                const disposition = await this.#resolveMessageExecution(input.sessionId, messageId);
+                if (disposition.kind === 'owned_root' || disposition.kind === 'shared_turn') {
+                    // This read projects current execution, including safe-boundary
+                    // continuations. The Message's durable admission ownership is unchanged.
+                    const latest = await this.#root.readLatestRootTurnLineage({
+                        sessionId: input.sessionId,
+                        turnId: disposition.turnId,
+                        runId: disposition.runId,
+                    });
+                    resolutions.push({
+                        messageId,
+                        state: 'owned',
+                        turnId: latest.turnId,
+                        runId: latest.runId,
+                    });
+                    continue;
+                }
+                if (disposition.kind === 'cancelled') {
+                    resolutions.push({ messageId, state: 'cancelled' });
+                    continue;
+                }
+                if (disposition.kind === 'pending') {
+                    resolutions.push({ messageId, state: 'pending' });
+                    continue;
+                }
+                // `recovering` means no durable receipt, steering proof, cancellation
+                // tombstone, or pending admission names this identity. Under the
+                // Session gate no admission write is in flight, so that silence is
+                // itself the proof: nothing in this epoch — or any prior one, since a
+                // stale epoch's submit can never commit here — ever admitted it.
+                // Report that fact positively instead of omitting the identity, so a
+                // missing entry stops meaning both "not admitted" and "cannot say yet".
+                if (this.#pendingSubmits.has(operationKey(input.sessionId, messageId)))
+                    continue;
+                resolutions.push({ messageId, state: 'not_admitted' });
             }
-        }
-        return success({ resolutions });
+            return success({ resolutions });
+        });
     }
     /**
      * Cancels exactly one durable pending Message, or returns the Turn that has

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

@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { runRecall } from '@maka/core/recall';
+/**
+ * Serves `recall.query` from the same dependency graph the model's `Recall`
+ * tool uses.
+ *
+ * The point of this coordinator is that it owns no retrieval logic: it hands
+ * the request to `runRecall` and projects the answer. Whatever recall can see —
+ * privacy gating, archived Sessions, the distilled-fact store — a Client
+ * asking over the wire sees the same thing, because there is one implementation
+ * and this is not a second one.
+ *
+ * Unlike the model's tool, no turn is excluded. A tool call runs inside a turn
+ * and must not surface that turn's own text back as corroboration; a Client
+ * search is not inside any turn, so there is nothing to exclude.
+ */
+export class HostRecallCoordinator {
+    deps;
+    handlers = {
+        'recall.query': (input) => this.#query(input),
+    };
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async #query(input) {
+        try {
+            const result = await runRecall(input, this.deps, { includeArchived: true });
+            return { ok: true, result: projectRecallResult(result) };
+        }
+        catch {
+            return {
+                ok: false,
+                error: { code: 'internal_failure', message: 'Recall query failed' },
+            };
+        }
+    }
+}
+/**
+ * `RecallQueryResult` is the core result with the Host's field vocabulary.
+ *
+ * Recall already returns exactly these fields; the projection exists to drop
+ * core-internal detail and to make the boundary explicit, so a change to the
+ * core shape shows up here rather than silently widening the wire.
+ */
+export function projectRecallResult(result) {
+    if (!result.ok) {
+        return { ok: false, reason: result.reason, message: result.message };
+    }
+    return {
+        ok: true,
+        facts: result.facts.map((fact) => ({
+            content: fact.content,
+            kind: fact.kind,
+            observedAt: fact.observedAt,
+        })),
+        passages: result.passages.map((passage) => projectPassage(passage)),
+        gaps: result.gaps,
+        searchedEverySession: result.scannedFully,
+    };
+}
+function projectPassage(passage) {
+    return {
+        sessionId: passage.sessionId,
+        sessionTitle: passage.sessionTitle,
+        ...(passage.turnId ? { turnId: passage.turnId } : {}),
+        anchorMessageId: passage.anchorMessageId,
+        sequence: passage.sequence,
+        messages: passage.messages.map((message) => ({
+            messageId: message.messageId,
+            role: message.role,
+            matchKind: message.matchKind,
+            text: message.text,
+            timestamp: message.timestamp,
+            isAnchor: message.isAnchor,
+            ...(message.materials
+                ? {
+                    materials: message.materials.map((material) => ({
+                        name: material.name,
+                        kind: material.kind,
+                        mimeType: material.mimeType,
+                        bytes: material.bytes,
+                        ...(material.resource ? { resource: material.resource } : {}),
+                        ...(material.sourceSessionId && material.materialId
+                            ? {
+                                sourceSessionId: material.sourceSessionId,
+                                materialId: material.materialId,
+                            }
+                            : {}),
+                    })),
+                }
+                : {}),
+        })),
+        matchedTerms: passage.matchedTerms,
+        score: passage.score,
+        ...(passage.lastMessageAt !== undefined ? { lastMessageAt: passage.lastMessageAt } : {}),
+        hasMoreBefore: passage.hasMoreBefore,
+        hasMoreAfter: passage.hasMoreAfter,
+        ...(passage.truncated ? { truncated: true } : {}),
+    };
+}

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

@@ -27,7 +27,7 @@ import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
 import { agentGraphIdForRootSession } from '@maka/runtime/stream-graph-coordinator';
 import { RuntimeHostedRootConflictError, RuntimeHostedRootUnavailableError, RuntimeMessageAuthorityInvariantError, } from '@maka/runtime/message-authority';
 import { isShutdownCancelledInteractionAdmission, RuntimeInteractionAdmissionRejectedError, RuntimeInteractionFailStopError, RuntimeInteractionInvariantError, } from '@maka/runtime/interaction-authority';
-import { normalizeStopSessionSource, RuntimeRegenerateTurnError, } from '@maka/runtime/session-manager';
+import { normalizeStopSessionSource, } from '@maka/runtime/session-manager';
 import { RuntimeOwnerCleanupError } from '@maka/runtime/runtime-kernel';
 import { parseSkillInvocationTokens, } from '@maka/runtime/skill-invocation';
 import { skillInvocationInlineReferences } from '@maka/runtime/skill-invocation-receipt';
@@ -1422,21 +1422,10 @@ export class RootTurnCoordinator {
             return { kind: 'ready', content: request.content };
         if ('prepareFreshContent' in request)
             return request.prepareFreshContent(lease);
-        try {
-            return {
-                kind: 'ready',
-                content: normalizeMessageContent(await request.prepareContent()),
-            };
-        }
-        catch (error) {
-            if (error instanceof RuntimeRegenerateTurnError) {
-                return {
-                    kind: 'rejected',
-                    outcome: error.code === 'not_found' ? notFound(error.message) : operationConflict(error.message),
-                };
-            }
-            throw error;
-        }
+        return {
+            kind: 'ready',
+            content: normalizeMessageContent(await request.prepareContent()),
+        };
     }
     async queryTurnResume(input, context) {
         if (isWorkHubCoordinationSessionId(input.sessionId)) {

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

@@ -21,7 +21,7 @@ import { RuntimeHostProtocolError } from '../protocol/errors.js';
 import { createHash } from 'node:crypto';
 import { authorizeConnectionModel, connectionEnabledModelIds } from '@maka/core/llm-connections';
 import { isModelExplicitlyUnsupportedForChat } from '@maka/core/model-catalog';
-import { thinkingVariantsForConnection } from '@maka/core/model-thinking';
+import { defaultThinkingLevelForConnection, thinkingVariantsForConnection, } from '@maka/core/model-thinking';
 import { executionBoundaryDisplayMode, } from '@maka/core/sandbox-boundary';
 import { isExecutorId } from '@maka/core/executor-id';
 import { DEFAULT_SESSION_NAME, normalizeUserSessionName } from '@maka/core/session-name';
@@ -184,7 +184,7 @@ export class HostSessionCatalogCoordinator {
      */
     async resolveDefaultCreateTarget() {
         try {
-            return await this.#composeCreateTarget(this.#resolveModel({ kind: 'default' }, undefined));
+            return await this.#composeCreateTarget(this.#resolveModel({ kind: 'default' }, undefined, true));
         }
         catch (error) {
             if (error instanceof SessionOperationFailure &&
@@ -200,6 +200,7 @@ export class HostSessionCatalogCoordinator {
             llmConnectionId: model.connectionId,
             llmConnectionSlug: model.connectionSlug,
             model: model.model,
+            ...(model.thinkingLevel === undefined ? {} : { thinkingLevel: model.thinkingLevel }),
             permissionMode: policy.policy.chatDefaults.permissionMode,
             toolMode: policy.policy.chatDefaults.codeModeEnabled ? 'code_mode' : 'direct',
             collaborationMode: 'agent',
@@ -235,7 +236,7 @@ export class HostSessionCatalogCoordinator {
                     ...(model.connectionId ? { llmConnectionId: model.connectionId } : {}),
                     llmConnectionSlug: model.connectionSlug,
                     model: model.model,
-                    ...(input.thinkingLevel === undefined ? {} : { thinkingLevel: input.thinkingLevel }),
+                    ...(model.thinkingLevel === undefined ? {} : { thinkingLevel: model.thinkingLevel }),
                     ...(input.toolProfile === undefined ? {} : { toolProfile: input.toolProfile }),
                     permissionMode: prepared.permissionMode ?? policy.policy.chatDefaults.permissionMode,
                     toolMode: policy.policy.chatDefaults.codeModeEnabled ? 'code_mode' : 'direct',
@@ -405,7 +406,7 @@ export class HostSessionCatalogCoordinator {
                         ...(model.connectionId ? { llmConnectionId: model.connectionId } : {}),
                         llmConnectionSlug: model.connectionSlug,
                         model: model.model,
-                        ...(input.thinkingLevel === undefined ? {} : { thinkingLevel: input.thinkingLevel }),
+                        ...(model.thinkingLevel === undefined ? {} : { thinkingLevel: model.thinkingLevel }),
                         ...(input.toolProfile === undefined ? {} : { toolProfile: input.toolProfile }),
                         permissionMode: prepared.permissionMode ?? policy.policy.chatDefaults.permissionMode,
                         toolMode: toolMode ?? (policy.policy.chatDefaults.codeModeEnabled ? 'code_mode' : 'direct'),
@@ -715,7 +716,7 @@ export class HostSessionCatalogCoordinator {
                     connectionId: candidate.connectionId,
                     connectionSlug: candidate.connectionSlug,
                     model: candidate.modelId,
-                }, undefined);
+                }, undefined, true);
             }
             catch (error) {
                 if (!(error instanceof SessionOperationFailure))
@@ -741,7 +742,7 @@ export class HostSessionCatalogCoordinator {
         }
         throw new NoUsableImportModelError('No usable Session model connection is available for import');
     }
-    async #resolveModel(target, thinkingLevel) {
+    async #resolveModel(target, thinkingLevel, applyConfiguredDefault = false) {
         const selected = await this.#selectModelTarget(target);
         const readiness = await this.#runtimePolicy.operations.resolveExecutionConnection({
             kind: 'bound',
@@ -788,17 +789,25 @@ export class HostSessionCatalogCoordinator {
         // rejected — execution-model-authority rebuilds the runtime connection
         // from the same table, so whatever passes here is exactly what the wire
         // can send.
-        if (thinkingLevel !== undefined &&
+        const resolvedThinkingLevel = thinkingLevel ??
+            (applyConfiguredDefault
+                ? defaultThinkingLevelForConnection({
+                    providerType: connection.providerType,
+                    modelOverrides: connection.modelOverrides,
+                }, selected.modelId)
+                : undefined);
+        if (resolvedThinkingLevel !== undefined &&
             !thinkingVariantsForConnection({
                 providerType: connection.providerType,
                 modelOverrides: connection.modelOverrides,
-            }, selected.modelId).includes(thinkingLevel)) {
-            throw new SessionOperationFailure('invalid_request', `Session model does not support thinking level ${thinkingLevel}`);
+            }, selected.modelId).includes(resolvedThinkingLevel)) {
+            throw new SessionOperationFailure('invalid_request', `Session model does not support thinking level ${resolvedThinkingLevel}`);
         }
         return {
             connectionId: connection.connectionId,
             connectionSlug: connection.slug,
             model: selected.modelId,
+            thinkingLevel: resolvedThinkingLevel,
         };
     }
     async #selectModelTarget(target) {
@@ -888,7 +897,7 @@ export class HostSessionCatalogCoordinator {
         if (!input.modelTarget) {
             throw new SessionOperationFailure('invalid_request', 'Session creation requires a model target or executor id');
         }
-        return await this.#resolveModel(input.modelTarget, input.thinkingLevel);
+        return await this.#resolveModel(input.modelTarget, input.thinkingLevel ?? undefined, input.thinkingLevel !== null);
     }
     async #readRuntimePolicy() {
         try {
@@ -943,7 +952,7 @@ async function prepareCreate(input) {
 }
 function createRequestFingerprint(input, prepared) {
     const identity = [
-        'session.create.v4',
+        'session.create.v5',
         input.sessionId,
         input.workspace.kind === 'project'
             ? ['project', input.workspace.projectId]
@@ -960,7 +969,7 @@ function createRequestFingerprint(input, prepared) {
                     input.modelTarget.connectionSlug,
                     input.modelTarget.model,
                 ],
-        input.thinkingLevel ?? null,
+        input.thinkingLevel === undefined ? ['model_default'] : input.thinkingLevel,
         input.toolProfile ?? null,
         prepared.permissionMode ?? ['runtime_default'],
         input.collaborationMode ?? 'agent',

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

@@ -17,7 +17,6 @@
  * under the License.
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { isDeepResearchSession } from '@maka/core/deep-research';
 import { SIDE_CONVERSATION_SESSION_LABEL } from '@maka/core/side-conversation';
 import { isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, sessionRevisionFamilyId, } from '@maka/core/session';
 import { runtimeHostConversationCopyUnavailableReason } from './host-session-availability.js';
@@ -204,9 +203,6 @@ export class HostSessionRevisionCoordinator {
         if (sourceHeader.subagentParent) {
             return copyFailure('operation_conflict', 'Linked child Sessions cannot be copied as ordinary conversations');
         }
-        if (isDeepResearchSession(sourceHeader.labels)) {
-            return copyFailure('operation_unavailable', 'Deep Research Sessions cannot be copied without an exact research ledger boundary');
-        }
         const copyUnavailableReason = runtimeHostConversationCopyUnavailableReason(sourceHeader);
         if (copyUnavailableReason)
             return copyFailure('operation_unavailable', copyUnavailableReason);

package/node_modules/@maka/runtime-host/dist/server/session-turn-access-request-coordinator.js

@@ -19,7 +19,6 @@
 export class SessionTurnAccessRequestCoordinator {
     #authority;
     #startTurn;
-    #regenerateTurn;
     #acquireResidency;
     #requestDrain;
     #whenIdle;
@@ -30,7 +29,6 @@ export class SessionTurnAccessRequestCoordinator {
     constructor(input) {
         this.#authority = input.authority;
         this.#startTurn = input.startTurn;
-        this.#regenerateTurn = input.regenerateTurn;
         this.#acquireResidency = input.acquireResidency;
         this.#requestDrain = input.requestDrain;
         this.#whenIdle = input.whenIdle;
@@ -98,21 +96,13 @@ export class SessionTurnAccessRequestCoordinator {
     async #run(request, context) {
         for (;;) {
             try {
-                if ('content' in request.intent) {
-                    const outcome = await this.#startTurn(request.intent, context);
-                    if (outcome.ok)
-                        return outcome.result.kind;
-                    if (outcome.error.code !== 'session_busy') {
-                        return this.#draining ? undefined : 'failed';
-                    }
-                }
-                else {
-                    const outcome = await this.#regenerateTurn(request.intent, context);
-                    if (outcome.ok)
-                        return 'started';
-                    if (outcome.error.code !== 'session_busy') {
-                        return this.#draining ? undefined : 'failed';
-                    }
+                if (!('content' in request.intent))
+                    return 'failed';
+                const outcome = await this.#startTurn(request.intent, context);
+                if (outcome.ok)
+                    return outcome.result.kind;
+                if (outcome.error.code !== 'session_busy') {
+                    return this.#draining ? undefined : 'failed';
                 }
             }
             catch {

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

@@ -18,7 +18,6 @@
  */
 import { isAbsolute } from 'node:path';
 import { ARTIFACT_KINDS, ARTIFACT_SOURCES, isArtifactTurnKey, isCanonicalArtifactEntityId, } from '@maka/core/artifacts';
-import { isDeepResearchArtifactRole } from '@maka/core/deep-research-run';
 const ARTIFACT_KIND_SET = new Set(ARTIFACT_KINDS);
 const ARTIFACT_SOURCE_SET = new Set(ARTIFACT_SOURCES);
 const ARTIFACT_RECORD_KEYS = new Set([
@@ -104,7 +103,6 @@ function decodeArtifactRecord(value, index) {
         value.sizeBytes < 0 ||
         !isOptionalNonEmptyString(value.mimeType) ||
         !isOptionalNonEmptyString(value.summary) ||
-        (value.deepResearchRole !== undefined && !isDeepResearchArtifactRole(value.deepResearchRole)) ||
         typeof value.source !== 'string') {
         throw invalidMetadataRecord(index);
     }
@@ -114,7 +112,10 @@ function decodeArtifactRecord(value, index) {
     if (value.relativePath !== `${value.sessionId}/${value.id}-${value.name}`) {
         throw invalidMetadataRecord(index);
     }
-    return value;
+    // Old reports carry a workflow role that no longer has a consumer.
+    const record = { ...value };
+    delete record.deepResearchRole;
+    return record;
 }
 function isCompatibleArtifactName(name) {
     if (name.length === 0 || name.length > 120)

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

@@ -22,7 +22,6 @@ import { constants as fsConstants } from 'node:fs';
 import { access, copyFile, lstat, mkdir, open, readFile, realpath, rm, stat, unlink, writeFile, } from 'node:fs/promises';
 import { basename, dirname, join, relative, sep } from 'node:path';
 import { ARTIFACT_ENTITY_ID_MAX_CHARS, ARTIFACT_KINDS, ARTIFACT_SOURCES, canUserDeleteArtifact, isArtifactTurnKey, isCanonicalArtifactEntityId, } from '@maka/core/artifacts';
-import { isDeepResearchArtifactRole, } from '@maka/core/deep-research-run';
 import { sniffAttachmentMimeType } from '@maka/core/attachments';
 import { isSafeRelativeArtifactPath, validateRelativeArtifactPath, } from './artifact-metadata-codec.js';
 import { withArtifactWriterLock, withLeaseBoundArtifactWriterLock, } from './artifact-writer-lock.js';
@@ -68,10 +67,6 @@ class SqliteArtifactStore {
         if (!ARTIFACT_SOURCE_SET.has(acceptedInput.source)) {
             throw new Error('Invalid Artifact source');
         }
-        if (acceptedInput.deepResearchRole !== undefined &&
-            !isDeepResearchArtifactRole(acceptedInput.deepResearchRole)) {
-            throw new Error('Invalid Artifact deep-research role');
-        }
         if (acceptedInput.now !== undefined &&
             (!Number.isSafeInteger(acceptedInput.now) || acceptedInput.now < 0)) {
             throw new Error('Invalid Artifact creation time');
@@ -103,9 +98,6 @@ class SqliteArtifactStore {
                 ...(acceptedInput.mimeType ? { mimeType: acceptedInput.mimeType } : {}),
                 source: acceptedInput.source,
                 ...(acceptedInput.summary ? { summary: acceptedInput.summary } : {}),
-                ...(acceptedInput.deepResearchRole
-                    ? { deepResearchRole: acceptedInput.deepResearchRole }
-                    : {}),
             }, (targetPath) => writeFile(targetPath, acceptedInput.content, { flag: 'wx' }));
         });
     }
@@ -346,7 +338,6 @@ class SqliteArtifactStore {
             existing.mimeType !== optionalCanonicalText(input.mimeType) ||
             existing.source !== input.source ||
             existing.summary !== optionalCanonicalText(input.summary) ||
-            existing.deepResearchRole !== input.deepResearchRole ||
             (input.now !== undefined && existing.createdAt !== input.now)) {
             throw artifactReplayConflict(canonical.id);
         }
@@ -798,8 +789,7 @@ function sameArtifactRecord(a, b) {
         a.sizeBytes === b.sizeBytes &&
         a.mimeType === b.mimeType &&
         a.source === b.source &&
-        a.summary === b.summary &&
-        a.deepResearchRole === b.deepResearchRole);
+        a.summary === b.summary);
 }
 function assertPageBound(value, allowZero, label) {
     if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1)) {

package/node_modules/@maka/storage/dist/process-lifetime-file-update-lock.js

@@ -22,43 +22,6 @@ import { openStableNativeLockFile, releaseNativeFileLock, tryAcquireNativeFileLo
 const LOCK_POLL_MS = 25;
 const LOCK_TIMEOUT_MS = 10_000;
 const lockGates = new Map();
-export async function withLegacyFileUpdateLockLease(targetPath, operation, timeoutMs = LOCK_TIMEOUT_MS) {
-    const lockPath = `${targetPath}.lock`;
-    const leasePath = `${targetPath}.lease`;
-    const supervisionPath = `${targetPath}.supervised`;
-    const deadline = Date.now() + timeoutMs;
-    return runWithLockGate(leasePath, deadline, async () => {
-        const lease = await openStableNativeLockFile(leasePath);
-        let leased = false;
-        let supervised = false;
-        let completed = false;
-        try {
-            while (!(leased = tryAcquireNativeFileLock(lease))) {
-                await waitForLockTurn(lockPath, deadline);
-            }
-            // The inherited advisory lease follows the legacy child process. A surviving
-            // supervision marker therefore proves that its directory lock is ownerless
-            // once a later process can acquire this lease.
-            await recoverSupervisedLegacyLock(lockPath, supervisionPath);
-            await createSupervisionMarker(supervisionPath);
-            supervised = true;
-            const result = await operation(lease.fd);
-            completed = true;
-            return result;
-        }
-        finally {
-            try {
-                if (supervised && completed)
-                    await unlink(supervisionPath).catch(ignoreMissing);
-            }
-            finally {
-                if (leased)
-                    releaseNativeFileLock(lease);
-                await lease.close();
-            }
-        }
-    });
-}
 /**
  * The callback may pass the lease fd as an extra child stdio descriptor. The
  * advisory lock then survives a parent crash until that exact child exits.
@@ -93,10 +56,6 @@ export async function withProcessLifetimeFileUpdateLock(targetPath, operation, t
         }
     });
 }
-async function createSupervisionMarker(path) {
-    const marker = await open(path, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY | fsConstants.O_NOFOLLOW, 0o600);
-    await marker.close();
-}
 async function recoverSupervisedLegacyLock(lockPath, supervisionPath) {
     const supervision = await lstat(supervisionPath).catch((error) => {
         if (isNodeError(error, 'ENOENT'))

package/node_modules/@maka/storage/dist/runtime-policy/connection-catalog-document.js

@@ -26,7 +26,6 @@ import { CONNECTION_CATALOG_MAX_CONNECTIONS, decodeCanonicalConnectionCatalogEnt
 import { PROVIDER_REGISTRY, reconcileConnectionAfterModelFetch } from '@maka/core/llm-connections';
 import { modelIdAliasesForProvider, providerReportsCompleteModelCatalog, } from '@maka/core/model-metadata';
 import { isRetiredProvider } from '@maka/core/provider-registry';
-import { pruneModelOverrides } from '@maka/core/model-thinking';
 import { deepFreeze, nextRevision, record, revision, unique } from './codec.js';
 import { codecError, decodeConnectionInput, decodePersistedDomain, RuntimePolicyStoreError, } from './errors.js';
 import { CATALOG_DOCUMENT_MAX_BYTES, readBoundedJsonDocument, serializeJsonDocument, writeJsonDocument, } from './document-io.js';
@@ -285,67 +284,6 @@ export class ConnectionCatalogDocumentOwner {
         await this.write(root, next);
         return committed(next);
     }
-    /**
-     * Built-in seed evolution as ONE atomic catalog mutation. A row whose
-     * `enabledModelIds` still exactly match a historical system seed is provably
-     * system-owned: it follows the current seed, its static inventory is
-     * re-derived from the current build, and a default target the migration
-     * removes is retargeted inside the same document write — so no restart can
-     * observe enabled ids without their inventory, or a nulled default awaiting
-     * a second write. Any other inventory (including a reordering) is a user
-     * selection and is never touched; an already-null default stays null.
-     */
-    async migrateSystemSeed(root, input) {
-        if (!input.enabledModelIds.includes(input.defaultModelId)) {
-            throw codecError('invalid_connection_input', 'Seed default must be in the seed selection');
-        }
-        const current = await this.read(root);
-        const index = current.connections.findIndex((item) => item.slug === input.slug && item.providerType === input.providerType);
-        const previous = current.connections[index];
-        const retired = new Set(input.retiredModelIds);
-        const sameIds = (left, right) => left.length === right.length && left.every((id, position) => id === right[position]);
-        const isLegacySeed = previous
-            ? input.legacyEnabledModelIds.some((seed) => sameIds(previous.enabledModelIds, seed))
-            : false;
-        const hasRetiredModels = previous
-            ? previous.enabledModelIds.some((id) => retired.has(id)) ||
-                previous.models.some((model) => retired.has(model.id))
-            : false;
-        if (!previous || (!isLegacySeed && !hasRetiredModels)) {
-            return committed(current);
-        }
-        // A legacy seed's stored inventory was the registry's shipped list copied
-        // in at write time. Clearing it is the migration: the resolver prepends
-        // that list from the current build, so the row stops carrying a stale
-        // second copy of it. Any other row keeps its own inventory, minus the
-        // retired ids.
-        const models = isLegacySeed ? [] : previous.models.filter((model) => !retired.has(model.id));
-        const { lastTest: _lastTest, modelSource: _modelSource, modelsFetchedAt: _modelsFetchedAt, ...retained } = previous;
-        const migratedEnabledModelIds = isLegacySeed
-            ? [...input.enabledModelIds]
-            : previous.enabledModelIds.filter((id) => !retired.has(id));
-        const connections = [...current.connections];
-        const modelOverrides = pruneModelOverrides(previous.modelOverrides, Object.keys(previous.modelOverrides ?? {}).filter((id) => !retired.has(id)));
-        connections[index] = {
-            ...retained,
-            revision: nextRevision(previous.revision),
-            enabledModelIds: migratedEnabledModelIds,
-            models,
-            ...(isLegacySeed || previous.modelSource === undefined
-                ? {}
-                : { modelSource: previous.modelSource, modelsFetchedAt: previous.modelsFetchedAt }),
-            ...(modelOverrides === undefined ? {} : { modelOverrides }),
-        };
-        const target = current.defaultTarget;
-        const defaultTarget = target !== null &&
-            target.connectionId === previous.connectionId &&
-            !migratedEnabledModelIds.includes(target.modelId)
-            ? { connectionId: previous.connectionId, modelId: input.defaultModelId }
-            : target;
-        const next = this.nextDocument(current, connections, defaultTarget);
-        await this.write(root, next);
-        return committed(next);
-    }
     async setDefaultTarget(root, rawInput) {
         const input = decodeConnectionInput(() => normalizeSetDefaultConnectionTargetInput(rawInput));
         const current = await this.read(root);