@myagentroam/node 0.10.2 → 0.10.4

package/dist/connector.js

@@ -316,13 +316,19 @@ export class NodeConnector {
     workspaceFileService = new WorkspaceFileService(this.workspaceState, (workspaceId) => {
         this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
         this.workspaceCoordinator.invalidate(workspaceId);
-    });
+    }, {}, (workspaceId, resourcePath) => this.workspaceUploadService.fileResource(workspaceId, resourcePath) ??
+        this.runAttachmentService.fileResource(workspaceId, resourcePath));
     workspaceUploadService = new WorkspaceUploadService(this.workspaceState, (workspaceId) => {
         this.workspaceFileService.dispose(workspaceId);
         this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
         this.workspaceCoordinator.invalidate(workspaceId);
-    });
+    }, () => this.attachmentTemporaryRoot());
     directTransferService;
+    attachmentTemporaryRoot() {
+        if (this.config === undefined)
+            throw new Error('NODE_CONFIG_UNAVAILABLE');
+        return resolve(nodeDataDirectory(this.config, this.configPath), 'temp-files');
+    }
     workspaceChangeService = new WorkspaceChangeService(this.workspaceState);
     workspaceWorkbenchService;
     database;
@@ -518,7 +524,7 @@ export class NodeConnector {
             options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
         this.fakeScript = options.fakeScript;
         this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoots(session), (sessionId) => this.runtime.activeSessionRun(sessionId) !== undefined ||
-            this.runtime.sessionQueue(sessionId).itemIds.length > 0);
+            this.runtime.sessionQueue(sessionId).itemIds.length > 0, () => this.attachmentTemporaryRoot());
         this.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory, options.codexRunClientFactory);
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
@@ -615,7 +621,15 @@ export class NodeConnector {
             intercepted: () => this.fakeRunner !== undefined,
             active: this.runState.active,
             parseAttachments: parseRunnerImageAttachments,
-            persistAttachments: (cwd, runId, attachments) => this.runAttachmentService.persistFiles(cwd, `${runId}-opencode-images`, attachments),
+            persistAttachments: async (_cwd, runId, attachments) => {
+                const run = this.runtime.getRun(runId);
+                if (run === undefined)
+                    throw new Error('RUN_NOT_FOUND');
+                const storageRunId = `${runId}-opencode-images`;
+                const paths = await this.runAttachmentService.persistFiles(run.workspaceId, storageRunId, attachments);
+                this.runAttachmentService.retainSessionFiles(run.sessionId, storageRunId);
+                return paths;
+            },
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             adopt: (input) => this.runtime.adoptRun(input),
@@ -1684,7 +1698,7 @@ export class NodeConnector {
                 nodeGeneration: () => this.nodeGeneration,
                 send: (type, payload) => this.send(type, payload),
                 terminalManager: this.terminalManager,
-                sendTerminalReady: (directSessionId) => this.send('terminal.direct.ready', { directSessionId }),
+                sendTerminalReady: (directSessionId, phase) => this.send('terminal.direct.ready', { directSessionId, ...(phase ? { phase } : {}) }),
                 udpPortRange: () => directTransferUdpPortRange(this.config),
                 openUpload: async (descriptor) => {
                     if (descriptor.direction !== 'UPLOAD' || descriptor.resource.kind !== 'WORKSPACE_FILE')

package/dist/main.js

@@ -23,11 +23,6 @@ if (command === 'run') {
     for (const signal of ['SIGINT', 'SIGTERM']) {
         process.once(signal, shutdown);
     }
-    if (args.includes('--managed-parent')) {
-        if (process.send === undefined || !process.connected)
-            throw new Error('NODE_MANAGED_PARENT_UNAVAILABLE');
-        process.once('disconnect', shutdown);
-    }
     await connector.start();
 }
 else if (command === 'supervise') {

package/dist/runner/opencode/managed-run-controller.js

@@ -1,3 +1,4 @@
+import { parseComposerTags } from '@myagentroam/protocol';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
@@ -264,9 +265,18 @@ export class OpenCodeManagedRunController {
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
             // The initial SSE snapshot can contain an idle event from before this prompt.
             this.pendingIdle.delete(input.runId);
+            // Replacement inputs can retain earlier tags; the latest tag describes the current images.
+            const currentAttachments = parseComposerTags(input.input)
+                .filter((part) => part.kind === 'mar_attachments')
+                .at(-1);
+            const existingImagePaths = currentAttachments?.payload.files
+                .filter((file) => input.attachments.some((image) => image.name === file.name && image.mime === file.mime))
+                .map((file) => file.path) ?? [];
             const attachmentPaths = input.attachments.length === 0
                 ? []
-                : await this.host.persistAttachments(input.cwd, input.runId, input.attachments);
+                : existingImagePaths.length === input.attachments.length
+                    ? existingImagePaths
+                    : await this.host.persistAttachments(input.cwd, input.runId, input.attachments);
             const execution = this.runner.execution.get(input.runId);
             if (execution !== undefined) {
                 execution.responseLatency = new ResponseLatencyTracker();
@@ -660,7 +670,7 @@ function openCodeImageInput(input, attachmentPaths) {
     if (attachmentPaths.length === 0)
         return input;
     const paths = attachmentPaths.map((path) => `- ${JSON.stringify(path)}`).join('\n');
-    return `${input}\n\nIf an inline image in this message is unavailable, use the read tool on the corresponding copy below. Do not read it again when the inline image is already visible:\n${paths}`;
+    return `${input}\n\nIf an inline image in this message is unavailable, use the read tool on the corresponding file below. Do not read it again when the inline image is already visible:\n${paths}`;
 }
 function hasMcpConfiguration(value) {
     return value !== null && typeof value === 'object' && Object.keys(value).length > 0;

package/dist/service/direct-transfer-service.js

@@ -47,7 +47,7 @@ export class DirectTransferService {
         this.leaseGraceMs = options.leaseGraceMs ?? LEASE_GRACE_MS;
         this.leaseCheckMs = options.leaseCheckMs ?? LEASE_CHECK_MS;
         if (options.terminalManager !== undefined)
-            this.terminalDirect = new TerminalDirectService(options.terminalManager, (id) => options.sendTerminalReady?.(id), (command, peer) => {
+            this.terminalDirect = new TerminalDirectService(options.terminalManager, (id, phase) => options.sendTerminalReady?.(id, phase), (command, peer) => {
                 const transport = this.transports.get(command.transportSessionId);
                 return (transport?.peer === peer &&
                     transport.command.workbenchConnectionId === command.workbenchConnectionId &&

package/dist/service/run-attachment-service.js

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
@@ -11,11 +11,16 @@ const SESSION_ATTACHMENT_IDLE_TTL_MS = 30 * 60_000;
 export class RunAttachmentService {
     nativeImageRoots;
     sessionIsBusy;
+    temporaryRoot;
     state = new AttachmentDomainState();
     disposed = false;
-    constructor(nativeImageRoots, sessionIsBusy = () => false) {
+    fileResources = new Map();
+    constructor(nativeImageRoots, sessionIsBusy = () => false, temporaryRoot = () => {
+        throw new Error('NODE_CONFIG_UNAVAILABLE');
+    }) {
         this.nativeImageRoots = nativeImageRoots;
         this.sessionIsBusy = sessionIsBusy;
+        this.temporaryRoot = temporaryRoot;
     }
     protectSession(sessionId) {
         this.assertOpen();
@@ -51,6 +56,25 @@ export class RunAttachmentService {
         this.state.runFileSessions.set(runId, sessionId);
         this.refreshSession(sessionId);
     }
+    adoptSessionFiles(sessionId, runId, directories, workspaceId, paths) {
+        this.assertOpen();
+        if (directories.length === 0)
+            return;
+        this.state.runFileDirectories.set(runId, [...directories]);
+        this.registerFileResources(workspaceId, paths);
+        this.retainSessionFiles(sessionId, runId);
+    }
+    resourcePath(path) {
+        return `mar-attachment://${basename(dirname(path))}/${basename(path)}`;
+    }
+    fileResource(workspaceId, resourcePath) {
+        const resource = this.fileResources.get(resourcePath);
+        return resource?.workspaceId === workspaceId ? resource.path : undefined;
+    }
+    registerFileResources(workspaceId, paths) {
+        for (const path of paths)
+            this.fileResources.set(this.resourcePath(path), { workspaceId, path });
+    }
     refreshSession(sessionId) {
         if (this.disposed)
             return;
@@ -106,16 +130,20 @@ export class RunAttachmentService {
         this.refreshSession(nextId);
     }
     async discardFiles(runId) {
-        const directory = this.state.runFileDirectories.get(runId);
+        const directories = this.state.runFileDirectories.get(runId);
         this.state.runFileDirectories.delete(runId);
+        if (directories !== undefined)
+            for (const [resourcePath, resource] of this.fileResources)
+                if (directories.includes(dirname(resource.path)))
+                    this.fileResources.delete(resourcePath);
         const sessionId = this.state.runFileSessions.get(runId);
         this.state.runFileSessions.delete(runId);
         if (sessionId !== undefined) {
             this.state.sessionRetentions.get(sessionId)?.runs.delete(runId);
             this.refreshSession(sessionId);
         }
-        if (directory !== undefined)
-            await rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        if (directories !== undefined)
+            await Promise.all(directories.map((directory) => rm(directory, { recursive: true, force: true }).catch(() => undefined)));
     }
     async releaseSession(sessionId) {
         const retained = this.state.sessionRetentions.get(sessionId);
@@ -173,32 +201,48 @@ export class RunAttachmentService {
             throw error;
         }
     }
-    async persistFiles(workspacePath, runId, attachments) {
+    async persistFiles(workspaceId, runId, attachments) {
         if (attachments.length === 0)
             return [];
         this.assertOpen();
-        const marDirectory = resolve(workspacePath, '.mar');
-        await mkdir(marDirectory, { recursive: true, mode: 0o700 });
-        const marMetadata = await lstat(marDirectory);
-        if (!marMetadata.isDirectory() || marMetadata.isSymbolicLink())
-            throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
-        const filesDirectory = join(marDirectory, 'temp-files');
+        const filesDirectory = this.temporaryRoot();
         await mkdir(filesDirectory, { recursive: true, mode: 0o700 });
         const filesMetadata = await lstat(filesDirectory);
         if (!filesMetadata.isDirectory() || filesMetadata.isSymbolicLink())
             throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
-        const runDirectory = join(filesDirectory, runId);
-        await mkdir(runDirectory, { mode: 0o700 });
-        this.state.runFileDirectories.set(runId, runDirectory);
+        const createdDirectories = [];
         try {
+            const paths = [];
+            for (const attachment of attachments) {
+                this.assertOpen();
+                const directory = join(filesDirectory, randomUUID());
+                await mkdir(directory, { mode: 0o700 });
+                createdDirectories.push(directory);
+                this.state.runFileDirectories.set(runId, [
+                    ...(this.state.runFileDirectories.get(runId) ?? []),
+                    directory
+                ]);
+                const path = join(directory, attachment.name);
+                await writeFile(path, Buffer.from(attachment.dataBase64, 'base64'), {
+                    flag: 'wx',
+                    mode: 0o600
+                });
+                paths.push(path);
+            }
             this.assertOpen();
-            await Promise.all(attachments.map((attachment) => writeFile(join(runDirectory, attachment.name), Buffer.from(attachment.dataBase64, 'base64'), { flag: 'wx', mode: 0o600 })));
-            this.assertOpen();
-            return attachments.map((attachment) => `.mar/temp-files/${runId}/${attachment.name}`);
+            this.registerFileResources(workspaceId, paths);
+            return paths;
         }
         catch (error) {
-            this.state.runFileDirectories.delete(runId);
-            await rm(runDirectory, { recursive: true, force: true });
+            const directories = this.state.runFileDirectories.get(runId);
+            if (directories !== undefined) {
+                const retained = directories.filter((directory) => !createdDirectories.includes(directory));
+                if (retained.length === 0)
+                    this.state.runFileDirectories.delete(runId);
+                else
+                    this.state.runFileDirectories.set(runId, retained);
+            }
+            await Promise.all(createdDirectories.map((directory) => rm(directory, { recursive: true, force: true })));
             throw error;
         }
     }

package/dist/service/session-message-service.js

@@ -5,7 +5,7 @@ import { personalInstructionsForRunner } from '../util/personal-instructions.js'
 import { safeErrorCode } from '../util/safe-error.js';
 import { publicGoalStartText } from './goal-runtime.js';
 import { serializeComposerTag, composerVisibleText } from '@myagentroam/protocol';
-import { relative, resolve } from 'node:path';
+import { relative } from 'node:path';
 import { prepareComposerResourceInput, composerResourceInputTags, validateComposerSkills } from './composer-message-input.js';
 const INTERNAL_GOAL = Symbol('internalGoal');
 const INTERNAL_SCHEDULE = Symbol('internalSchedule');
@@ -148,24 +148,29 @@ export class SessionMessageService {
             if (created.queueItem === undefined)
                 this.options.coordinator.publishCurrentTurn(created.run.id);
             const prepare = async () => {
+                let reservation;
                 try {
                     const currentSession = this.options.runtime.getAgentSession(session.id) ?? session;
-                    const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
-                    const attachments = attachmentIds.length === 0
+                    if (attachmentIds.length > 0)
+                        reservation = await this.options.uploads.reserve(session.workspaceId, attachmentIds);
+                    const attachments = reservation === undefined
                         ? inlineAttachments
-                        : uploaded.map((attachment) => attachment.attachment);
+                        : reservation.attachments.map((attachment) => attachment.attachment);
                     const imageAttachments = attachments.filter(isImageAttachment);
                     const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
                     const workspacePath = this.options.workspacePath?.(currentSession.workspaceId) ?? currentSession.cwd;
                     await validateComposerSkills(runnerContent, workspacePath);
-                    const attachmentPaths = await this.persistAttachments(currentSession, submissionId, attachments);
+                    const attachmentPaths = reservation === undefined
+                        ? await this.persistAttachments(currentSession, submissionId, attachments)
+                        : reservation.attachments.map((attachment) => attachment.path);
                     const attachmentFiles = attachments.map((attachment, index) => ({
                         name: attachment.name,
                         mime: attachment.mime,
-                        path: attachmentPaths[index]
+                        path: reservation?.attachments[index]?.resourcePath ??
+                            this.options.attachments.resourcePath(attachmentPaths[index])
                     }));
-                    const runnerFiles = attachmentFiles.map((file) => {
-                        const path = relative(currentSession.cwd, resolve(workspacePath, file.path)).replaceAll('\\', '/');
+                    const runnerFiles = attachmentFiles.map((file, index) => {
+                        const path = relative(currentSession.cwd, attachmentPaths[index]).replaceAll('\\', '/');
                         return path === file.path ? file : { ...file, path, workspacePath: file.path };
                     });
                     const displayInput = withNonImageAttachmentPrompt(publicContent, attachmentPaths, attachmentFiles);
@@ -228,11 +233,12 @@ export class SessionMessageService {
                         queueBefore: queueBeforeCreate,
                         ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })
                     });
+                    reservation?.commit((directories) => this.options.attachments.adoptSessionFiles(currentSession.id, submissionId, directories, currentSession.workspaceId, attachmentPaths));
                     this.options.attachments.acceptSessionInput(currentSession.id);
-                    void this.options.uploads.consume(attachmentIds).catch(() => undefined);
                     return delivery;
                 }
                 catch (error) {
+                    reservation?.release();
                     if (goalMessage !== undefined)
                         this.options.goalPreparationFailed(session, goalMessage.goal, goalMessage.activated);
                     this.options.coordinator.failPreparation(submissionId, safeErrorCode(error, 'MESSAGE_PREPARATION_FAILED'));
@@ -263,7 +269,7 @@ export class SessionMessageService {
         }
     }
     async persistAttachments(session, runId, attachments) {
-        return this.options.attachments.persistFiles(this.options.workspacePath?.(session.workspaceId) ?? session.cwd, runId, attachments);
+        return this.options.attachments.persistFiles(session.workspaceId, runId, attachments);
     }
     async channelMessage(input) {
         if (typeof input.sessionId !== 'string' ||

package/dist/service/terminal-direct-service.js

@@ -114,6 +114,9 @@ export class TerminalDirectService {
                 this.sendFrame(session, frame);
             channel.onmessage = (event) => this.accept(session, event.data);
             this.manager.startCommand(session.command.terminalId);
+            void Promise.resolve()
+                .then(() => this.sendReady(session.command.directSessionId, 'ATTACHED'))
+                .catch(() => console.warn('AUDIT_RECEIPT_UNAVAILABLE'));
         }
         catch (error) {
             this.remove(session, error instanceof Error && error.message === 'TERMINAL_ATTACH_CONFLICT'

package/dist/service/workspace-file-service.js

@@ -1,5 +1,6 @@
-import { isAbsolute, relative, resolve, win32 } from 'node:path';
-import { realpath } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, relative, resolve, win32 } from 'node:path';
+import { lstat, realpath } from 'node:fs/promises';
+import { isComposerAttachmentResourcePath } from '@myagentroam/protocol';
 import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAbsoluteFileContentRange, readWorkspaceFileContentRange, readAbsoluteTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
 const INDEX_CACHE_LIMIT = 32;
 const INDEX_CACHE_BYTE_LIMIT = 128 * 1024 * 1024;
@@ -9,13 +10,15 @@ export class WorkspaceFileService {
     state;
     onInvalidated;
     indexLimits;
+    attachmentResource;
     mutationTails = new Map();
     indexQueue = [];
     indexRunning = false;
-    constructor(state, onInvalidated, indexLimits = {}) {
+    constructor(state, onInvalidated, indexLimits = {}, attachmentResource = () => undefined) {
         this.state = state;
         this.onInvalidated = onInvalidated;
         this.indexLimits = indexLimits;
+        this.attachmentResource = attachmentResource;
     }
     async list(workspace, input) {
         if ((input.path !== undefined && typeof input.path !== 'string') ||
@@ -38,6 +41,13 @@ export class WorkspaceFileService {
             throw new Error('FILE_RANGE_INVALID');
         const offset = typeof input.offset === 'number' ? input.offset : 0;
         const limit = typeof input.limit === 'number' ? input.limit : 512 * 1024;
+        if (input.path.startsWith('mar-attachment:')) {
+            const target = await this.resolveAttachmentResource(workspace.id, input.path);
+            return {
+                ...(await readWorkspaceTextFile(dirname(target), basename(target), offset, limit)),
+                path: input.path
+            };
+        }
         const path = normalizeFilePreviewPath(input.path);
         if (workspacePath !== workspace.path && isFilePreviewAbsolutePath(path))
             throw new Error('FILE_PATH_ESCAPE');
@@ -54,6 +64,15 @@ export class WorkspaceFileService {
                     input.limit < 1 ||
                     input.limit > 512 * 1024)))
             throw new Error('FILE_RANGE_INVALID');
+        if (input.path.startsWith('mar-attachment:')) {
+            if (input.previewDirectory !== undefined)
+                throw new Error('FILE_PATH_ESCAPE');
+            const target = await this.resolveAttachmentResource(workspace.id, input.path);
+            return {
+                ...(await readWorkspaceFileContentRange(dirname(target), basename(target), typeof input.offset === 'number' ? input.offset : 0, typeof input.limit === 'number' ? input.limit : 512 * 1024)),
+                path: input.path
+            };
+        }
         const path = normalizeFilePreviewPath(input.path);
         if (workspacePath !== workspace.path && isFilePreviewAbsolutePath(path))
             throw new Error('FILE_PATH_ESCAPE');
@@ -76,6 +95,23 @@ export class WorkspaceFileService {
             ? readAbsoluteFileContentRange(path, offset, limit)
             : readWorkspaceFileContentRange(workspacePath, path, offset, limit);
     }
+    async resolveAttachmentResource(workspaceId, path) {
+        if (!isComposerAttachmentResourcePath(path))
+            throw new Error('FILE_PATH_ESCAPE');
+        const target = this.attachmentResource(workspaceId, path);
+        if (target === undefined)
+            throw new Error('FILE_NOT_FOUND');
+        const [directory, file] = await Promise.all([lstat(dirname(target)), lstat(target)]).catch((error) => {
+            if (error.code === 'ENOENT')
+                throw new Error('FILE_NOT_FOUND');
+            throw error;
+        });
+        if (directory.isSymbolicLink() || file.isSymbolicLink())
+            throw new Error('FILE_PATH_ESCAPE');
+        if (!directory.isDirectory() || !file.isFile())
+            throw new Error('FILE_NOT_REGULAR');
+        return target;
+    }
     readDirect(workspace, input, workspacePath = workspace.path) {
         const readContent = this.readContent.bind(this);
         return (async function* () {
@@ -147,6 +183,8 @@ export class WorkspaceFileService {
         const path = input.path;
         const content = input.content;
         const expectedRevision = input.expectedRevision;
+        if (path.startsWith('mar-attachment:'))
+            throw new Error('FILE_PATH_ESCAPE');
         return this.serializeMutation(workspace.id, async () => {
             const result = await writeWorkspaceTextFile(workspace.path, path, content, expectedRevision);
             this.dispose(workspace.id);
@@ -177,6 +215,8 @@ export class WorkspaceFileService {
             throw new Error('FILE_MUTATION_INVALID');
         const path = input.path;
         const destination = typeof input.destination === 'string' ? input.destination : undefined;
+        if (path.startsWith('mar-attachment:') || destination?.startsWith('mar-attachment:'))
+            throw new Error('FILE_PATH_ESCAPE');
         return this.serializeMutation(workspace.id, async () => {
             const result = await mutateWorkspaceFile(workspace.path, action === 'MOVE' ? { action, path, destination: destination } : { action, path });
             this.dispose(workspace.id);

package/dist/service/workspace-git-exclude-service.js

@@ -9,11 +9,10 @@ const BLOCK_END = '# END MyAgentRoam';
 const LEGACY_BLOCK_BEGIN = '# BEGIN MyAgentRoam Skills';
 const LEGACY_BLOCK_END = '# END MyAgentRoam Skills';
 export async function ensureWorkspaceGitExclude(workspace) {
-    await mutateGitExclude(workspace, (entries) => entries.add(MAR_TEMP_DIRECTORY));
+    await mutateGitExclude(workspace, () => undefined);
 }
 export async function updateWorkspaceSkillGitExclude(workspace, name, add) {
     await mutateGitExclude(workspace, (entries) => {
-        entries.add(MAR_TEMP_DIRECTORY);
         for (const root of ['.agents', '.claude']) {
             const line = `/${root}/skills/${name}/`;
             if (add)
@@ -26,7 +25,6 @@ export async function updateWorkspaceSkillGitExclude(workspace, name, add) {
 export async function rewriteWorkspaceGitExclude(workspace, names) {
     await mutateGitExclude(workspace, (entries) => {
         entries.clear();
-        entries.add(MAR_TEMP_DIRECTORY);
         for (const name of names)
             for (const root of ['.agents', '.claude'])
                 entries.add(`/${root}/skills/${name}/`);
@@ -65,9 +63,13 @@ async function mutateGitExclude(workspace, mutate) {
     const pattern = managedBlockPattern();
     const existing = [...content.matchAll(pattern)].map((match) => match[0]).join('\n');
     const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/.')));
+    entries.delete(MAR_TEMP_DIRECTORY);
     mutate(entries);
-    const block = `${BLOCK_BEGIN}\n${[...entries].sort().join('\n')}\n${BLOCK_END}\n`;
-    const next = content.replace(pattern, '').replace(/\s*$/u, '\n') + block;
+    const block = entries.size === 0 ? '' : `${BLOCK_BEGIN}\n${[...entries].sort().join('\n')}\n${BLOCK_END}\n`;
+    const unmanaged = content.replace(pattern, '');
+    const next = block === '' ? unmanaged : unmanaged.replace(/\s*$/u, '\n') + block;
+    if (next === content)
+        return;
     const staging = path.join(path.dirname(exclude), `.mar-git-exclude-${randomUUID()}.tmp`);
     try {
         await writeFile(staging, next, { encoding: 'utf8', flag: 'wx' });

package/dist/service/workspace-upload-service.js

@@ -3,16 +3,17 @@ import { lstat, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
 import { dirname, join, posix, resolve } from 'node:path';
 import { parseComposerAttachmentUpload, validComposerAttachmentName } from '../util/node-operation-parsers.js';
 import { preflightWorkspaceUpload, workspaceUploadTemporaryName } from '../workspace.js';
-import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
 const CHUNK_BYTES = 512 * 1024;
 const TTL_MS = 60 * 60_000;
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 export class WorkspaceUploadService {
     state;
     onCompleted;
-    constructor(state, onCompleted) {
+    temporaryRoot;
+    constructor(state, onCompleted, temporaryRoot) {
         this.state = state;
         this.onCompleted = onCompleted;
+        this.temporaryRoot = temporaryRoot;
     }
     async preflight(workspace, input) {
         if ((input.directory !== undefined && typeof input.directory !== 'string') ||
@@ -47,7 +48,7 @@ export class WorkspaceUploadService {
             throw new Error('COMPOSER_ATTACHMENT_INVALID');
         const target = attachment === undefined
             ? await preflightWorkspaceUpload(workspace.path, typeof input.directory === 'string' ? input.directory : '.', input.name)
-            : await this.attachmentTarget(workspace.path, attachment.id, input.name);
+            : await this.attachmentTarget(attachment.id, input.name);
         if (target.status === 'INVALID_NAME')
             throw new Error('UPLOAD_NAME_INVALID');
         if (target.status === 'EXISTS_DIRECTORY')
@@ -164,14 +165,7 @@ export class WorkspaceUploadService {
         this.state.uploads.delete(upload.id);
         this.onCompleted(upload.workspaceId);
         if (upload.composerAttachment !== undefined) {
-            const attachmentId = upload.composerAttachment.id;
-            const timer = setTimeout(() => {
-                const attachment = this.state.composerAttachments.get(attachmentId);
-                if (attachment !== undefined)
-                    void this.removeCompleted(attachment);
-            }, TTL_MS);
-            timer.unref();
-            this.state.composerAttachments.set(attachmentId, {
+            const attachment = {
                 id: upload.composerAttachment.id,
                 workspaceId: upload.workspaceId,
                 path: upload.path,
@@ -179,8 +173,12 @@ export class WorkspaceUploadService {
                 name: upload.composerAttachment.name,
                 mime: upload.composerAttachment.mime,
                 size: upload.size,
-                timer
-            });
+                expiresAt: Date.now() + TTL_MS,
+                reserved: false,
+                timer: undefined
+            };
+            this.state.composerAttachments.set(attachment.id, attachment);
+            this.scheduleAttachmentExpiry(attachment);
         }
         return {
             uploadId: upload.id,
@@ -198,36 +196,77 @@ export class WorkspaceUploadService {
         const attachment = this.state.composerAttachments.get(uploadId);
         if (attachment === undefined)
             throw new Error('UPLOAD_NOT_FOUND');
+        if (attachment.reserved)
+            throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
         await this.removeCompleted(attachment);
     }
-    async resolve(workspaceId, ids) {
-        return Promise.all(ids.map(async (id) => {
+    async reserve(workspaceId, ids) {
+        if (new Set(ids).size !== ids.length)
+            throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
+        const storedAttachments = ids.map((id) => {
             const stored = this.state.composerAttachments.get(id);
-            if (stored === undefined || stored.workspaceId !== workspaceId)
+            if (stored === undefined || stored.workspaceId !== workspaceId || stored.reserved)
                 throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
-            const metadata = await lstat(stored.targetPath).catch(() => undefined);
-            if (metadata === undefined ||
-                metadata.isSymbolicLink() ||
-                !metadata.isFile() ||
-                metadata.size !== stored.size)
+            return stored;
+        });
+        for (const stored of storedAttachments) {
+            stored.reserved = true;
+            clearTimeout(stored.timer);
+            stored.timer = undefined;
+        }
+        let active = true;
+        const assertReserved = () => {
+            if (!active ||
+                storedAttachments.some((stored) => this.state.composerAttachments.get(stored.id) !== stored))
                 throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
-            const bytes = await readFile(stored.targetPath);
+        };
+        const release = () => {
+            if (!active)
+                return;
+            active = false;
+            for (const stored of storedAttachments) {
+                if (this.state.composerAttachments.get(stored.id) !== stored)
+                    continue;
+                stored.reserved = false;
+                this.scheduleAttachmentExpiry(stored);
+            }
+        };
+        try {
+            const attachments = await Promise.all(storedAttachments.map(async (stored) => {
+                const metadata = await lstat(stored.targetPath).catch(() => undefined);
+                if (metadata === undefined ||
+                    metadata.isSymbolicLink() ||
+                    !metadata.isFile() ||
+                    metadata.size !== stored.size)
+                    throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
+                const bytes = await readFile(stored.targetPath);
+                return {
+                    attachment: {
+                        name: stored.name,
+                        mime: stored.mime,
+                        dataBase64: bytes.toString('base64')
+                    },
+                    path: stored.targetPath,
+                    resourcePath: stored.path
+                };
+            }));
+            assertReserved();
             return {
-                attachment: {
-                    name: stored.name,
-                    mime: stored.mime,
-                    dataBase64: bytes.toString('base64')
+                attachments,
+                commit: (retain) => {
+                    assertReserved();
+                    retain(storedAttachments.map((stored) => dirname(stored.targetPath)));
+                    for (const stored of storedAttachments)
+                        this.state.composerAttachments.delete(stored.id);
+                    active = false;
                 },
-                path: stored.path
+                release
             };
-        }));
-    }
-    async consume(ids) {
-        await Promise.all(ids.map(async (id) => {
-            const attachment = this.state.composerAttachments.get(id);
-            if (attachment !== undefined)
-                await this.removeCompleted(attachment);
-        }));
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
     }
     async shutdown() {
         await Promise.allSettled([...this.state.uploads.values()].map((upload) => this.remove(upload)));
@@ -235,6 +274,12 @@ export class WorkspaceUploadService {
             await this.removeCompleted(attachment);
         this.state.composerAttachments.clear();
     }
+    fileResource(workspaceId, resourcePath) {
+        for (const attachment of this.state.composerAttachments.values())
+            if (attachment.workspaceId === workspaceId && attachment.path === resourcePath)
+                return attachment.targetPath;
+        return undefined;
+    }
     require(id) {
         if (typeof id !== 'string')
             throw new Error('UPLOAD_NOT_FOUND');
@@ -258,12 +303,15 @@ export class WorkspaceUploadService {
         clearTimeout(attachment.timer);
         await rm(dirname(attachment.targetPath), { recursive: true, force: true }).catch(() => undefined);
     }
-    async attachmentTarget(workspacePath, id, name) {
-        await ensureWorkspaceGitExclude(workspacePath);
-        const mar = resolve(workspacePath, '.mar');
-        await mkdir(mar, { recursive: true, mode: 0o700 });
-        await safeDirectory(mar);
-        const temp = join(mar, 'temp-files');
+    scheduleAttachmentExpiry(attachment) {
+        attachment.timer = setTimeout(() => {
+            if (!attachment.reserved)
+                void this.removeCompleted(attachment);
+        }, Math.max(0, attachment.expiresAt - Date.now()));
+        attachment.timer.unref();
+    }
+    async attachmentTarget(id, name) {
+        const temp = this.temporaryRoot();
         await mkdir(temp, { recursive: true, mode: 0o700 });
         await safeDirectory(temp);
         const directory = join(temp, id);
@@ -277,7 +325,7 @@ export class WorkspaceUploadService {
         }
         await safeDirectory(directory);
         return {
-            path: `.mar/temp-files/${id}/${name}`,
+            path: `mar-attachment://${id}/${name}`,
             absolutePath: join(directory, name),
             status: 'READY'
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.10.2",
+    "@myagentroam/agent": "0.10.4",
     "@myagentroam/code-navigation": "0.10.1",
     "@myagentroam/marctl": "0.10.1",
-    "@myagentroam/protocol": "0.10.2"
+    "@myagentroam/protocol": "0.10.4"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"