@myagentroam/node 0.11.15 → 0.11.17

package/dist/runner/runner-registry.js

@@ -77,6 +77,10 @@ export class RunnerRegistry {
                 return true;
         return false;
     }
+    migrateSessionIdentity(previousId, nativeSessionId) {
+        for (const runner of this.runners.values())
+            runner.migrateSessionIdentity(previousId, nativeSessionId);
+    }
     decideApproval(input) {
         let handled = false;
         for (const runner of this.runners.values())

package/dist/runtime-state.js

@@ -478,6 +478,7 @@ export class NodeRuntimeState {
             runner: session.runner,
             clientMessageId: input.clientMessageId,
             content: input.content,
+            ...(input.goalInput === true ? { goalInput: true } : {}),
             ...(input.suppressNotifications === true ? { suppressNotifications: true } : {}),
             attachments: input.attachments ?? [],
             ...(input.initiatedByUserId === undefined
@@ -1236,12 +1237,6 @@ export class NodeRuntimeState {
         if (this.sessionHistoryMutations.has(sessionId))
             throw new Error('SESSION_ACTIVE');
     }
-    reconcileRun(id, active) {
-        // There is no cross-restart run recovery: this process-local state is
-        // discarded on restart and cannot be reconciled from SQLite.
-        void id;
-        void active;
-    }
     replaceSession(id, patch) {
         const value = this.requireSession(id);
         const next = { ...value, ...patch };

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

@@ -50,6 +50,7 @@ export class ContinuousRunCoordinator {
                 sessionId: message.sessionId,
                 clientMessageId: message.clientMessageId,
                 content: message.content,
+                ...(message.goalInput === true ? { goalInput: true } : {}),
                 ...(message.suppressNotifications === true ? { suppressNotifications: true } : {}),
                 ...(message.initiatedByUserId === undefined
                     ? {}

package/dist/service/conversation-template-manifest.js

@@ -0,0 +1,179 @@
+import { createHash } from 'node:crypto';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { conversationTemplateDraftSchema, mcpRuntimeDescriptorSchema, mcpInstallationConfigurationSchema } from '@myagentroam/protocol';
+const RUNTIME_LINK_ROOTS = ['/usr', '/bin', '/sbin', '/lib', '/lib64'];
+const RESERVED_SANDBOX_ROOTS = [
+    '/workspace',
+    '/home/mar',
+    '/runtime',
+    '/usr',
+    '/bin',
+    '/sbin',
+    '/lib',
+    '/lib64',
+    '/proc',
+    '/dev',
+    '/run',
+    '/tmp'
+];
+export function parseTemplateVersionManifest(input) {
+    if (!record(input) ||
+        input['schemaVersion'] !== 2 ||
+        typeof input['sourceWorkspacePath'] !== 'string' ||
+        !Array.isArray(input['directories']) ||
+        !Array.isArray(input['entries']) ||
+        typeof input['contentHash'] !== 'string' ||
+        typeof input['mcpConfigHash'] !== 'string')
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    const sourceWorkspacePath = input['sourceWorkspacePath'];
+    if (!isAbsolute(sourceWorkspacePath) ||
+        resolve(sourceWorkspacePath) !== sourceWorkspacePath ||
+        sourceWorkspacePath === '/' ||
+        isReservedTemplateSourcePath(sourceWorkspacePath))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    const draft = conversationTemplateDraftSchema.safeParse(input['draft']);
+    if (!draft.success)
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    const directories = input['directories'].map(safeManifestRelativePath);
+    if (new Set(directories).size !== directories.length ||
+        directories.includes('inbox') ||
+        directories.includes('output'))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    const entries = input['entries'].map(manifestEntry);
+    if (new Set(entries.map((entry) => entry.relativePath)).size !== entries.length)
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    return {
+        schemaVersion: 2,
+        sourceWorkspacePath,
+        draft: draft.data,
+        directories,
+        entries,
+        contentHash: input['contentHash'],
+        mcpServers: publishedMcpServers(input['mcpServers']),
+        mcpConfigHash: input['mcpConfigHash']
+    };
+}
+export function isTemplateRuntimeLinkTarget(path) {
+    return isAbsolute(path) && RUNTIME_LINK_ROOTS.some((root) => path === root || within(root, path));
+}
+export function isReservedTemplateSourcePath(path) {
+    return RESERVED_SANDBOX_ROOTS.some((root) => path === root || within(root, path) || within(path, root));
+}
+export function templateMcpConfigHash(servers) {
+    return hashText(JSON.stringify(servers));
+}
+/** Hash the persisted text after removing exactly one optional trailing newline. */
+export function templateManifestHash(manifestText) {
+    return hashText(manifestText.endsWith('\n') ? manifestText.slice(0, -1) : manifestText);
+}
+function manifestEntry(input) {
+    if (!record(input))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    if (input['kind'] === 'FILE')
+        return manifestFile(input);
+    if (input['kind'] !== 'SYMLINK' ||
+        typeof input['linkTarget'] !== 'string' ||
+        input['linkTarget'].length === 0 ||
+        input['linkTarget'].includes('\0') ||
+        (input['targetKind'] !== 'SNAPSHOT' && input['targetKind'] !== 'RUNTIME') ||
+        typeof input['resolvedTarget'] !== 'string')
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    const relativePath = safeManifestRelativePath(input['relativePath']);
+    const size = safeNonNegativeInteger(input['size']);
+    const linkTarget = input['linkTarget'];
+    const targetKind = input['targetKind'];
+    const resolvedTarget = input['resolvedTarget'];
+    if (size !== Buffer.byteLength(linkTarget))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    if (targetKind === 'SNAPSHOT')
+        safeManifestRelativePath(resolvedTarget);
+    else if (!isTemplateRuntimeLinkTarget(resolvedTarget))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    return {
+        kind: 'SYMLINK',
+        relativePath,
+        size,
+        linkTarget,
+        targetKind,
+        resolvedTarget
+    };
+}
+function manifestFile(input) {
+    if (!record(input) ||
+        input['kind'] !== 'FILE' ||
+        typeof input['executable'] !== 'boolean' ||
+        typeof input['sha256'] !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(input['sha256']))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    return {
+        kind: 'FILE',
+        relativePath: safeManifestRelativePath(input['relativePath']),
+        size: safeNonNegativeInteger(input['size']),
+        executable: input['executable'],
+        sha256: input['sha256']
+    };
+}
+function safeManifestRelativePath(input) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        input.startsWith('/') ||
+        input.includes('\\') ||
+        input.split('/').some((segment) => segment.length === 0 || segment === '.' || segment === '..'))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    return input;
+}
+function safeNonNegativeInteger(input) {
+    if (!Number.isSafeInteger(input) || input < 0)
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    return input;
+}
+export function templateContentHash(directories, entries) {
+    return hashText([
+        ...directories.map((directory) => `DIRECTORY\0${directory}`),
+        ...entries.map((entry) => entry.kind === 'FILE'
+            ? `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.executable ? 1 : 0}\0${entry.sha256}`
+            : `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.linkTarget}\0${entry.targetKind}\0${entry.resolvedTarget}`)
+    ].join('\n'));
+}
+function publishedMcpServers(value) {
+    if (!Array.isArray(value))
+        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+    return value.map((candidate) => {
+        if (!record(candidate))
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        const keys = Object.keys(candidate).sort().join(',');
+        if (keys !== 'configuration,displayName,id,origin,runtime,serverName,transport,version')
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        const runtime = mcpRuntimeDescriptorSchema.safeParse(candidate.runtime);
+        const configuration = mcpInstallationConfigurationSchema.safeParse(candidate.configuration);
+        if (!runtime.success || !configuration.success)
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        if (typeof candidate.id !== 'string' ||
+            typeof candidate.serverName !== 'string' ||
+            typeof candidate.displayName !== 'string' ||
+            typeof candidate.version !== 'string' ||
+            (candidate.origin !== 'NODE' && candidate.origin !== 'WORKSPACE') ||
+            candidate.transport !== runtime.data.transport)
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        return {
+            id: candidate.id,
+            serverName: candidate.serverName,
+            displayName: candidate.displayName,
+            version: candidate.version,
+            origin: candidate.origin,
+            transport: runtime.data.transport,
+            runtime: runtime.data,
+            configuration: configuration.data
+        };
+    });
+}
+function within(parent, candidate) {
+    const relation = relative(parent, candidate);
+    return relation.length > 0 && relation !== '..' && !relation.startsWith(`..${sep}`);
+}
+function hashText(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/service/conversation-template-node-service.js

@@ -3,6 +3,7 @@ import { chmod, copyFile, lstat, mkdir, readFile, readlink, readdir, realpath, r
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { conversationTemplateDraftSchema, conversationTemplatePublishJobSchema, conversationTemplatePublishRequestSchema, conversationTemplatePublishResultSchema, conversationTemplatePublishStatusInputSchema, conversationTemplateSourceInspectInputSchema, conversationTemplateSourceInspectionSchema, conversationTemplateVersionSchema } from '@myagentroam/protocol';
 import { safeErrorCode } from '../util/safe-error.js';
+import { parseTemplateVersionManifest, templateContentHash, templateMcpConfigHash, templateManifestHash, isTemplateRuntimeLinkTarget, isReservedTemplateSourcePath } from './conversation-template-manifest.js';
 const HOST_POLICY_VERSION = 1;
 const FORCED_EXCLUDED_NAMES = new Set([
     '.git',
@@ -17,21 +18,6 @@ const FORCED_EXCLUDED_NAMES = new Set([
 const ROOT_EXCLUDED_NAMES = new Set(['credentials', 'secrets', 'readme.md', 'agents.md']);
 const ROOT_TEMPLATE_INSTRUCTIONS_SOURCE = 'AGENTS.template.md';
 const ROOT_TEMPLATE_INSTRUCTIONS_TARGET = 'AGENTS.md';
-const RUNTIME_LINK_ROOTS = ['/usr', '/bin', '/sbin', '/lib', '/lib64'];
-const RESERVED_SANDBOX_ROOTS = [
-    '/workspace',
-    '/home/mar',
-    '/runtime',
-    '/usr',
-    '/bin',
-    '/sbin',
-    '/lib',
-    '/lib64',
-    '/proc',
-    '/dev',
-    '/run',
-    '/tmp'
-];
 /** Handles the four closed template-management operations owned by Node. */
 export class ConversationTemplateNodeService {
     options;
@@ -196,7 +182,7 @@ export class ConversationTemplateNodeService {
             const snapshot = await this.collectSnapshot(request.draft);
             const entries = snapshot.entries;
             const mcpServers = this.selectedMcpServers(request.draft);
-            const mcpConfigHash = hashText(JSON.stringify(mcpServers));
+            const mcpConfigHash = templateMcpConfigHash(mcpServers);
             stage = 'ENUMERATING';
             this.updateJob(request.jobId, stage, 'RUNNING');
             await rm(candidate, { recursive: true, force: true });
@@ -237,7 +223,7 @@ export class ConversationTemplateNodeService {
             const versionNumber = this.nextVersionNumber(request.templateId);
             const versionId = this.id();
             const publishedAt = this.now();
-            const contentHash = snapshotContentHash(snapshot.directories, entries);
+            const contentHash = templateContentHash(snapshot.directories, entries);
             const manifest = {
                 schemaVersion: 2,
                 templateId: request.templateId,
@@ -273,7 +259,7 @@ export class ConversationTemplateNodeService {
             stage = 'MANIFEST';
             this.updateJob(request.jobId, stage, 'RUNNING');
             const manifestJson = JSON.stringify(manifest);
-            const manifestHash = hashText(manifestJson);
+            const manifestHash = templateManifestHash(manifestJson);
             await writeFile(join(candidate, 'manifest.json'), `${manifestJson}\n`, { mode: 0o600 });
             await chmod(join(candidate, 'manifest.json'), 0o444);
             sealed = this.options.store.templateVersionDirectory(storageKey);
@@ -506,16 +492,16 @@ export class ConversationTemplateNodeService {
         const root = this.options.store.templateVersionDirectory(storageKey);
         const manifestText = await readFile(join(root, 'manifest.json'), 'utf8');
         const manifestJson = manifestText.endsWith('\n') ? manifestText.slice(0, -1) : manifestText;
-        if (hashText(manifestJson) !== stringValue(row, 'manifest_hash'))
+        if (templateManifestHash(manifestText) !== stringValue(row, 'manifest_hash'))
             throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-        const manifest = templateVersionManifest(JSON.parse(manifestJson));
+        const manifest = parseTemplateVersionManifest(JSON.parse(manifestJson));
         if (manifest.mcpConfigHash !== stringValue(row, 'mcp_config_hash') ||
-            hashText(JSON.stringify(manifest.mcpServers)) !== manifest.mcpConfigHash ||
+            templateMcpConfigHash(manifest.mcpServers) !== manifest.mcpConfigHash ||
             manifest.contentHash !== stringValue(row, 'content_hash') ||
             manifest.entries.length !== numberValue(row, 'file_count') ||
             manifest.entries.reduce((total, entry) => total + entry.size, 0) !==
                 numberValue(row, 'total_bytes') ||
-            snapshotContentHash(manifest.directories, manifest.entries) !== manifest.contentHash)
+            templateContentHash(manifest.directories, manifest.entries) !== manifest.contentHash)
             throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
         const expected = new Map(manifest.entries.map((entry) => [entry.relativePath, entry]));
         const expectedDirectories = new Set([...manifest.directories, 'inbox', 'output']);
@@ -779,8 +765,7 @@ async function publishedSymlink(workspaceRoot, path, relativePath, metadata) {
             resolvedTarget: targetRelative
         };
     }
-    const runtimeTarget = RUNTIME_LINK_ROOTS.find((root) => resolvedTarget === root || within(root, resolvedTarget));
-    if (runtimeTarget === undefined)
+    if (!isTemplateRuntimeLinkTarget(resolvedTarget))
         throw new Error('CONVERSATION_TEMPLATE_SOURCE_LINK_INVALID');
     return {
         kind: 'SYMLINK',
@@ -792,110 +777,6 @@ async function publishedSymlink(workspaceRoot, path, relativePath, metadata) {
         resolvedTarget
     };
 }
-function templateVersionManifest(input) {
-    if (!record(input))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    const mcpServers = Array.isArray(input['mcpServers'])
-        ? input['mcpServers']
-        : undefined;
-    if (mcpServers === undefined ||
-        typeof input['mcpConfigHash'] !== 'string' ||
-        typeof input['contentHash'] !== 'string')
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    if (input['schemaVersion'] !== 2 ||
-        typeof input['sourceWorkspacePath'] !== 'string' ||
-        !Array.isArray(input['directories']) ||
-        !Array.isArray(input['entries']))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    validateSourceWorkspacePath(input['sourceWorkspacePath']);
-    const directories = input['directories'].map((value) => safeManifestRelativePath(value));
-    if (new Set(directories).size !== directories.length ||
-        directories.includes('inbox') ||
-        directories.includes('output'))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    const entries = input['entries'].map((value) => manifestEntry(value));
-    if (new Set(entries.map((entry) => entry.relativePath)).size !== entries.length)
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    return {
-        schemaVersion: 2,
-        sourceWorkspacePath: input['sourceWorkspacePath'],
-        directories,
-        entries,
-        contentHash: input['contentHash'],
-        mcpServers,
-        mcpConfigHash: input['mcpConfigHash']
-    };
-}
-function manifestEntry(input) {
-    if (!record(input))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    if (input['kind'] === 'FILE')
-        return manifestFile(input, true);
-    if (input['kind'] !== 'SYMLINK' ||
-        typeof input['linkTarget'] !== 'string' ||
-        input['linkTarget'].length === 0 ||
-        input['linkTarget'].includes('\0') ||
-        (input['targetKind'] !== 'SNAPSHOT' && input['targetKind'] !== 'RUNTIME') ||
-        typeof input['resolvedTarget'] !== 'string')
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    const relativePath = safeManifestRelativePath(input['relativePath']);
-    const size = safeNonNegativeInteger(input['size']);
-    const linkTarget = input['linkTarget'];
-    const targetKind = input['targetKind'];
-    const resolvedTarget = input['resolvedTarget'];
-    if (size !== Buffer.byteLength(linkTarget))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    if (targetKind === 'SNAPSHOT')
-        safeManifestRelativePath(resolvedTarget);
-    else if (!isAbsolute(resolvedTarget) ||
-        !RUNTIME_LINK_ROOTS.some((root) => resolvedTarget === root || within(root, resolvedTarget)))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    return {
-        kind: 'SYMLINK',
-        relativePath,
-        size,
-        linkTarget,
-        targetKind,
-        resolvedTarget
-    };
-}
-function manifestFile(input, requireKind = false) {
-    if (!record(input) ||
-        (requireKind && input['kind'] !== 'FILE') ||
-        typeof input['executable'] !== 'boolean' ||
-        typeof input['sha256'] !== 'string' ||
-        !/^[a-f0-9]{64}$/u.test(input['sha256']))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    return {
-        kind: 'FILE',
-        relativePath: safeManifestRelativePath(input['relativePath']),
-        size: safeNonNegativeInteger(input['size']),
-        executable: input['executable'],
-        sha256: input['sha256']
-    };
-}
-function safeManifestRelativePath(input) {
-    if (typeof input !== 'string' ||
-        input.length === 0 ||
-        input.startsWith('/') ||
-        input.includes('\\') ||
-        input.split('/').some((segment) => segment.length === 0 || segment === '.' || segment === '..'))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    return input;
-}
-function safeNonNegativeInteger(input) {
-    if (!Number.isSafeInteger(input) || input < 0)
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    return input;
-}
-function snapshotContentHash(directories, entries) {
-    return hashText([
-        ...directories.map((directory) => `DIRECTORY\0${directory}`),
-        ...entries.map((entry) => entry.kind === 'FILE'
-            ? `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.executable ? 1 : 0}\0${entry.sha256}`
-            : `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.linkTarget}\0${entry.targetKind}\0${entry.resolvedTarget}`)
-    ].join('\n'));
-}
 async function hostedFilesystemAvailableBytes(path) {
     try {
         const filesystem = await statfs(path);
@@ -913,16 +794,13 @@ async function hostedFilesystemAvailableBytes(path) {
 function validateSourceWorkspacePath(path) {
     if (!isAbsolute(path) || resolve(path) !== path || path === '/')
         throw new Error('CONVERSATION_TEMPLATE_SOURCE_INVALID');
-    if (RESERVED_SANDBOX_ROOTS.some((root) => path === root || within(root, path) || within(path, root)))
+    if (isReservedTemplateSourcePath(path))
         throw new Error('CONVERSATION_TEMPLATE_SOURCE_INVALID');
 }
 function within(parent, candidate) {
     const relation = relative(parent, candidate);
     return relation.length > 0 && relation !== '..' && !relation.startsWith(`..${sep}`);
 }
-function hashText(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
 function hashBuffer(value) {
     return createHash('sha256').update(value).digest('hex');
 }

package/dist/service/external-session-resume-service.js

@@ -6,6 +6,21 @@ export class ExternalSessionResumeService {
     constructor(options) {
         this.options = options;
     }
+    setActivity(sessionId, activity) {
+        this.options.state.externalActivity.set(sessionId, activity);
+    }
+    forgetSessions(directIds, projectionIds) {
+        for (const directId of directIds) {
+            this.options.state.externalActivity.delete(directId);
+            this.options.state.resumedByDirectId.delete(directId);
+            this.clearFailure(directId);
+        }
+        for (const [directId, resumedId] of this.options.state.resumedByDirectId)
+            if (projectionIds.has(resumedId))
+                this.options.state.resumedByDirectId.delete(directId);
+        for (const projectionId of projectionIds)
+            this.options.state.externalActivity.delete(projectionId);
+    }
     transitioning(sessionId) {
         return this.transitions.has(sessionId);
     }

package/dist/service/fake-managed-run-service.js

@@ -1,4 +1,4 @@
-import { isTerminalRunStatus } from '../runner/codex/conversation-parser.js';
+import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
 /** Test-only managed Run adapter; production Runner paths never depend on it. */
 export class FakeManagedRunService {
     options;

package/dist/service/goal-continuation-coordinator.js

@@ -3,7 +3,6 @@ import { nodeLog } from '../operational.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { NODE_MCP } from '../mcp/naming.js';
-import { goalUnrestrictedAccess } from './goal-runtime.js';
 import { composerResourceInputTags } from './composer-message-input.js';
 /** Owns transient Goal orchestration, not the domain state or execution queue. */
 export class GoalContinuationCoordinator {
@@ -527,9 +526,11 @@ export class GoalContinuationCoordinator {
         return goalExit;
     }
     prepareGoalSession(session) {
-        const access = goalUnrestrictedAccess(session.runner, session.access);
+        const { access, accessChanged: changed } = this.options
+            .runners()
+            .require(session.runner)
+            .goalAccess(session.access);
         const requiresUpdate = session.access !== access;
-        const changed = session.runner !== 'mar-agent' && requiresUpdate;
         const prepared = requiresUpdate
             ? this.options.runtime.updateAgentSessionAccess(session.id, access)
             : session;

package/dist/service/goal-runtime.js

@@ -1,15 +1,6 @@
 import { NODE_MCP } from '../mcp/naming.js';
 import { randomUUID } from 'node:crypto';
 import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
-export function goalUnrestrictedAccess(runner, currentAccess) {
-    if (runner === 'mar-agent')
-        return currentAccess ?? 'full-access';
-    if (runner === 'codex')
-        return 'full-access';
-    if (runner === 'claude-code')
-        return 'bypass';
-    return 'auto';
-}
 export function publicGoalStartText(objective) {
     return serializeComposerTag('mar_goal_start', { objective: objective.trim() });
 }