@myagentroam/node 0.11.43 → 0.11.45

package/dist/service/agent-network-bindings.js

@@ -3,10 +3,8 @@ import { resolvedPersonalInstructions } from '../runner/personal-instructions.js
 import { AgentNetworkService } from './agent-network-service.js';
 import { isPlainRecord } from '../util/records.js';
 import { safeErrorCode } from '../util/safe-error.js';
-import { withSessionMessageOrigin } from './composer-message-input.js';
 import { SESSION_ADMISSION_SIGNAL } from '../session/operation-admission.js';
 import { assertSessionControlOwner } from './run-ownership-policy.js';
-const approvedCalls = new WeakMap();
 const terminalCalls = new WeakMap();
 /** Bind a terminal actor only after the Node request boundary has authenticated its caller. */
 export function actorForAuthenticatedTerminal(actor, workspaceId) {
@@ -14,14 +12,6 @@ export function actorForAuthenticatedTerminal(actor, workspaceId) {
     terminalCalls.set(authenticated, { workspaceId });
     return authenticated;
 }
-/** Bind a Host-approved invocation to its exact target and domain operations. */
-export function actorForApprovedAgentCall(actor, context, agentIds, operations) {
-    if (context.permission?.decision !== 'approved')
-        return actor;
-    const approved = Object.freeze({ ...actor });
-    approvedCalls.set(approved, { agentIds: [...agentIds], operations: [...operations] });
-    return approved;
-}
 import { sessionPage } from '../session/pagination.js';
 import { marctlSessionSummary, marctlSessionDetail } from './session-recent-activity.js';
 /** Bind the collaboration use case to the existing Session, Run and Goal owners. */
@@ -50,7 +40,7 @@ export function createNodeAgentNetwork(options) {
         const parent = terminal ? undefined : await actorSession(actor);
         const workspaceId = terminal?.workspaceId ?? parent?.workspaceId;
         const session = options.runtime.getAgentSession(id) ?? (await options.projection.resolve(id, true));
-        if (!session || session.workspaceId !== workspaceId || session.id === parent?.id)
+        if (!session || session.workspaceId !== workspaceId)
             throw new Error('SESSION_NOT_FOUND');
         return session;
     }
@@ -93,11 +83,8 @@ export function createNodeAgentNetwork(options) {
         return result;
     }
     async function validateApproval(actor, session, input) {
-        if (!terminalCalls.has(actor)) {
-            const parent = await actorSession(actor);
-            if (session.parentSessionId !== parent.id)
-                throw new Error('AGENT_TARGET_NOT_AUTHORIZED');
-        }
+        if (!terminalCalls.has(actor))
+            await actorSession(actor);
         assertSessionControlOwner(options.runtime, session.id, actor.requestUserId);
         const approval = options.runtime.getApproval(input.approvalId);
         if (!approval)
@@ -118,19 +105,10 @@ export function createNodeAgentNetwork(options) {
     return new AgentNetworkService({
         observations: options.observations,
         target,
-        authorize: async (actor, session, operation) => {
+        authorize: async (actor, session) => {
+            if (!terminalCalls.has(actor))
+                await actorSession(actor);
             assertSessionControlOwner(options.runtime, session.id, actor.requestUserId);
-            if (terminalCalls.has(actor))
-                return;
-            const source = await actorSession(actor);
-            if (session.parentSessionId === source.id)
-                return;
-            if (source.parentSessionId === session.id && operation === 'send')
-                return;
-            const approved = approvedCalls.get(actor);
-            if (approved?.agentIds.includes(session.id) && approved.operations.includes(operation))
-                return;
-            throw new Error('AGENT_TARGET_NOT_AUTHORIZED');
         },
         children: async (actor) => {
             if (terminalCalls.has(actor))
@@ -144,27 +122,6 @@ export function createNodeAgentNetwork(options) {
         observe: (actor) => {
             options.ensureObservations(actor);
         },
-        isUpward: async (actor, session) => !terminalCalls.has(actor) && (await actorSession(actor)).parentSessionId === session.id,
-        reportUpward: async (actor, session, input, signal) => {
-            const child = await actorSession(actor);
-            const runId = actor.runId;
-            const executionId = actor.executionId;
-            if (!runId ||
-                !executionId ||
-                options.runtime.currentExecutionId(runId) !== executionId ||
-                child.parentSessionId !== session.id)
-                throw new Error('AGENT_ACTOR_NOT_ACTIVE');
-            signal?.throwIfAborted();
-            const parent = options.observations.get(session.id);
-            if (!parent?.report({
-                childId: child.id,
-                runId,
-                executionId,
-                value: withSessionMessageOrigin(input.content, origin(child), session.parentSessionId)
-            }))
-                throw new Error('AGENT_PARENT_NOT_WARM');
-            return { delivery: 'reported', clientMessageId: input.clientMessageId };
-        },
         freezeExecution: (session) => {
             const snapshot = options.runtime.latestSessionExecution(session.id);
             const run = options.runtime.activeSessionRun(session.id);
@@ -222,6 +179,7 @@ export function createNodeAgentNetwork(options) {
                 cwd: parent?.cwd ?? workspace.path,
                 content: input.content,
                 clientMessageId: input.clientMessageId,
+                __suppressNotifications: true,
                 ...(!terminal && parent ? { __marctlOrigin: origin(parent) } : {}),
                 ...(input.title === undefined ? {} : { title: input.title }),
                 ...(model ? { model } : {}),
@@ -237,6 +195,7 @@ export function createNodeAgentNetwork(options) {
                     objective: input.goal.kind === 'set' ? input.goal.objective : '',
                     secretEnvironment: childEnvironment(actor),
                     messageContent: input.content,
+                    suppressNotifications: true,
                     ...(!terminal && parent ? { messageOrigin: origin(parent) } : {}),
                     clientMessageId: input.clientMessageId,
                     ...(input.attachments === undefined ? {} : { attachments: input.attachments }),
@@ -276,6 +235,7 @@ export function createNodeAgentNetwork(options) {
                 session: current,
                 objective: change.objective,
                 executionContext,
+                suppressNotifications: true,
                 secretEnvironment: childEnvironment(actor),
                 ...(actor.requestUserId === undefined ? {} : { initiatedByUserId: actor.requestUserId }),
                 ...(actor.personalInstructions === undefined
@@ -306,6 +266,7 @@ export function createNodeAgentNetwork(options) {
                 ...input,
                 ...(signal ? { [SESSION_ADMISSION_SIGNAL]: signal } : {}),
                 sessionId: session.id,
+                __suppressNotifications: true,
                 ...(parent ? { __marctlOrigin: origin(parent) } : {})
             }));
             return publicReceipt(result);

package/dist/service/agent-network-invoke.js

@@ -1,4 +1,4 @@
-import { actorForApprovedAgentCall, actorForAuthenticatedTerminal } from './agent-network-bindings.js';
+import { actorForAuthenticatedTerminal } from './agent-network-bindings.js';
 import { isPlainRecord } from '../util/records.js';
 import { randomUUID } from 'node:crypto';
 import { modelUsageGrantSchema } from '@myagentroam/protocol';
@@ -52,21 +52,6 @@ export function executionAgentActor(input) {
 }
 /** Shared command dispatch; callers must bind actor authority at their trusted boundary. */
 export async function invokeAgentNetwork(service, actor, action, payload, context, requestSignal) {
-    const targets = typeof payload.agentId === 'string'
-        ? [payload.agentId]
-        : Array.isArray(payload.agentIds)
-            ? payload.agentIds.filter((id) => typeof id === 'string')
-            : [];
-    const operations = action === 'send'
-        ? ['send', 'goal']
-        : action === 'stop'
-            ? ['stop']
-            : action === 'wait'
-                ? ['wait']
-                : [];
-    const authorized = context
-        ? actorForApprovedAgentCall(actor, context, targets, operations)
-        : actor;
     const signal = context?.signal ?? requestSignal;
     switch (action) {
         case 'start':
@@ -85,11 +70,11 @@ export async function invokeAgentNetwork(service, actor, action, payload, contex
                 ...(typeof payload.title === 'string' ? { title: payload.title.trim() } : {})
             }, signal);
         case 'send':
-            return service.send(authorized, payload, signal);
+            return service.send(actor, payload, signal);
         case 'stop':
-            return service.stop(authorized, payload);
+            return service.stop(actor, payload);
         case 'wait':
-            return service.wait(authorized, {
+            return service.wait(actor, {
                 ...payload,
                 ...(context
                     ? { signal: context.signal, interrupt: context.waitInterrupt }

package/dist/service/agent-network-service.js

@@ -91,22 +91,6 @@ export class AgentNetworkService {
         if (input.approval !== undefined)
             await this.options.validateApproval(actor, session, input.approval);
         signal?.throwIfAborted();
-        if (hasMessage && (await this.options.isUpward(actor, session))) {
-            signal?.throwIfAborted();
-            if (goal.kind !== 'unchanged' ||
-                input.approval !== undefined ||
-                input.deliveryIntent === 'REPLACE_CURRENT' ||
-                input.deliveryIntent === 'QUEUE' ||
-                input.attachments?.length ||
-                input.attachmentIds?.length)
-                throw new Error('AGENT_UPWARD_REPORT_INVALID');
-            const result = await this.options.reportUpward(actor, session, {
-                clientMessageId: input.clientMessageId ?? randomUUID(),
-                content
-            }, signal);
-            return { agentId: session.id, message: { status: 'accepted', result } };
-        }
-        signal?.throwIfAborted();
         if (session.parentSessionId === actor.sessionId)
             this.options.observe(actor, session);
         const approvalResult = input.approval === undefined

package/dist/service/marctl-caller.js

@@ -21,7 +21,7 @@ const executionManagementOperations = new Set([
     'session.config.update',
     'session.schedule.agent.save'
 ]);
-/** Prevent execution credentials from reaching legacy writes outside their Session tree. */
+/** Keep execution management within its authenticated Workspace and Run ownership. */
 export async function authorizeMarctlExecutionOperation(input) {
     if (!isPlainRecord(input.caller))
         throw new Error('MARCTL_EXECUTION_CREDENTIAL_INVALID');
@@ -31,19 +31,27 @@ export async function authorizeMarctlExecutionOperation(input) {
         throw new Error('MARCTL_EXECUTION_CREDENTIAL_INVALID');
     if (executionReadOperations.has(input.operation))
         return;
-    if (!executionManagementOperations.has(input.operation) ||
-        !isPlainRecord(input.data) ||
-        typeof input.data.sessionId !== 'string' ||
-        typeof input.data.workspaceId !== 'string')
+    if (!isPlainRecord(input.data) || typeof input.data.workspaceId !== 'string')
         throw new Error('MARCTL_AGENT_NETWORK_REQUIRED');
+    let sessionId;
+    if (input.operation === 'run.approval.decide') {
+        const run = typeof input.data.runId === 'string' ? input.runtime.getRun(input.data.runId) : undefined;
+        if (!run)
+            throw new Error('RUN_NOT_FOUND');
+        sessionId = run.sessionId;
+    }
+    else {
+        if (!executionManagementOperations.has(input.operation) ||
+            typeof input.data.sessionId !== 'string')
+            throw new Error('MARCTL_AGENT_NETWORK_REQUIRED');
+        sessionId = input.data.sessionId;
+    }
     const source = input.runtime.getAgentSession(input.caller.sessionId);
-    const target = input.runtime.getAgentSession(input.data.sessionId) ??
-        (await input.resolveSession(input.data.sessionId));
+    const target = input.runtime.getAgentSession(sessionId) ?? (await input.resolveSession(sessionId));
     if (!source ||
         !target ||
         source.workspaceId !== input.data.workspaceId ||
-        target.workspaceId !== source.workspaceId ||
-        (target.id !== source.id && target.parentSessionId !== source.id))
+        target.workspaceId !== source.workspaceId)
         throw new Error('AGENT_TARGET_NOT_AUTHORIZED');
     assertSessionControlOwner(input.runtime, target.id, input.userId);
 }

package/dist/session/runtime/conversation-projection.js

@@ -1,4 +1,4 @@
-import { appendExecutionPresentation, permissionStopSchema } from '@myagentroam/protocol';
+import { appendToolOutput, retainExecutionInputTruncation, toolOutputSchema, permissionStopSchema } from '@myagentroam/protocol';
 import { projectConversationWorkProcesses } from './work-process.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
@@ -292,9 +292,16 @@ export function mergeConversationItemPayload(existing, next) {
     }
     if (next.append === 'output' &&
         isRecord(next.payload.output) &&
-        typeof next.payload.output.text === 'string') {
+        Array.isArray(next.payload.output.blocks)) {
+        const update = toolOutputSchema.parse(next.payload.output);
+        const prior = base.output === undefined ? undefined : toolOutputSchema.parse(base.output);
+        value.output = appendToolOutput(prior, update);
         if (next.payload.toolPresentation !== undefined)
-            value.toolPresentation = appendExecutionPresentation(base.toolPresentation, next.payload.toolPresentation);
+            value.toolPresentation = retainExecutionInputTruncation(base.toolPresentation, next.payload.toolPresentation);
+    }
+    if (next.append === 'output' &&
+        isRecord(next.payload.output) &&
+        typeof next.payload.output.text === 'string') {
         const prior = isRecord(base.output) && typeof base.output.text === 'string' ? base.output : undefined;
         const text = `${prior?.text ?? ''}${next.payload.output.text}`;
         value.output = {

package/dist/workspace/git.js

@@ -107,6 +107,23 @@ export async function readRestrictedDiff(workspacePath, fromRef, toRef) {
     }
     return { binary: false, text: result.text, truncated: result.truncated };
 }
+/** Fetches refs only; failures never expose remote URLs or authentication diagnostics. */
+export async function fetchGitRepository(workspacePath, timeoutMs) {
+    if (timeoutMs <= 0)
+        return false;
+    try {
+        const result = await runGitAllowFailure(workspacePath, ['fetch', '--all', '--quiet', '--no-recurse-submodules', '--no-write-fetch-head'], {
+            timeoutMs,
+            processGroup: true,
+            includeStderrInTimeout: false,
+            environment: { GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' }
+        });
+        return result.code === 0;
+    }
+    catch {
+        return false;
+    }
+}
 function currentBranchFromStatusHeader(header) {
     const value = header.slice(3);
     if (value.startsWith('HEAD '))
@@ -898,10 +915,12 @@ async function runGitAllowFailure(workspacePath, args, options = {}) {
             cwd: workspacePath,
             shell: false,
             windowsHide: true,
+            detached: options.processGroup === true && process.platform !== 'win32',
             stdio: ['ignore', 'pipe', 'pipe'],
             env: {
                 ...process.env,
                 ...gitOperationEnvironment.getStore(),
+                ...options.environment,
                 ...(options.readOnly === true ? { GIT_OPTIONAL_LOCKS: '0' } : {})
             }
         });
@@ -911,6 +930,7 @@ async function runGitAllowFailure(workspacePath, args, options = {}) {
         let errorSize = 0;
         let truncated = false;
         let timedOut = false;
+        let forcedTerminationTimer;
         const timer = setTimeout(() => {
             timedOut = true;
             if (process.platform === 'win32') {
@@ -932,6 +952,26 @@ async function runGitAllowFailure(workspacePath, args, options = {}) {
                 });
                 return;
             }
+            if (options.processGroup === true && child.pid !== undefined) {
+                const pid = child.pid;
+                try {
+                    // Give Git a chance to release transaction locks before bounded escalation.
+                    process.kill(-pid, 'SIGTERM');
+                    forcedTerminationTimer = setTimeout(() => {
+                        try {
+                            process.kill(-pid, 'SIGKILL');
+                        }
+                        catch {
+                            // The process group may have completed its cleanup already.
+                        }
+                    }, 250);
+                    forcedTerminationTimer.unref();
+                    return;
+                }
+                catch {
+                    // The group may have exited before the timeout fired.
+                }
+            }
             child.kill('SIGKILL');
         }, options.timeoutMs ?? GIT_TIMEOUT_MS);
         child.stdout.on('data', (chunk) => {
@@ -953,6 +993,7 @@ async function runGitAllowFailure(workspacePath, args, options = {}) {
         });
         child.once('error', (error) => {
             clearTimeout(timer);
+            clearTimeout(forcedTerminationTimer);
             logNodeCommandFailure(`git ${args[0] ?? 'unknown'}`, {
                 reason: error.code ?? 'START_FAILED'
             });
@@ -960,9 +1001,11 @@ async function runGitAllowFailure(workspacePath, args, options = {}) {
         });
         child.once('close', (code) => {
             clearTimeout(timer);
+            clearTimeout(forcedTerminationTimer);
             const stderr = Buffer.concat(errors).toString('utf8');
             if (timedOut) {
-                reject(gitCommandFailure(code === null || code === 0 ? 1 : code, `Git command timed out after ${options.timeoutMs ?? GIT_TIMEOUT_MS} ms.${stderr ? `\n${stderr}` : ''}`, args[0] ?? 'unknown', Math.round(performance.now() - startedAt), 'TIMEOUT'));
+                const details = options.includeStderrInTimeout === false ? '' : stderr;
+                reject(gitCommandFailure(code === null || code === 0 ? 1 : code, `Git command timed out after ${options.timeoutMs ?? GIT_TIMEOUT_MS} ms.${details ? `\n${details}` : ''}`, args[0] ?? 'unknown', Math.round(performance.now() - startedAt), 'TIMEOUT'));
                 return;
             }
             const output = Buffer.concat(chunks);

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

@@ -2,7 +2,7 @@ import { lstat } from 'node:fs/promises';
 import { basename, posix, resolve } from 'node:path';
 import { publicErrorMessage } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
-import { GitCommandError, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository, resolveWorkspaceGitRoot } from './git.js';
+import { GitCommandError, fetchGitRepository, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository, resolveWorkspaceGitRoot } from './git.js';
 const CACHE_TTL_MS = 5_000;
 const REPOSITORY_READ_CONCURRENCY = 4;
 const WORKTREE_READ_CONCURRENCY = 4;
@@ -27,6 +27,44 @@ export class WorkspaceChangeService {
         this.changesCache.clear();
         this.changesVersions.clear();
     }
+    async fetch(workspace, repositoryPath) {
+        if (workspace.kind !== 'GIT_WORKSPACE')
+            throw new Error('WORKSPACE_NOT_GIT');
+        const root = await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true);
+        // A selected History repository is validated before any network operation.
+        const selected = repositoryPath === undefined ? undefined : await resolveGitRepository(root, repositoryPath);
+        let paths;
+        if (selected !== undefined)
+            paths = [repositoryPath];
+        else {
+            this.invalidate(workspace.id);
+            const current = (await this.current(workspace));
+            // Linked worktrees share the root's refs and must not fetch them twice.
+            paths = current.repositories
+                .filter((entry) => entry.source !== 'WORKTREE' && entry.status !== 'UNAVAILABLE')
+                .map((entry) => entry.repositoryPath);
+        }
+        const deadline = performance.now() + 10_000;
+        try {
+            const results = await mapWithConcurrency(paths, REPOSITORY_READ_CONCURRENCY, async (path) => {
+                try {
+                    if (performance.now() >= deadline)
+                        return false;
+                    const repository = selected ?? (await resolveGitRepository(root, path));
+                    return await fetchGitRepository(repository, Math.max(0, Math.floor(deadline - performance.now())));
+                }
+                catch {
+                    return false;
+                }
+            });
+            return { fetchFailed: results.some((success) => !success) };
+        }
+        finally {
+            // Fetch is request/user scoped, never coalesced with another user's credentials.
+            // Invalidate even after partial failure: some remotes may already have advanced.
+            this.invalidate(workspace.id);
+        }
+    }
     async current(workspace) {
         if (workspace.kind !== 'GIT_WORKSPACE')
             throw new Error('WORKSPACE_NOT_GIT');

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

@@ -58,6 +58,7 @@ export class WorkspaceWorkbenchService {
             'workspace.files.upload.complete': (data) => this.completeUpload(record(data)),
             'workspace.files.upload.cancel': (data) => this.cancelUpload(record(data)),
             'workspace.changes.current': (data) => this.currentChanges(record(data)),
+            'workspace.git.fetch': (data) => this.gitFetch(record(data)),
             'workspace.change.diff': (data) => this.changeDiff(record(data)),
             'workspace.change.restore': (data) => this.restoreChange(record(data)),
             'workspace.git.refs.list': (data) => this.gitRefs(record(data)),
@@ -239,6 +240,13 @@ export class WorkspaceWorkbenchService {
     async gitRefs(input) {
         return { refs: await listGitHistoryRefs(await this.gitRepository(input)) };
     }
+    async gitFetch(input) {
+        if (typeof input.workspaceId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        if (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string')
+            throw new Error('GIT_REPOSITORY_INVALID');
+        return this.options.changes.fetch(this.gitWorkspace(input.workspaceId), input.repositoryPath);
+    }
     async gitHistory(input) {
         const refs = this.refs(input);
         if (input.cursor !== undefined && typeof input.cursor !== 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.43",
+  "version": "0.11.45",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -38,10 +38,10 @@
     "sharp": "0.35.5",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.43",
-    "@myagentroam/marctl": "0.11.6",
+    "@myagentroam/agent": "0.11.45",
     "@myagentroam/code-navigation": "0.11.1",
-    "@myagentroam/protocol": "0.11.43"
+    "@myagentroam/marctl": "0.11.6",
+    "@myagentroam/protocol": "0.11.45"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"