@myagentroam/node 0.9.176 → 0.9.177

package/dist/connector.js

@@ -1,5 +1,5 @@
 import { dirname, resolve } from 'node:path';
-import { createEnvelope, directNodeCommandSchema } from '@myagentroam/protocol';
+import { createEnvelope, composerVisibleText, directNodeCommandSchema } from '@myagentroam/protocol';
 import { hostedConversationStorePath, loadNodeConfig, computerUseRuntimeExecutable, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
 import { NodeMetrics, nodeLog } from './operational.js';
 import { assertLocalSqlitePath } from './storage.js';
@@ -61,6 +61,7 @@ import { RunnerInteractionService } from './service/runner-interaction-service.j
 import { SessionLifecycleService } from './service/session-lifecycle-service.js';
 import { ExternalSessionResumeService } from './service/external-session-resume-service.js';
 import { SessionMessageService } from './service/session-message-service.js';
+import { composerResourceInputTags } from './service/composer-message-input.js';
 import { SessionScheduleService } from './service/session-schedule-service.js';
 import { ScheduledSessionCoordinator } from './service/scheduled-session-coordinator.js';
 import { ScheduledSessionStore } from './service/scheduled-session-store.js';
@@ -343,6 +344,7 @@ export class NodeConnector {
                 this.publishWorkbenchEvent(category, payload);
         },
         cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
+        refreshAttachments: (sessionId) => this.runAttachmentService.refreshSession(sessionId),
         expireImages: (runId) => this.runAttachmentService.expire(runId),
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
         refreshWorkspaceSessions: (workspaceId) => this.workspaceWorkbenchService.ensureTopicSnapshot(workspaceId, 'sessions'),
@@ -515,7 +517,8 @@ export class NodeConnector {
         this.fakeRunner =
             options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
         this.fakeScript = options.fakeScript;
-        this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoots(session));
+        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.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory, options.codexRunClientFactory);
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
@@ -747,9 +750,15 @@ export class NodeConnector {
         });
         this.continuousRunCoordinator = new ContinuousRunCoordinator({
             runtime: this.runtime,
-            emitQueue: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
+            emitQueue: (workspaceId, sessionId) => {
+                this.runEventBridge.emitQueue(workspaceId, sessionId);
+                this.runAttachmentService.refreshSession(sessionId);
+            },
             clearImages: (runId) => this.runAttachmentService.clear(runId),
-            cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
+            cleanupAttachments: (runId) => {
+                this.runAttachmentService.cleanup(runId);
+                void this.runAttachmentService.discardFiles(runId);
+            },
             migrateAssets: (previousId, nextId) => this.runAttachmentService.move(previousId, nextId),
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitConversation: (turn) => this.emitConversationTurn(turn),
@@ -894,6 +903,9 @@ export class NodeConnector {
         });
         this.sessionIdentityService = new SessionIdentityService({
             runtime: this.runtime,
+            releaseAttachments: (sessionId) => {
+                void this.runAttachmentService.releaseSession(sessionId);
+            },
             persist: (session, nativeSessionId) => {
                 if (session.model === null || session.effort === null || session.access === null)
                     return;
@@ -908,6 +920,7 @@ export class NodeConnector {
             },
             migrateCommands: (previousId, nextId) => this.commandStates.promoteSessionIdentity(previousId, nextId),
             migrateGoal: (previousId, nextId) => {
+                this.runAttachmentService.migrateSession(previousId, nextId);
                 this.goalRuntime.migrateSession(previousId, nextId);
                 this.goalMcpServer.migrateSession(previousId, nextId);
                 const retry = this.goalRetryTimers.get(previousId);
@@ -1076,6 +1089,7 @@ export class NodeConnector {
             coordinator: this.continuousRunCoordinator,
             runners: this.runners,
             resolve: (sessionId) => this.externalSessionResumeService.acceptForMessage(sessionId),
+            workspacePath: (workspaceId) => this.database?.getWorkspace(workspaceId)?.path,
             present: (session) => this.sessionPresentationService.present(session),
             emitSession: (session) => this.emitSessionWorkbenchEvent({
                 session: this.sessionPresentationService.present(session)
@@ -1106,8 +1120,11 @@ export class NodeConnector {
                         activated: false
                     };
                 }
+                const objective = composerVisibleText(content);
+                if (objective.length === 0)
+                    return undefined;
                 this.invalidateGoalContinuation(session.id);
-                const goal = this.goalRuntime.start(session.id, content);
+                const goal = this.goalRuntime.start(session.id, objective, composerResourceInputTags(content));
                 this.publishGoalState(session, goal);
                 return {
                     runnerContent: this.goalRuntime.prompt(session.id, 'start'),
@@ -1144,7 +1161,10 @@ export class NodeConnector {
             present: (session) => this.sessionPresentationService.present(session),
             projectionForNative: (session) => this.nativeSessionProjectionService.projectionForNative(session),
             nativeIds: (session) => this.nativeSessionProjectionService.nativeIds(session),
-            forget: (session, nativeIds) => this.nativeSessionProjectionService.forget(session, nativeIds),
+            forget: (session, nativeIds) => {
+                this.nativeSessionProjectionService.forget(session, nativeIds);
+                void this.runAttachmentService.releaseSession(session.id);
+            },
             refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
             externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
             isWatching: (sessionId) => this.nativeSessionWatchService.isWatching(sessionId),

package/dist/runner/codex/conversation-parser.js

@@ -3,7 +3,7 @@ import { runnerErrorProjection } from '../../util/runner-error.js';
 import { conversationImageAttachmentSchema } from '@myagentroam/protocol';
 import { parseCodexComposerImageMarkers } from './composer-image-markers.js';
 import { normalizeCodexTool } from './tool-normalizer.js';
-import { stripGoalStartPrompt } from '../../service/goal-runtime.js';
+import { publicGoalHistoryText } from '../../service/goal-runtime.js';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
 const MAX_ASSISTANT_MESSAGE_CHARACTERS = 64 * 1024;
@@ -529,7 +529,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
         completedAt
     };
     if (value.type === 'userMessage') {
-        const text = stripGoalStartPrompt(codexContentText(value.content));
+        const text = publicGoalHistoryText(codexContentText(value.content));
         const hasImage = Array.isArray(value.content) &&
             value.content.some((part) => isPlainRecord(part) &&
                 (part.type === 'image' ||

package/dist/runner/opencode/conversation-parser.js

@@ -1,5 +1,5 @@
 import { boundedConversationItemId, compactRunnerText } from '../codex/conversation-parser.js';
-import { stripGoalStartPrompt } from '../../service/goal-runtime.js';
+import { publicGoalHistoryText } from '../../service/goal-runtime.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 export function openCodeUserMessagePreview(messages) {
     for (const message of messages) {
@@ -21,7 +21,7 @@ export function openCodeUserMessagePreview(messages) {
                 : [];
         })
             .join('\n');
-        const preview = stripGoalStartPrompt(text).trim().replace(/\s+/gu, ' ').slice(0, 160);
+        const preview = publicGoalHistoryText(text).trim().replace(/\s+/gu, ' ').slice(0, 160);
         if (preview)
             return preview;
     }
@@ -75,9 +75,9 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
     const localUser = managed?.items.find((item) => item.kind === 'user_message');
     if (localUser !== undefined)
         items.push({ ...localUser, turnId: managed.id });
-    else if (stripGoalStartPrompt(userText).length > 0)
+    else if (publicGoalHistoryText(userText).length > 0)
         items.push(item(session, nativeTurnId, `user-${nativeTurnId}`, 'user_message', 'COMPLETED', {
-            text: compactRunnerText(stripGoalStartPrompt(userText), 20_000),
+            text: compactRunnerText(publicGoalHistoryText(userText), 20_000),
             attachments: []
         }, startedAt, startedAt, sequence));
     for (const part of compactionParts) {

package/dist/runtime-state.js

@@ -525,10 +525,12 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(item.sessionId);
         return next;
     }
-    updateQueueItemAttachments(itemId, attachments) {
+    updateQueueItemAttachments(itemId, attachments, content) {
         const item = this.requireQueueItem(itemId);
-        const next = { ...item, attachments };
+        const next = { ...item, attachments, ...(content === undefined ? {} : { content }) };
         this.queueItems.set(itemId, next);
+        if (content !== undefined && content !== item.content)
+            this.bumpQueueVersion(item.sessionId);
         return next;
     }
     deleteQueueItem(itemId) {
@@ -1224,7 +1226,9 @@ export class NodeRuntimeState {
     }
     projectMessageAttachments(runId, attachments) {
         let imageIndex = 0;
-        return attachments.map(({ name, mime, dataBase64 }) => {
+        return attachments
+            .filter(({ mime }) => mime.startsWith('image/'))
+            .map(({ name, mime, dataBase64 }) => {
             const attachment = {
                 name,
                 mime,

package/dist/service/attachment-domain-state.js

@@ -1,6 +1,8 @@
 export class AttachmentDomainState {
     runDirectories = new Map();
     runFileDirectories = new Map();
+    runFileSessions = new Map();
+    sessionRetentions = new Map();
     runImages = new Map();
     nativeHistoryImages = new Map();
     nativeHistoryImageTimers = new Map();

package/dist/service/composer-message-input.js

@@ -0,0 +1,50 @@
+import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
+import { relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { SkillDirectoryService } from './skill-directory-service.js';
+export function composerResourceInputTags(input) {
+    return parseComposerTags(input)
+        .filter((part) => part.kind === 'mar_skills' ||
+        part.kind === 'mar_references' ||
+        part.kind === 'mar_attachments')
+        .map((part) => part.raw)
+        .join('\n');
+}
+/** Product references keep their Workspace identity while tools use the Session's cwd. */
+export function prepareComposerResourceInput(input, cwd, workspacePath) {
+    return parseComposerTags(input)
+        .map((part) => {
+        if (part.kind === 'text')
+            return part.text;
+        if (part.kind !== 'mar_references')
+            return part.raw;
+        return serializeComposerTag('mar_references', {
+            references: part.payload.references.map((reference) => ({
+                ...reference,
+                runnerPath: relative(cwd, resolve(workspacePath, reference.path)).replaceAll('\\', '/')
+            }))
+        });
+    })
+        .join('');
+}
+/** Recheck selection identity, without loading Skill content into the message or granting access. */
+export async function validateComposerSkills(input, workspacePath, home = homedir()) {
+    const selected = parseComposerTags(input).flatMap((part) => part.kind === 'mar_skills' ? part.payload.skills : []);
+    if (selected.length === 0)
+        return;
+    const directories = new SkillDirectoryService();
+    const [node, workspace] = await Promise.all([
+        directories.inspectNodeHome(home),
+        directories.inspectWorkspace(workspacePath)
+    ]);
+    const effective = new Map(node.skills.map((skill) => [skill.name, { ...skill, source: 'NODE_HOME' }]));
+    for (const skill of workspace.skills)
+        effective.set(skill.name, { ...skill, source: 'WORKSPACE' });
+    for (const skill of selected) {
+        const current = effective.get(skill.name);
+        if (current === undefined ||
+            current.source !== skill.source ||
+            resolve(workspacePath, skill.path) !== resolve(current.skillFilePath))
+            throw new Error('MESSAGE_INVALID');
+    }
+}

package/dist/service/continuous-run-coordinator.js

@@ -1,5 +1,6 @@
 import { withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
 import { safeErrorCode } from '../util/safe-error.js';
+import { prepareComposerResourceInput } from './composer-message-input.js';
 export class ContinuousRunCoordinator {
     options;
     preparedInputs = new Map();
@@ -181,7 +182,11 @@ export class ContinuousRunCoordinator {
         const pending = this.preparedInputs.get(itemId);
         if (pending === undefined)
             return;
-        this.preparedInputs.set(itemId, { ...pending, input });
+        const resources = prepareComposerResourceInput(input, pending.cwd, pending.workspacePath ?? pending.cwd);
+        this.preparedInputs.set(itemId, {
+            ...pending,
+            input: withNonImageAttachmentPrompt(resources, pending.attachmentPaths, pending.attachmentFiles)
+        });
     }
     deleteQueueItem(itemId) {
         const item = this.options.runtime.getQueueItem(itemId);
@@ -275,7 +280,7 @@ export class ContinuousRunCoordinator {
                 return;
             }
             this.prioritizeNextQueueItem(sessionId, itemId);
-            if (this.options.runtime.claimNextQueueItem(sessionId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths)) === undefined)
+            if (this.options.runtime.claimNextQueueItem(sessionId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths, pending.attachmentFiles)) === undefined)
                 return;
             const execution = this.options.runtime.createExecution(active.id);
             executionId = execution.id;
@@ -466,7 +471,7 @@ export class ContinuousRunCoordinator {
             return;
         }
         this.prioritizeNextQueueItem(sessionId, itemId);
-        const { run, turn } = this.options.runtime.startRunFromQueueItem(itemId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths));
+        const { run, turn } = this.options.runtime.startRunFromQueueItem(itemId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths, pending.attachmentFiles));
         this.immediateQueueItems.delete(itemId);
         this.preparedInputs.delete(itemId);
         this.preparedInputs.set(run.id, { ...pending, runId: run.id });

package/dist/service/conversation-history-service.js

@@ -739,16 +739,19 @@ function sameConversationTurn(left, right) {
     if (left.id === right.id)
         return true;
     const leftMessageId = conversationClientMessageId(left);
-    if (leftMessageId !== null)
-        return leftMessageId === conversationClientMessageId(right);
-    if (left.userItemId !== null || right.userItemId !== null)
+    const rightMessageId = conversationClientMessageId(right);
+    if (leftMessageId !== null && rightMessageId !== null)
+        return leftMessageId === rightMessageId;
+    if (left.userItemId !== null && right.userItemId !== null)
         return false;
-    // Item-only live Turns have no input receipt. Runtime namespaces the stable
-    // Runner Item identity by Run, so reconcile it with the unprefixed history Item.
+    // Runtime namespaces stable Runner Items by Run. A failure before input
+    // persistence can leave an error-only native Turn and a local user Turn.
     const [native, local] = left.runId === null ? [left, right] : [right, left];
     if (native.runId !== null || local.runId === null)
         return false;
-    return native.items.some((item) => local.items.some((candidate) => candidate.kind === item.kind && candidate.id === `${local.runId}:${item.id}`));
+    return native.items.some((item) => local.items.some((candidate) => candidate.kind === item.kind &&
+        candidate.id === `${local.runId}:${item.id}` &&
+        ((native.userItemId === null && local.userItemId === null) || item.kind === 'error')));
 }
 function terminalConversationTurn(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);

package/dist/service/goal-runtime.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
 export function goalUnrestrictedAccess(runner) {
     if (runner === 'codex' || runner === 'mar-agent')
         return 'full-access';
@@ -10,34 +11,15 @@ const START_OPEN = '<mar_goal_start>';
 const START_CLOSE = '</mar_goal_start>';
 const CONTINUE_OPEN = '<mar_goal_continue>';
 const CONTINUE_CLOSE = '</mar_goal_continue>';
-const LEGACY_START_OPEN = '<mar_mission_start>';
-const LEGACY_START_CLOSE = '</mar_mission_start>';
-const LEGACY_CONTINUE_OPEN = '<mar_mission_continue>';
-const LEGACY_CONTINUE_CLOSE = '</mar_mission_continue>';
 function goalPromptTags(text) {
     if (text.startsWith(START_OPEN))
-        return { open: START_OPEN, close: START_CLOSE, legacy: false, continuation: false };
+        return { open: START_OPEN, close: START_CLOSE, continuation: false };
     if (text.startsWith(CONTINUE_OPEN))
-        return { open: CONTINUE_OPEN, close: CONTINUE_CLOSE, legacy: false, continuation: true };
-    if (text.startsWith(LEGACY_START_OPEN))
-        return {
-            open: LEGACY_START_OPEN,
-            close: LEGACY_START_CLOSE,
-            legacy: true,
-            continuation: false
-        };
-    if (text.startsWith(LEGACY_CONTINUE_OPEN))
-        return {
-            open: LEGACY_CONTINUE_OPEN,
-            close: LEGACY_CONTINUE_CLOSE,
-            legacy: true,
-            continuation: true
-        };
+        return { open: CONTINUE_OPEN, close: CONTINUE_CLOSE, continuation: true };
     return undefined;
 }
 export function publicGoalStartText(objective) {
-    const normalized = objective.trim();
-    return normalized.length === 0 ? 'Goal Start' : `Goal Start\n${normalized}`;
+    return serializeComposerTag('mar_goal_start', { objective: objective.trim() });
 }
 export function stripGoalStartPrompt(text) {
     const tags = goalPromptTags(text);
@@ -50,25 +32,20 @@ export function publicGoalHistoryText(text) {
     const tags = goalPromptTags(text);
     if (tags === undefined)
         return text;
+    const safe = parseComposerTags(text)[0];
+    if (safe?.kind === 'mar_goal_start' || safe?.kind === 'mar_goal_continue')
+        return text;
     const stripped = stripGoalStartPrompt(text);
-    if (stripped.length > 0)
-        return stripped;
     if (tags.continuation)
-        return tags.legacy ? 'Mission Continue' : 'Goal Continue';
+        return [serializeComposerTag('mar_goal_continue', {}), stripped].filter(Boolean).join('\n');
     const close = text.lastIndexOf(tags.close);
     const prompt = close === -1 ? text : text.slice(0, close);
     const objectiveStart = prompt.indexOf('\nOriginal objective:\n');
-    const objectiveEnd = prompt.lastIndexOf(tags.legacy
-        ? '\n\nContinue executing this Mission across turns:'
-        : '\n\nContinue executing this Goal across turns:');
+    const objectiveEnd = prompt.lastIndexOf('\n\nContinue executing this Goal across turns:');
     const objective = objectiveStart === -1 || objectiveEnd === -1
         ? ''
         : prompt.slice(objectiveStart + '\nOriginal objective:\n'.length, objectiveEnd);
-    return tags.legacy
-        ? objective.trim().length === 0
-            ? 'Mission Start'
-            : `Mission Start\n${objective.trim()}`
-        : publicGoalStartText(objective);
+    return [publicGoalStartText(objective), stripped].filter(Boolean).join('\n');
 }
 export class GoalRuntime {
     changed;
@@ -96,17 +73,19 @@ export class GoalRuntime {
             this.executionFailures.set(nextId, failures);
         }
     }
-    start(sessionId, objective) {
+    start(sessionId, objective, inputTags) {
         const normalized = objective.trim();
         if (normalized.length === 0 || normalized.length > 20_000)
             throw new Error('GOAL_OBJECTIVE_INVALID');
         const current = this.goals.get(sessionId);
         const continuing = current?.status === 'active';
+        const selectedInputTags = inputTags ?? (continuing ? current?.inputTags : undefined);
         const now = this.now();
         const goal = {
             id: continuing ? current.id : randomUUID(),
             sessionId,
             objective: normalized,
+            ...(selectedInputTags ? { inputTags: selectedInputTags } : {}),
             startedAt: continuing ? current.startedAt : now,
             revisionStartedAt: now,
             revision: continuing ? current.revision + 1 : 1,
@@ -245,7 +224,7 @@ export class GoalRuntime {
         const heading = kind === 'start' ? 'A Goal has started or changed.' : 'Continue the active Goal.';
         const open = kind === 'start' ? START_OPEN : CONTINUE_OPEN;
         const close = kind === 'start' ? START_CLOSE : CONTINUE_CLOSE;
-        return `${open}\n${heading}\n\nOriginal objective:\n${goal.objective}\n\nContinue executing this Goal across turns:\n- This Goal is owned by the Node's myagentroam_goal MCP server. Prefer myagentroam_goal.mar_update_goal to complete it. In Codex, a runner-native Goal created during this Goal may also complete it when Codex reports that native Goal complete; native Goal state from another task or turn does not count. Do not claim completion based only on a final message or an unrelated Goal.\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call mar_update_goal with status=completed when available.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use mar_get_goal only when you need to reread the authoritative objective or status.\n- After mar_update_goal confirms completed or finally blocked, summarize the completed work, verification evidence, remaining issues, and the tool-reported elapsedWallMs converted from milliseconds into a concise readable duration in your final user-facing response. If Codex instead confirms completion with its native Goal, summarize the work without claiming a MAR elapsedWallMs value. Name whether the Goal completed or is finally blocked. MAR elapsedWallMs includes waiting and retries through the status update, not tool execution time or the final response. If blocked returns active for the required retry, continue work instead of claiming a final summary.\n${close}`;
+        return `${open}\n${heading}\n\nOriginal objective:\n${goal.objective}\n\nContinue executing this Goal across turns:\n- This Goal is owned by the Node's myagentroam_goal MCP server. Prefer myagentroam_goal.mar_update_goal to complete it. In Codex, a runner-native Goal created during this Goal may also complete it when Codex reports that native Goal complete; native Goal state from another task or turn does not count. Do not claim completion based only on a final message or an unrelated Goal.\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call mar_update_goal with status=completed when available.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use mar_get_goal only when you need to reread the authoritative objective or status.\n- After mar_update_goal confirms completed or finally blocked, summarize the completed work, verification evidence, remaining issues, and the tool-reported elapsedWallMs converted from milliseconds into a concise readable duration in your final user-facing response. If Codex instead confirms completion with its native Goal, summarize the work without claiming a MAR elapsedWallMs value. Name whether the Goal completed or is finally blocked. MAR elapsedWallMs includes waiting and retries through the status update, not tool execution time or the final response. If blocked returns active for the required retry, continue work instead of claiming a final summary.\n${close}${goal.inputTags ? `\n${goal.inputTags}` : ''}`;
     }
     requireCurrent(sessionId, goalId, revision) {
         const current = this.goals.get(sessionId);

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

@@ -7,24 +7,162 @@ import { AttachmentDomainState } from './attachment-domain-state.js';
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const IMAGE_CACHE_TTL_MS = 60 * 60_000;
 const NATIVE_IMAGE_SOURCE_TTL_MS = 60 * 60_000;
+const SESSION_ATTACHMENT_IDLE_TTL_MS = 30 * 60_000;
 export class RunAttachmentService {
     nativeImageRoots;
+    sessionIsBusy;
     state = new AttachmentDomainState();
-    constructor(nativeImageRoots) {
+    disposed = false;
+    constructor(nativeImageRoots, sessionIsBusy = () => false) {
         this.nativeImageRoots = nativeImageRoots;
+        this.sessionIsBusy = sessionIsBusy;
+    }
+    protectSession(sessionId) {
+        this.assertOpen();
+        const retained = this.sessionRetention(sessionId);
+        retained.protections += 1;
+        this.stopSessionTimer(retained);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const current = this.state.sessionRetentions.get(retained.sessionId);
+            if (current === undefined)
+                return;
+            current.protections -= 1;
+            this.refreshSession(current.sessionId);
+        };
+    }
+    acceptSessionInput(sessionId) {
+        const retained = this.state.sessionRetentions.get(sessionId);
+        if (retained === undefined)
+            return;
+        this.stopSessionTimer(retained);
+        retained.deadline = undefined;
+        this.refreshSession(sessionId);
+    }
+    retainSessionFiles(sessionId, runId) {
+        this.assertOpen();
+        if (!this.state.runFileDirectories.has(runId))
+            return;
+        const retained = this.sessionRetention(sessionId);
+        retained.runs.add(runId);
+        this.state.runFileSessions.set(runId, sessionId);
+        this.refreshSession(sessionId);
+    }
+    refreshSession(sessionId) {
+        if (this.disposed)
+            return;
+        const retained = this.state.sessionRetentions.get(sessionId);
+        if (retained === undefined)
+            return;
+        this.stopSessionTimer(retained);
+        if (retained.protections > 0)
+            return;
+        if (this.sessionIsBusy(sessionId)) {
+            retained.deadline = undefined;
+            return;
+        }
+        if (retained.runs.size === 0) {
+            this.state.sessionRetentions.delete(sessionId);
+            return;
+        }
+        retained.deadline ??= Date.now() + SESSION_ATTACHMENT_IDLE_TTL_MS;
+        const timer = setTimeout(async () => {
+            if (this.state.sessionRetentions.get(sessionId) !== retained || retained.timer !== timer)
+                return;
+            retained.timer = undefined;
+            if (retained.protections > 0 || this.sessionIsBusy(sessionId)) {
+                this.refreshSession(sessionId);
+                return;
+            }
+            await this.releaseSession(sessionId);
+        }, Math.max(0, retained.deadline - Date.now()));
+        timer.unref();
+        retained.timer = timer;
+    }
+    migrateSession(previousId, nextId) {
+        if (previousId === nextId)
+            return;
+        const previous = this.state.sessionRetentions.get(previousId);
+        if (previous === undefined)
+            return;
+        this.stopSessionTimer(previous);
+        const existing = this.state.sessionRetentions.get(nextId);
+        if (existing !== undefined) {
+            this.stopSessionTimer(existing);
+            for (const runId of previous.runs)
+                existing.runs.add(runId);
+            existing.protections += previous.protections;
+            existing.deadline = Math.max(existing.deadline ?? 0, previous.deadline ?? 0) || undefined;
+        }
+        else
+            this.state.sessionRetentions.set(nextId, previous);
+        previous.sessionId = nextId;
+        this.state.sessionRetentions.delete(previousId);
+        for (const runId of previous.runs)
+            this.state.runFileSessions.set(runId, nextId);
+        this.refreshSession(nextId);
+    }
+    async discardFiles(runId) {
+        const directory = this.state.runFileDirectories.get(runId);
+        this.state.runFileDirectories.delete(runId);
+        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);
+    }
+    async releaseSession(sessionId) {
+        const retained = this.state.sessionRetentions.get(sessionId);
+        if (retained === undefined)
+            return;
+        this.stopSessionTimer(retained);
+        this.state.sessionRetentions.delete(sessionId);
+        await Promise.all([...retained.runs].map((runId) => this.discardFiles(runId)));
+    }
+    sessionRetention(sessionId) {
+        const existing = this.state.sessionRetentions.get(sessionId);
+        if (existing !== undefined)
+            return existing;
+        const retained = {
+            sessionId,
+            runs: new Set(),
+            protections: 0,
+            deadline: undefined,
+            timer: undefined
+        };
+        this.state.sessionRetentions.set(sessionId, retained);
+        return retained;
+    }
+    assertOpen() {
+        if (this.disposed)
+            throw new Error('NODE_STOPPED');
+    }
+    stopSessionTimer(retained) {
+        if (retained.timer !== undefined)
+            clearTimeout(retained.timer);
+        retained.timer = undefined;
     }
     async materializeCodex(runId, attachments) {
         if (attachments.length === 0)
             return [];
+        this.assertOpen();
         const directory = await mkdtemp(join(tmpdir(), 'myagentroam-attachment-'));
         this.state.runDirectories.set(runId, directory);
         try {
+            this.assertOpen();
             const inputs = await Promise.all(attachments.map(async (attachment, index) => {
                 const extension = attachment.mime.slice('image/'.length).replace('jpeg', 'jpg');
                 const path = join(directory, `${index + 1}.${extension}`);
                 await writeFile(path, Buffer.from(attachment.dataBase64, 'base64'), { mode: 0o600 });
                 return { type: 'localImage', path };
             }));
+            this.assertOpen();
             const cached = this.state.runImages.get(runId);
             if (cached !== undefined)
                 cached.localPaths = inputs.map((input) => input.path);
@@ -38,6 +176,7 @@ export class RunAttachmentService {
     async persistFiles(workspacePath, 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);
@@ -52,7 +191,9 @@ export class RunAttachmentService {
         await mkdir(runDirectory, { mode: 0o700 });
         this.state.runFileDirectories.set(runId, runDirectory);
         try {
+            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}`);
         }
         catch (error) {
@@ -67,15 +208,13 @@ export class RunAttachmentService {
             this.state.runDirectories.delete(runId);
             void rm(directory, { recursive: true, force: true }).catch(() => undefined);
         }
-        const fileDirectory = this.state.runFileDirectories.get(runId);
-        if (fileDirectory !== undefined) {
-            this.state.runFileDirectories.delete(runId);
-            void rm(fileDirectory, { recursive: true, force: true }).catch(() => undefined);
-        }
+        if (!this.state.runFileSessions.has(runId))
+            void this.discardFiles(runId);
     }
     cache(runId, images) {
         if (images.length === 0)
             return;
+        this.assertOpen();
         this.clear(runId);
         this.state.runImages.set(runId, {
             images,
@@ -100,6 +239,14 @@ export class RunAttachmentService {
             this.state.runFileDirectories.delete(previousId);
             this.state.runFileDirectories.set(nextId, fileDirectory);
         }
+        const sessionId = this.state.runFileSessions.get(previousId);
+        if (sessionId !== undefined) {
+            this.state.runFileSessions.delete(previousId);
+            this.state.runFileSessions.set(nextId, sessionId);
+            const retained = this.state.sessionRetentions.get(sessionId);
+            retained?.runs.delete(previousId);
+            retained?.runs.add(nextId);
+        }
     }
     append(runId, images) {
         if (images.length === 0)
@@ -306,6 +453,11 @@ export class RunAttachmentService {
         this.state.runImages.delete(runId);
     }
     dispose() {
+        this.disposed = true;
+        for (const retained of this.state.sessionRetentions.values())
+            this.stopSessionTimer(retained);
+        this.state.sessionRetentions.clear();
+        this.state.runFileSessions.clear();
         for (const runId of new Set([
             ...this.state.runDirectories.keys(),
             ...this.state.runFileDirectories.keys()

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

@@ -117,6 +117,8 @@ export class RunEventService {
         }
         if (eventType === 'run.started' || eventType === 'run.running')
             this.options.executionStarted?.(executionId);
+        if (!terminalExecution)
+            this.options.refreshAttachments?.(run.sessionId);
         let finalStatus;
         let manuallyInterrupted = false;
         if (terminalCurrentExecution) {
@@ -199,6 +201,7 @@ export class RunEventService {
         this.options.onTerminalRun?.(run, finalStatus);
         const idleSnapshot = this.options.refreshWorkspaceSessions(run.workspaceId);
         this.options.runtime.removeTerminalRun(runId);
+        this.options.refreshAttachments?.(run.sessionId);
         if (terminalNotification)
             void idleSnapshot
                 .catch(() => undefined)

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

@@ -59,6 +59,8 @@ export class SessionIdentityService {
         return promise;
     }
     reject(sessionId, code) {
+        if (this.bootstrapIds.has(sessionId))
+            this.options.releaseAttachments?.(sessionId);
         const waiter = this.waiters.get(sessionId);
         if (waiter === undefined)
             return;

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

@@ -153,7 +153,8 @@ export class SessionLifecycleService {
         if (typeof input.clientMessageId !== 'string' ||
             input.clientMessageId.length === 0 ||
             typeof input.content !== 'string' ||
-            input.content.length === 0)
+            (input.content.length === 0 &&
+                !(Array.isArray(input.attachmentIds) && input.attachmentIds.length > 0)))
             throw new Error('MESSAGE_INVALID');
         if (input.deferredCommands !== undefined &&
             (!Array.isArray(input.deferredCommands) ||

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

@@ -4,6 +4,9 @@ import { parseSecretEnvironment } from '../util/secret-environment.js';
 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 { prepareComposerResourceInput, composerResourceInputTags, validateComposerSkills } from './composer-message-input.js';
 const INTERNAL_GOAL = Symbol('internalGoal');
 const INTERNAL_SCHEDULE = Symbol('internalSchedule');
 export class SessionMessageService {
@@ -24,7 +27,9 @@ export class SessionMessageService {
             [INTERNAL_GOAL]: true,
             sessionId: input.sessionId,
             clientMessageId: `goal:${randomUUID()}`,
-            content: input.kind === 'start' ? publicGoalStartText(input.objective ?? '') : 'Goal Continue',
+            content: input.kind === 'start'
+                ? publicGoalStartText(input.objective ?? '')
+                : serializeComposerTag('mar_goal_continue', {}),
             __runnerContent: input.content,
             __goalRef: input.goal,
             ...(input.initiatedByUserId === undefined
@@ -45,7 +50,7 @@ export class SessionMessageService {
             sessionId: input.sessionId,
             clientMessageId: input.occurrenceId,
             content: input.objective,
-            __runnerContent: `Scheduled task execution:\n${input.objective}`,
+            __runnerContent: serializeComposerTag('mar_schedule', { objective: input.objective }),
             __requestUserId: input.initiatedByUserId,
             deliveryIntent: 'SEND',
             secretEnvironment: input.secretEnvironment,
@@ -61,7 +66,9 @@ export class SessionMessageService {
             typeof input.clientMessageId !== 'string' ||
             input.clientMessageId.length === 0 ||
             typeof input.content !== 'string' ||
-            input.content.length === 0)
+            (input.content.length === 0 &&
+                !(Array.isArray(input.attachmentIds) && input.attachmentIds.length > 0) &&
+                !(Array.isArray(input.attachments) && input.attachments.length > 0)))
             throw new Error('MESSAGE_INVALID');
         const clientMessageId = input.clientMessageId;
         const content = input.content;
@@ -106,8 +113,13 @@ export class SessionMessageService {
             ? undefined
             : this.options.goalMessage(session, content, requestedIntent);
         const runnerContent = goalMessage?.runnerContent ?? internalRunnerContent;
-        const publicContent = goalMessage?.activated === true ? publicGoalStartText(content) : content;
+        const publicContent = goalMessage?.activated === true
+            ? [publicGoalStartText(composerVisibleText(content)), composerResourceInputTags(content)]
+                .filter(Boolean)
+                .join('\n')
+            : content;
         const intent = goalMessage?.activated === true ? 'REPLACE_CURRENT' : requestedIntent;
+        const releasePreparation = this.options.attachments.protectSession(session.id);
         const operation = (async () => {
             const acceptedSession = accepted.session;
             const session = this.options.runtime.getAgentSession(acceptedSession.id) ?? acceptedSession;
@@ -144,9 +156,21 @@ export class SessionMessageService {
                         : uploaded.map((attachment) => attachment.attachment);
                     const imageAttachments = attachments.filter(isImageAttachment);
                     const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
-                    const attachmentPaths = await this.persistAttachments(currentSession, runId, attachments);
-                    const displayInput = withNonImageAttachmentPrompt(publicContent, attachmentPaths);
-                    const runnerInput = withNonImageAttachmentPrompt(runnerContent, attachmentPaths);
+                    const workspacePath = this.options.workspacePath?.(currentSession.workspaceId) ?? currentSession.cwd;
+                    await validateComposerSkills(runnerContent, workspacePath);
+                    const attachmentPaths = await this.persistAttachments(currentSession, submissionId, attachments);
+                    const attachmentFiles = attachments.map((attachment, index) => ({
+                        name: attachment.name,
+                        mime: attachment.mime,
+                        path: attachmentPaths[index]
+                    }));
+                    const runnerFiles = attachmentFiles.map((file) => {
+                        const path = relative(currentSession.cwd, resolve(workspacePath, file.path)).replaceAll('\\', '/');
+                        return path === file.path ? file : { ...file, path, workspacePath: file.path };
+                    });
+                    const displayInput = withNonImageAttachmentPrompt(publicContent, attachmentPaths, attachmentFiles);
+                    const resourceInput = prepareComposerResourceInput(runnerContent, currentSession.cwd, workspacePath);
+                    const runnerInput = withNonImageAttachmentPrompt(resourceInput, attachmentPaths, runnerFiles);
                     const planActive = this.options.commands
                         .list(session.id)
                         .some((state) => state.commandId === 'plan');
@@ -157,7 +181,7 @@ export class SessionMessageService {
                             this.options.coordinator.publishCurrentTurn(created.run.id);
                     }
                     else
-                        this.options.runtime.updateQueueItemAttachments(created.queueItem.id, attachments);
+                        this.options.runtime.updateQueueItemAttachments(created.queueItem.id, attachments, displayInput);
                     this.options.coordinator.prepare(submissionId, {
                         runId,
                         sessionId: currentSession.id,
@@ -167,7 +191,9 @@ export class SessionMessageService {
                         clientMessageId,
                         attachments: runnerImageAttachments,
                         attachmentPaths,
+                        attachmentFiles: runnerFiles,
                         cwd: currentSession.cwd,
+                        workspacePath,
                         externalSessionId: currentSession.externalSessionId,
                         model: currentSession.model,
                         effort: currentSession.effort,
@@ -195,12 +221,14 @@ export class SessionMessageService {
                     if (goalMessage !== undefined &&
                         !this.options.prepareGoalInsertion(session.id, submissionId, goalMessage.goal))
                         throw new Error('GOAL_REVISION_STALE');
+                    this.options.attachments.retainSessionFiles(currentSession.id, submissionId);
                     const delivery = this.options.coordinator.settle({
                         submissionId,
                         intent,
                         queueBefore: queueBeforeCreate,
                         ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })
                     });
+                    this.options.attachments.acceptSessionInput(currentSession.id);
                     void this.options.uploads.consume(attachmentIds).catch(() => undefined);
                     return delivery;
                 }
@@ -210,6 +238,7 @@ export class SessionMessageService {
                     this.options.coordinator.failPreparation(submissionId, safeErrorCode(error, 'MESSAGE_PREPARATION_FAILED'));
                     this.options.attachments.clear(submissionId);
                     this.options.attachments.cleanup(submissionId);
+                    await this.options.attachments.discardFiles(submissionId);
                     throw error;
                 }
             };
@@ -228,12 +257,13 @@ export class SessionMessageService {
             return await operation;
         }
         finally {
+            releasePreparation();
             if (this.pendingMessages.get(pendingKey) === operation)
                 this.pendingMessages.delete(pendingKey);
         }
     }
     async persistAttachments(session, runId, attachments) {
-        return this.options.attachments.persistFiles(session.cwd, runId, attachments.filter((attachment) => !isRunnerImageAttachment(attachment)));
+        return this.options.attachments.persistFiles(this.options.workspacePath?.(session.workspaceId) ?? session.cwd, runId, attachments);
     }
     async channelMessage(input) {
         if (typeof input.sessionId !== 'string' ||

package/dist/service/workspace-queue-workbench-service.js

@@ -107,7 +107,7 @@ export class WorkspaceQueueWorkbenchService {
         this.options.runtime.updateQueueItem(item.id, content);
         const prepared = this.options.coordinator.pending(item.id);
         if (prepared !== undefined) {
-            const runnerInput = withNonImageAttachmentPrompt(content, prepared.attachmentPaths);
+            const runnerInput = withNonImageAttachmentPrompt(content, prepared.attachmentPaths, prepared.attachmentFiles);
             this.options.coordinator.updatePreparedInput(item.id, this.options.prepareInput(prepared.runner, runnerInput, prepared.collaborationMode));
         }
         this.options.emit(item.workspaceId, item.sessionId);

package/dist/util/node-operation-parsers.js

@@ -1,8 +1,7 @@
-import { nodeCapabilitiesSchema } from '@myagentroam/protocol';
+import { nodeCapabilitiesSchema, serializeComposerTag, parseComposerTags, composerVisibleText } from '@myagentroam/protocol';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
 const USER_AUTHORIZATION_CLOCK_SKEW_MS = 60 * 60 * 1_000;
-const NON_IMAGE_ATTACHMENT_PROMPT_PREFIX = '\n\nAttachments available in the Workspace:\n';
 const COMPOSER_IMAGE_MIME_TYPES = new Set([
     'image/png',
     'image/jpeg',
@@ -243,7 +242,7 @@ export function validSessionTitle(value) {
         (typeof value === 'string' && value.trim().length > 0 && value.length <= 160));
 }
 export function sessionTitleFromFirstMessage(content) {
-    return content.trim().replace(/\s+/g, ' ').slice(0, 160);
+    return composerVisibleText(content).replace(/\s+/g, ' ').slice(0, 160);
 }
 export function parseComposerAttachmentUpload(input) {
     if (input.composerAttachmentId === undefined && input.mime === undefined)
@@ -323,12 +322,24 @@ export function isRunnerImageAttachment(attachment) {
 export function isImageAttachment(attachment) {
     return attachment.mime.startsWith('image/');
 }
-export function withNonImageAttachmentPrompt(input, paths) {
+export function withNonImageAttachmentPrompt(input, paths, files) {
     if (paths.length === 0)
         return input;
-    return `${input}${NON_IMAGE_ATTACHMENT_PROMPT_PREFIX}${paths
-        .map((path) => `- ${path}`)
-        .join('\n')}`;
+    const tag = serializeComposerTag('mar_attachments', {
+        files: files
+            ? [...files]
+            : paths.map((path) => ({
+                name: path.split(/[\\/]/u).at(-1),
+                mime: 'application/octet-stream',
+                path
+            }))
+    });
+    const body = parseComposerTags(input)
+        .filter((part) => part.kind !== 'mar_attachments')
+        .map((part) => (part.kind === 'text' ? part.text : part.raw))
+        .join('')
+        .trimEnd();
+    return `${body}\n${tag}`;
 }
 export function isCanonicalBase64(value) {
     return value.length > 0 && value.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);

package/dist/util/runner-native-session-parsers.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { stripClaudePlanTag } from '../runner-command-engine.js';
-import { stripGoalStartPrompt } from '../service/goal-runtime.js';
+import { publicGoalHistoryText } from '../service/goal-runtime.js';
 import { parseCodexComposerImageMarkers } from '../runner/codex/composer-image-markers.js';
 import { normalizeCodexTool } from '../runner/codex/tool-normalizer.js';
 import { normalizeClaudeTool } from '../runner/claude/tool-normalizer.js';
@@ -452,8 +452,8 @@ function runtimeUserMessagePayload(clientMessageId, runtimeTurns) {
     return undefined;
 }
 function nativeUserMessageText(runner, text) {
-    const goalFiltered = stripGoalStartPrompt(text);
-    const normalized = runner === 'claude-code' ? stripClaudePlanTag(goalFiltered) : goalFiltered;
+    const withoutPlan = runner === 'claude-code' ? stripClaudePlanTag(text) : text;
+    const normalized = publicGoalHistoryText(withoutPlan);
     if (runner !== 'codex')
         return normalized;
     return parseCodexComposerImageMarkers(normalized).text;

package/package.json

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