maka-agent 0.2.0-dev.25.20260908 → 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/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/session-store.js

@@ -351,9 +351,9 @@ class SqliteSessionStore {
         // pre-cutover session sees its imported rows.
         return projectHeaderSnapshot(await this.metadata.read(sessionId));
     }
-    async readCatalogRecord(sessionId) {
+    async readCatalogRecord(sessionId, roleScope = 'ordinary') {
         await this.ensureCatalogProjectionReadable();
-        const record = await this.metadata.readCatalogRecord(sessionId);
+        const record = await this.metadata.readCatalogRecord(sessionId, roleScope);
         return {
             ...projectHeaderSnapshot(record),
             activityAt: record.activityAt,
@@ -372,6 +372,18 @@ class SqliteSessionStore {
         await this.ensureReady();
         return this.metadata.readTranscriptHighWater(sessionId);
     }
+    async readCoordinationTranscriptIndexState() {
+        await this.ensureReady();
+        return this.metadata.readCoordinationTranscriptIndexState();
+    }
+    async appendCoordinationTranscriptIndex(records) {
+        await this.ensureReady();
+        return this.metadata.appendCoordinationTranscriptIndex(records);
+    }
+    async readCoordinationTranscriptIndex(request) {
+        await this.ensureReady();
+        return this.metadata.readCoordinationTranscriptIndex(request);
+    }
     async listTurnsSnapshot(sessionId) {
         return deriveTurnRecords(await this.readMessagesSnapshot(sessionId));
     }

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

@@ -16,10 +16,11 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { mkdir, readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { createDefaultSettings, mergeSettings, normalizeSettings } from '@maka/core/settings';
 import { sanitizeOnboardingMilestones } from '@maka/core/onboarding';
+import { writeAtomicFile } from './atomic-file-write.js';
 export function createSettingsStore(workspaceRoot) {
     return new FileSettingsStore(workspaceRoot);
 }
@@ -133,10 +134,13 @@ class FileSettingsStore {
         return result;
     }
     async write(settings) {
+        // SettingsStore does not own the workspace directory's permission policy:
+        // sibling stores such as MCP config may independently harden the same root.
+        // Keep both directory creation and the historical umask-derived file mode.
         await mkdir(dirname(this.settingsPath), { recursive: true });
-        const tempPath = `${this.settingsPath}.${process.pid}.${Date.now()}.tmp`;
-        await writeFile(tempPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
-        await rename(tempPath, this.settingsPath);
+        await writeAtomicFile(this.settingsPath, JSON.stringify(settings, null, 2) + '\n', {
+            fileMode: 0o666 & ~process.umask(),
+        });
     }
     withQueue(operation) {
         const next = this.queue.then(operation, operation);

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

@@ -82,6 +82,17 @@ class SqliteArtifactMetadataRepository {
             .prepare('SELECT 1 FROM artifact_records WHERE relative_path = ?')
             .get(relativePath));
     }
+    readRelativePathsByCaseFoldedArtifactIds(artifactIds) {
+        this.assertOpen();
+        if (artifactIds.length === 0)
+            return [];
+        const placeholders = artifactIds.map(() => '?').join(', ');
+        const rows = this.#lease.database
+            .prepare(`SELECT relative_path FROM artifact_records
+          WHERE artifact_id COLLATE NOCASE IN (${placeholders})`)
+            .all(...artifactIds);
+        return rows.map((row) => row.relative_path);
+    }
     forgetUpgradeOrphanPaths(relativePaths) {
         this.assertOpen();
         this.#lease.transaction('write', () => {

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

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const SQLITE_SESSION_METADATA_SCHEMA_VERSION = 38;
+export const SQLITE_SESSION_METADATA_SCHEMA_VERSION = 39;
 export const SQLITE_SESSION_MESSAGE_CHUNK_BYTES = 64 * 1024;
 export const SQLITE_SESSION_MESSAGE_CHUNK_MARKER = '{"$maka":"session-message-chunks-v1"}';
 export const SQLITE_AGENT_GRAPH_CONTROL_TABLES = [
@@ -32,6 +32,17 @@ export const SQLITE_AGENT_GRAPH_CONTROL_TABLES = [
     'agent_graph_supervisor_wake_attempts',
 ];
 const MIGRATIONS = new Map([
+    [
+        39,
+        `
+    CREATE TABLE IF NOT EXISTS coordination_transcript_index (
+      sequence INTEGER PRIMARY KEY,
+      source TEXT NOT NULL CHECK (source IN ('legacy', 'runtime')),
+      source_sequence INTEGER NOT NULL CHECK (source_sequence >= 0),
+      UNIQUE (source, source_sequence)
+    );
+  `,
+    ],
     [
         1,
         `

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

@@ -730,10 +730,12 @@ export class SqliteSessionMetadataStore {
             throw new SessionNotFoundError(sessionId);
         return record;
     }
-    async readCatalogRecord(sessionId) {
+    async readCatalogRecord(sessionId, roleScope = 'ordinary') {
         this.assertOpen();
         assertSafeSessionId(sessionId);
-        const role = sqliteOrdinarySessionRolePredicate();
+        const role = roleScope === 'recoverable'
+            ? sqliteRecoverableSessionRolePredicate()
+            : sqliteOrdinarySessionRolePredicate();
         const row = this.db
             .prepare(`
         SELECT
@@ -1206,7 +1208,11 @@ export class SqliteSessionMetadataStore {
             assignment.id !== `wha_${suffix}` ||
             assignment.targetMessageId !== `whm_${suffix}` ||
             assignment.delegationId !== `whd_${suffix}` ||
-            !messageContentsEqual(admission.content, normalizeMessageContent({ text: assignment.userText })) ||
+            !workHubAssignmentAttachmentsMatchTarget(assignment) ||
+            !messageContentsEqual(admission.content, normalizeMessageContent({
+                text: assignment.delegationText ?? assignment.userText,
+                ...(assignment.targetAttachments ? { attachments: assignment.targetAttachments } : {}),
+            })) ||
             admission.submittedContentDigest !== messageContentDigest(admission.content) ||
             admission.submittedPlacement !== 'current_turn' ||
             admission.placement !== 'current_turn' ||
@@ -1825,6 +1831,45 @@ export class SqliteSessionMetadataStore {
             unique.forEach((messageId, index) => update.run(index, sessionId, messageId));
         });
     }
+    async readCoordinationTranscriptIndexState() {
+        this.assertOpen();
+        return this.db
+            .prepare(`SELECT (SELECT MAX(sequence) FROM coordination_transcript_index) AS highWater,
+      (SELECT MAX(source_sequence) FROM coordination_transcript_index WHERE source = 'legacy') AS legacy,
+      (SELECT MAX(source_sequence) FROM coordination_transcript_index WHERE source = 'runtime') AS runtime`)
+            .get();
+    }
+    async appendCoordinationTranscriptIndex(records) {
+        this.assertOpen();
+        if (records.length > 64)
+            throw new Error('Coordination transcript index batch exceeds limit');
+        this.transaction(() => {
+            let sequence = this.db
+                .prepare('SELECT MAX(sequence) AS value FROM coordination_transcript_index')
+                .get().value ?? -1;
+            const insert = this.db.prepare(`INSERT INTO coordination_transcript_index
+        (sequence, source, source_sequence) VALUES (?, ?, ?)
+        ON CONFLICT(source, source_sequence) DO NOTHING`);
+            for (const record of records) {
+                if (!Number.isSafeInteger(record.sourceSequence) || record.sourceSequence < 0)
+                    throw new Error('Invalid Coordination source sequence');
+                const result = insert.run(sequence + 1, record.source, record.sourceSequence);
+                if (result.changes)
+                    sequence++;
+            }
+        });
+    }
+    async readCoordinationTranscriptIndex(request) {
+        this.assertOpen();
+        if (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 64)
+            throw new Error('Invalid Coordination transcript index limit');
+        const older = request.direction === 'older';
+        return this.db
+            .prepare(`SELECT sequence, source, source_sequence AS sourceSequence
+      FROM coordination_transcript_index WHERE sequence <= ? AND sequence ${older ? '<=' : '>='} ?
+      ORDER BY sequence ${older ? 'DESC' : 'ASC'} LIMIT ?`)
+            .all(request.throughSequence, request.position, request.limit);
+    }
     async readMessages(sessionId) {
         return this.readMessagesWith(sessionId, decodeStoredMessage);
     }
@@ -4566,6 +4611,21 @@ function isWorkHubActionOperation(value) {
         value === 'replace' ||
         value === 'stop');
 }
+function workHubAssignmentAttachmentsMatchTarget(assignment) {
+    const source = assignment.attachments ?? [];
+    const target = assignment.targetAttachments ?? [];
+    return (source.length === target.length &&
+        source.every((attachment, index) => {
+            const copied = target[index];
+            const { ref: sourceRef, ...sourceMetadata } = attachment;
+            const { ref: targetRef, ...targetMetadata } = copied;
+            return (sourceRef.kind === 'session_file' &&
+                sourceRef.sessionId === WORKHUB_COORDINATION_SESSION_ID &&
+                targetRef.kind === 'session_file' &&
+                targetRef.sessionId === assignment.targetSessionId &&
+                isDeepStrictEqual(sourceMetadata, targetMetadata));
+        }));
+}
 function sameWorkHubAssignmentRequest(existing, requested) {
     return isDeepStrictEqual({
         actionId: existing.actionId,
@@ -4574,6 +4634,8 @@ function sameWorkHubAssignmentRequest(existing, requested) {
         targetSessionId: existing.targetSessionId,
         disposition: existing.disposition,
         userText: existing.userText,
+        delegationText: existing.delegationText,
+        attachments: existing.attachments,
         create: existing.create,
         replacesActionId: existing.replacesActionId,
         replacesDelegationId: existing.replacesDelegationId,
@@ -4584,6 +4646,8 @@ function sameWorkHubAssignmentRequest(existing, requested) {
         targetSessionId: requested.targetSessionId,
         disposition: requested.disposition,
         userText: requested.userText,
+        delegationText: requested.delegationText,
+        attachments: requested.attachments,
         create: requested.create,
         replacesActionId: requested.replacesActionId,
         replacesDelegationId: requested.replacesDelegationId,

package/node_modules/@maka/storage/dist/stable-storage.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { constants } from 'node:fs';
-import { lstat, open } from 'node:fs/promises';
+import { chmod, lstat, mkdir, open } from 'node:fs/promises';
 import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
 const openStableFile = open;
 const lstatStableFile = lstat;
@@ -74,6 +74,19 @@ export async function syncFile(path) {
         await handle.close();
     }
 }
+/**
+ * Create (or harden) an owner-only directory: recursive mkdir plus a
+ * fail-closed chmod, since mkdir's mode only applies on creation. Callers that
+ * store secrets use this before creating their file or update lock.
+ */
+export async function hardenDirectory(dir, mode = 0o700) {
+    await mkdir(dir, { recursive: true, mode });
+    if (process.platform === 'win32') {
+        await chmod(dir, mode).catch(() => { });
+        return;
+    }
+    await chmod(dir, mode);
+}
 export async function syncDirectoryChain(path, root, beforeSync) {
     const boundary = resolve(root);
     let current = resolve(path);

package/package.json

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