maka-agent 0.2.0-dev.24.20260907 → 0.2.0-dev.26.20260909

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

@@ -16,10 +16,11 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { randomUUID } from 'node:crypto';
-import { chmod, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { writeAtomicFile } from './atomic-file-write.js';
 import { withFileUpdateLock } from './file-update-lock.js';
+import { hardenDirectory } from './stable-storage.js';
 /** Current on-disk schema version. Unknown versions fail closed on read. */
 export const CREDENTIAL_SCHEMA_VERSION = 1;
 export function createFileCredentialStore(workspaceRoot) {
@@ -129,68 +130,14 @@ class FileCredentialStore {
     }
 }
 /**
- * Create (or harden) the directory that holds a secret file: 0700, and
- * re-chmod a pre-existing looser dir so neither the secret nor the lock can sit
- * world-readable. mkdir's mode only applies on creation, so the chmod is what
- * fixes an existing dir. On POSIX a chmod failure fails closed (we must not
- * write plaintext credentials into a dir we couldn't lock down); no-op on
- * Windows. Shared by the writer and the lock so their dir hardening can't drift.
- */
-async function ensureSecretDir(dir) {
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    await chmodStrict(dir, 0o700);
-}
-/**
- * Owner-only atomic write for a credentials file: a 0700 dir, an exclusive
- * 0600 temp ('wx'/O_EXCL so we never follow a pre-planted symlink at a
- * predictable path), a durability fence before and after the atomic rename,
- * and temp cleanup on failure.
+ * Owner-only atomic write for a credentials file. Directory hardening is an
+ * explicit credential-store policy; file publication uses the shared legacy
+ * JSON writer so its mode, synchronization, and cleanup behavior remains
+ * aligned with settings and MCP config.
  */
 async function writeSecretFileAtomic(path, contents) {
-    await ensureSecretDir(dirname(path));
-    const tempPath = `${path}.${randomUUID()}.tmp`;
-    try {
-        const handle = await open(tempPath, 'wx', 0o600);
-        try {
-            await handle.writeFile(contents, 'utf8');
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-        await chmodStrict(tempPath, 0o600);
-        await rename(tempPath, path);
-        await syncDirectory(dirname(path));
-    }
-    catch (error) {
-        await rm(tempPath, { force: true });
-        throw error;
-    }
-}
-async function syncDirectory(path) {
-    if (process.platform === 'win32')
-        return;
-    const handle = await open(path, 'r');
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-/**
- * chmod that fails loud on POSIX and is best-effort on Windows. A secret file
- * or its directory left looser than intended breaks the 0600/0700 boundary, so
- * on POSIX we surface the failure rather than write plaintext into it; Windows
- * has no POSIX mode, so a failure there is a no-op. One policy for both the
- * secret file (0600) and its directory (0700) so they can't drift apart.
- */
-async function chmodStrict(path, mode) {
-    if (process.platform === 'win32') {
-        await chmod(path, mode).catch(() => { });
-        return;
-    }
-    await chmod(path, mode);
+    await hardenDirectory(dirname(path));
+    await writeAtomicFile(path, contents, { fileMode: 0o600 });
 }
 const LOCK_TIMEOUT_MS = 10_000;
 /**
@@ -220,7 +167,9 @@ const LOCK_TIMEOUT_MS = 10_000;
  * stays the typed store and callers can't drive the lock directly.
  */
 export async function withCredentialFileLock(targetPath, fn, timeoutMs = LOCK_TIMEOUT_MS) {
-    await ensureSecretDir(dirname(targetPath));
+    // Same owner-only hardening the writer applies, so the lock directory can
+    // never sit looser than the secret it guards.
+    await hardenDirectory(dirname(targetPath));
     return withFileUpdateLock(targetPath, fn, timeoutMs);
 }
 const STORED_CREDENTIAL_KINDS = [

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

@@ -149,10 +149,13 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             listForRecovery: () => run(() => sessionStore.listForRecovery()),
             readHeaderSnapshot: (sessionId) => run(() => sessionStore.readHeaderSnapshot(sessionId)),
             readHeaderRecordSnapshot: (sessionId) => run(() => sessionStore.readHeaderRecordSnapshot(sessionId)),
-            readCatalogRecord: (sessionId) => run(() => sessionStore.readCatalogRecord(sessionId)),
+            readCatalogRecord: (sessionId, roleScope) => run(() => sessionStore.readCatalogRecord(sessionId, roleScope)),
             probeSessionRemoval: (sessionId) => run(() => sessionStore.probeSessionRemoval(sessionId)),
             readMessagesSnapshot: (sessionId) => run(() => sessionStore.readMessagesSnapshot(sessionId)),
             readTranscriptMessagesSnapshot: (sessionId, request) => run(() => sessionStore.readTranscriptMessagesSnapshot(sessionId, request)),
+            readCoordinationTranscriptIndexState: () => run(() => sessionStore.readCoordinationTranscriptIndexState()),
+            appendCoordinationTranscriptIndex: (records) => run(() => sessionStore.appendCoordinationTranscriptIndex(records)),
+            readCoordinationTranscriptIndex: (request) => run(() => sessionStore.readCoordinationTranscriptIndex(request)),
             readTranscriptHighWaterSnapshot: (sessionId) => run(() => sessionStore.readTranscriptHighWaterSnapshot(sessionId)),
             listTurnsSnapshot: (sessionId) => run(() => sessionStore.listTurnsSnapshot(sessionId)),
             readHeader: (sessionId) => run(() => sessionStore.readHeader(sessionId)),

package/node_modules/@maka/storage/dist/git-exec.js

@@ -0,0 +1,61 @@
+/*
+ * 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 { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = 2 * 60 * 1_000;
+const DEFAULT_TEXT_MAX_BUFFER = 1024 * 1024;
+const DEFAULT_BYTES_MAX_BUFFER = Number.MAX_SAFE_INTEGER;
+/**
+ * Runs Git with repository discovery isolated from ambient Git environment
+ * variables. Callers may provide a temporary index for patch construction.
+ */
+export async function execGitText(cwd, args, options = {}) {
+    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
+        env: gitEnvironment(options),
+        encoding: 'utf8',
+        maxBuffer: options.maxBuffer ?? DEFAULT_TEXT_MAX_BUFFER,
+        timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return stdout;
+}
+export async function execGitBytes(cwd, args, options = {}) {
+    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
+        env: gitEnvironment(options),
+        encoding: 'buffer',
+        maxBuffer: options.maxBuffer ?? DEFAULT_BYTES_MAX_BUFFER,
+        timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return new Uint8Array(stdout);
+}
+function gitEnvironment(options) {
+    const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_COMMON_DIR;
+    if (options.gitIndexFile === undefined) {
+        delete env.GIT_INDEX_FILE;
+    }
+    else {
+        env.GIT_INDEX_FILE = options.gitIndexFile;
+    }
+    return env;
+}

package/node_modules/@maka/storage/dist/git-worktree-child-executor.js

@@ -16,17 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { execFile } from 'node:child_process';
 import { copyFile, mkdir, mkdtemp, readdir, realpath, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, normalize, resolve } from 'node:path';
-import { promisify } from 'node:util';
 import { SUBAGENT_WORKSPACE_BINDING_SCHEMA_VERSION, isSubagentWorkspaceBinding, } from '@maka/core/subagent-workspace';
+import { execGitBytes, execGitText } from './git-exec.js';
 import { resolveProjectLocation } from './project-catalog.js';
-const execFileAsync = promisify(execFile);
 const LEASE_PATTERN = /^subagent_worktree_([a-f0-9]{32})$/;
 const WORKTREE_DIRECTORY_PATTERN = /^[a-f0-9]{32}$/;
-const GIT_TIMEOUT_MS = 2 * 60 * 1_000;
 /**
  * Host-owned Git worktree allocator for linked child Sessions.
  *
@@ -96,8 +93,8 @@ class GitWorktreeChildExecutor {
                 const currentIndex = (await runGit(binding.worktreePath, ['rev-parse', '--git-path', 'index'])).trim();
                 // Preserve staged and committed ignored paths, then overlay all working-tree changes.
                 await copyFile(isAbsolute(currentIndex) ? currentIndex : resolve(binding.worktreePath, currentIndex), indexPath);
-                const env = { GIT_INDEX_FILE: indexPath };
-                await runGit(binding.worktreePath, ['add', '--all', '--'], env);
+                const gitOptions = { gitIndexFile: indexPath };
+                await runGit(binding.worktreePath, ['add', '--all', '--'], gitOptions);
                 return await runGitBytes(binding.worktreePath, [
                     'diff',
                     '--cached',
@@ -108,7 +105,7 @@ class GitWorktreeChildExecutor {
                     '--no-color',
                     binding.baseCommit,
                     '--',
-                ], env);
+                ], gitOptions);
             }
             finally {
                 await rm(temporary, { recursive: true, force: true });
@@ -398,35 +395,11 @@ async function gitCurrentBranch(cwd) {
         throw error;
     }
 }
-async function runGit(cwd, args, overrides = {}) {
-    const env = gitEnvironment(overrides);
-    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
-        env,
-        encoding: 'utf8',
-        maxBuffer: 1024 * 1024,
-        timeout: GIT_TIMEOUT_MS,
-        windowsHide: true,
-    });
-    return stdout;
+async function runGit(cwd, args, options = {}) {
+    return execGitText(cwd, args, options);
 }
-async function runGitBytes(cwd, args, overrides = {}) {
-    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
-        env: gitEnvironment(overrides),
-        encoding: 'buffer',
-        maxBuffer: Number.MAX_SAFE_INTEGER,
-        timeout: GIT_TIMEOUT_MS,
-        windowsHide: true,
-    });
-    return new Uint8Array(stdout);
-}
-function gitEnvironment(overrides) {
-    const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0', ...overrides };
-    delete env.GIT_DIR;
-    delete env.GIT_WORK_TREE;
-    delete env.GIT_COMMON_DIR;
-    if (overrides.GIT_INDEX_FILE === undefined)
-        delete env.GIT_INDEX_FILE;
-    return env;
+async function runGitBytes(cwd, args, options = {}) {
+    return execGitBytes(cwd, args, options);
 }
 function gitExitCode(error) {
     if (!error || typeof error !== 'object' || !('code' in error))

package/node_modules/@maka/storage/dist/goal-authority.js

@@ -19,6 +19,7 @@
 import { decodeGoalAuthorityRecord } from '@maka/core/goal';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
 import { assertStorageRootLease, runWithStorageRootLease, StorageRootAuthorityError, } from './root-authority.js';
+import { assertSafeStorageId } from './storage-id.js';
 const writerBrand = Symbol('InteractiveGoalAuthorityWriter');
 const writers = new WeakSet();
 const writerByLease = new WeakMap();
@@ -217,6 +218,5 @@ function cloneSnapshot(snapshot) {
     });
 }
 function requireId(value, label) {
-    if (!/^[A-Za-z0-9_-]{1,128}$/.test(value))
-        throw new TypeError(`${label} identity is invalid`);
+    assertSafeStorageId(value, `${label} identity is invalid`);
 }

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

@@ -22,7 +22,7 @@ import { clientCapabilityScopeIdentity, decodeClientCapabilitySessionGrant, deco
 import { decodeInteractionCanonicalOutcome, decodeInteractionRequest, interactionCanonicalOutcomesEquivalent, isInteractionCanonicalOutcomeValidForRequest, projectInteractionFormRequest, projectInteractionQuestionRequest, } from '@maka/core/interaction';
 import { assertStorageRootLease, runWithStorageRootLease, StorageRootAuthorityError, } from './root-authority.js';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
-const SAFE_ID = /^[A-Za-z0-9_-]{1,128}$/;
+import { isSafeStorageId } from './storage-id.js';
 const REMEMBER_SCOPE_ID = /^[0-9a-f]{64}$/;
 export const STORED_INTERACTION_REQUEST_MAX_BYTES = 20 * 1024;
 export const STORED_INTERACTION_OUTCOME_MAX_BYTES = 12 * 1024;
@@ -512,7 +512,7 @@ function identity(value) {
     };
 }
 function assertId(value, source = 'input', message = 'Invalid Interaction identity') {
-    if (typeof value !== 'string' || !SAFE_ID.test(value))
+    if (!isSafeStorageId(value))
         decodeFailure(source, message);
     return value;
 }

package/node_modules/@maka/storage/dist/mcp-config-store.js

@@ -16,11 +16,15 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { randomUUID } from 'node:crypto';
-import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { MCP_CONFIG_VERSION, createDefaultMcpConfig, isNonLoopbackCleartextHttp, } from '@maka/core/mcp';
+import { writeAtomicFile } from './atomic-file-write.js';
 import { withProcessLifetimeFileUpdateLock } from './process-lifetime-file-update-lock.js';
+import { hardenDirectory } from './stable-storage.js';
+// Consumers reconcile an already-published write through this store's public
+// boundary; the shared atomic writer itself remains internal to storage.
+export { AtomicFileWriteCommitUnknownError } from './atomic-file-write.js';
 const MAX_SERVERS = 100;
 const MAX_ID_LENGTH = 128;
 const MAX_STRING_LENGTH = 8_192;
@@ -157,34 +161,15 @@ class FileMcpConfigStore {
         return withProcessLifetimeFileUpdateLock(this.path, operation);
     }
     async write(config) {
-        const dir = dirname(this.path);
         await this.ensureDirectory();
-        const tempPath = join(dir, `.mcp-${randomUUID()}.tmp`);
-        try {
-            await writeFile(tempPath, `${JSON.stringify(config, null, 2)}\n`, {
-                encoding: 'utf8',
-                mode: 0o600,
-                flag: 'wx',
-            });
-            if (process.platform !== 'win32')
-                await chmod(tempPath, 0o600);
-            await rename(tempPath, this.path);
-            if (process.platform !== 'win32')
-                await chmod(this.path, 0o600);
-        }
-        finally {
-            await rm(tempPath, { force: true }).catch(() => { });
-        }
+        await writeAtomicFile(this.path, `${JSON.stringify(config, null, 2)}\n`, {
+            fileMode: 0o600,
+        });
     }
     ensureDirectory() {
         if (this.directoryReady)
             return this.directoryReady;
-        const dir = dirname(this.path);
-        const ready = (async () => {
-            await mkdir(dir, { recursive: true, mode: 0o700 });
-            if (process.platform !== 'win32')
-                await chmod(dir, 0o700);
-        })();
+        const ready = hardenDirectory(dirname(this.path), 0o700);
         this.directoryReady = ready;
         void ready.catch(() => {
             if (this.directoryReady === ready)

package/node_modules/@maka/storage/dist/project-catalog.js

@@ -16,16 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { execFile } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { realpath, stat } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
-import { promisify } from 'node:util';
 import { markPersisted } from '@maka/core/persisted-value';
+import { execGitText } from './git-exec.js';
 import { hasEnclosingGitEntry } from './git-entry.js';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
 import { decodePersistedSessionHeader, normalizeSessionHeader } from './session-store.js';
-const execFileAsync = promisify(execFile);
 export class ProjectPathMismatchError extends Error {
     projectId;
     path;
@@ -690,26 +688,7 @@ function isPathWithin(root, candidate) {
     return path === '' || (!isAbsolute(path) && path !== '..' && !path.startsWith(`..${sep}`));
 }
 async function resolveGitLocation(canonicalPath) {
-    const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
-    delete env.GIT_DIR;
-    delete env.GIT_WORK_TREE;
-    delete env.GIT_INDEX_FILE;
-    delete env.GIT_COMMON_DIR;
-    const { stdout: locationOutput } = await execFileAsync('git', [
-        '-C',
-        canonicalPath,
-        'rev-parse',
-        '--path-format=absolute',
-        '--show-toplevel',
-        '--git-dir',
-        '--git-common-dir',
-    ], {
-        env,
-        encoding: 'utf8',
-        maxBuffer: 64 * 1024,
-        timeout: 3_000,
-        windowsHide: true,
-    });
+    const locationOutput = await execGitText(canonicalPath, ['rev-parse', '--path-format=absolute', '--show-toplevel', '--git-dir', '--git-common-dir'], { maxBuffer: 64 * 1024, timeoutMs: 3_000 });
     const [worktreeRootRaw, gitDirRaw, commonDirRaw] = locationOutput.trim().split(/\r?\n/);
     if (!worktreeRootRaw || !gitDirRaw || !commonDirRaw) {
         throw new Error(`Git returned an incomplete project location for: ${canonicalPath}`);

package/node_modules/@maka/storage/dist/runtime-event-invariants.js

@@ -16,9 +16,9 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-const SAFE_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+import { isSafeStorageId } from './storage-id.js';
 export function isRuntimeStorageSafeId(value) {
-    return SAFE_ID_PATTERN.test(value);
+    return isSafeStorageId(value);
 }
 export function immutableSteeringMessageId(event) {
     const messageId = event.refs?.providerEventId;

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

@@ -20,7 +20,7 @@ import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { CONNECTION_CATALOG_MAX_CONNECTIONS, decodeCanonicalConnectionCatalogEntry, decodeConnectionName, decodeConnectionSlug, decodeConnectionTarget, decodeConnectionTestSummary, decodeProviderType, decodeRuntimePolicyEntityId, normalizeConnectionCatalogEntryUpdateForProvider, normalizeConnectionModelDiscoveryResult, normalizeCreateCatalogConnectionInput, normalizeRemoveCatalogConnectionInput, normalizeSetDefaultConnectionTargetInput, normalizeUpdateCatalogConnectionInput, } from '@maka/core/runtime-policy';
 import { PROVIDER_REGISTRY, reconcileConnectionAfterModelFetch } from '@maka/core/llm-connections';
-import { modelIdAliasesForProvider } from '@maka/core/model-metadata';
+import { modelIdAliasesForProvider, providerReportsCompleteModelCatalog, } from '@maka/core/model-metadata';
 import { isRetiredProvider } from '@maka/core/provider-registry';
 import { pruneRelayModelProfiles } from '@maka/core/model-thinking';
 import { deepFreeze, nextRevision, record, revision, unique } from './codec.js';
@@ -325,14 +325,19 @@ export class ConnectionCatalogDocumentOwner {
             hasModelInventory: previous.models.length > 0,
         }, result.models, {
             aliases: modelIdAliasesForProvider(previous.providerType),
+            authoritative: providerReportsCompleteModelCatalog(previous.providerType),
         });
         // Discovery MOVES a target: a provider's model rename carries the default
         // across by alias. A default outside the selection the reconciler just
         // decided is its own bug — fail closed where it is still attributable.
         const defaultTarget = currentDefaultTarget
-            ? { connectionId: previous.connectionId, modelId: reconciled.defaultModel }
+            ? reconciled.defaultModel
+                ? { connectionId: previous.connectionId, modelId: reconciled.defaultModel }
+                : null
             : current.defaultTarget;
-        if (currentDefaultTarget && !reconciled.enabledModelIds.includes(reconciled.defaultModel)) {
+        if (currentDefaultTarget &&
+            reconciled.defaultModel &&
+            !reconciled.enabledModelIds.includes(reconciled.defaultModel)) {
             throw codecError('invalid_document', 'Model discovery reconciled a default outside its own selection');
         }
         // A refresh only ever migrates a renamed id now, but that rename still