@myagentroam/node 0.11.35 → 0.11.37

package/dist/hosting/hosted-conversation-watch.js

@@ -0,0 +1,194 @@
+import { safeErrorCode } from '../util/safe-error.js';
+const WATCH_TTL_MS = 45_000;
+/** Owns hosted Watch leases, initialization ordering and pending realtime events. */
+export class HostedConversationWatch {
+    options;
+    leases = new Map();
+    snapshotSequence = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    watch(input, sessionHash, userId, templateId, models) {
+        const ownerKey = `${sessionHash}:${input.workbenchConnectionId}`;
+        const existing = this.leases.get(ownerKey);
+        if (input.mode === 'renew') {
+            if (!existing ||
+                !this.options.slots.owns(ownerKey, existing.slotToken) ||
+                existing.watchId !== input.watchId ||
+                existing.conversationId !== input.conversationId ||
+                existing.userId !== userId)
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            if (existing.expiresAt <= Date.now()) {
+                this.remove(ownerKey);
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            }
+            return this.renew(existing);
+        }
+        const resolvedModels = models();
+        if (existing &&
+            this.options.slots.owns(ownerKey, existing.slotToken) &&
+            existing.watchId === input.watchId &&
+            existing.conversationId === input.conversationId &&
+            existing.userId === userId &&
+            existing.expiresAt > Date.now())
+            return this.renew(existing);
+        this.remove(ownerKey);
+        const slotToken = this.options.slots.replace(ownerKey, 'hosted-conversation', () => this.remove(ownerKey));
+        const lease = {
+            ownerKey,
+            slotToken,
+            sessionHash,
+            workbenchConnectionId: input.workbenchConnectionId,
+            watchId: input.watchId,
+            conversationId: input.conversationId,
+            templateId,
+            userId,
+            models: resolvedModels,
+            nodeGeneration: this.options.nodeGeneration?.() ?? 'local-test-generation',
+            pendingEvents: [],
+            expiresAt: Date.now() + WATCH_TTL_MS,
+            ready: false,
+            timer: undefined
+        };
+        lease.timer = this.timer(ownerKey);
+        this.leases.set(ownerKey, lease);
+        void this.initialize(lease);
+        return this.accepted(lease);
+    }
+    unwatch(input, sessionHash, userId) {
+        const key = `${sessionHash}:${input.workbenchConnectionId}`;
+        const lease = this.leases.get(key);
+        if (lease?.watchId === input.watchId &&
+            lease.conversationId === input.conversationId &&
+            lease.userId === userId)
+            this.remove(key);
+        return { unwatched: true };
+    }
+    hasConversation(id) {
+        return [...this.leases.values()].some((lease) => lease.conversationId === id);
+    }
+    removeConversation(id) {
+        for (const lease of [...this.leases.values()])
+            if (lease.conversationId === id)
+                this.remove(lease.ownerKey);
+    }
+    close() {
+        for (const key of [...this.leases.keys()])
+            this.remove(key);
+    }
+    publishEvent(conversationId, payload) {
+        const leases = [...this.leases.values()].filter((lease) => lease.conversationId === conversationId);
+        if (leases.length === 0)
+            return false;
+        const event = this.options.nextEvent(payload);
+        if (event === undefined)
+            return false;
+        for (const lease of leases) {
+            if (!lease.ready)
+                lease.pendingEvents.push(event);
+            else
+                this.emitEvent(lease, event);
+        }
+        return true;
+    }
+    publishSnapshot(conversationId, snapshot) {
+        for (const lease of this.leases.values())
+            if (lease.conversationId === conversationId && lease.ready)
+                this.emitSnapshot(lease, snapshot);
+    }
+    async refreshReadySnapshots(conversationId, completedRunId) {
+        const leases = [...this.leases.values()].filter((lease) => lease.conversationId === conversationId && lease.ready);
+        await Promise.allSettled(leases.map(async (lease) => {
+            const snapshot = await this.options.snapshot(lease.userId, conversationId, lease.models);
+            if (this.leases.get(lease.ownerKey) !== lease ||
+                !lease.ready ||
+                !this.options.mayRefresh(conversationId, completedRunId))
+                return;
+            this.emitSnapshot(lease, { ...snapshot, run: null });
+        }));
+    }
+    async initialize(lease) {
+        try {
+            const snapshot = await this.options.initial(lease);
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            this.emitSnapshot(lease, snapshot);
+            lease.ready = true;
+            for (const event of lease.pendingEvents)
+                this.emitEvent(lease, event);
+            lease.pendingEvents.length = 0;
+        }
+        catch (error) {
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            this.options.emit?.({
+                type: 'watch.failed',
+                workbenchConnectionId: lease.workbenchConnectionId,
+                watchType: 'hosted-conversation',
+                watchId: lease.watchId,
+                nodeGeneration: lease.nodeGeneration,
+                nodeId: this.options.nodeId(),
+                templateId: lease.templateId,
+                conversationId: lease.conversationId,
+                code: safeErrorCode(error, 'HOSTED_CONVERSATION_WATCH_FAILED'),
+                message: 'Hosted conversation watch snapshot failed.'
+            });
+            this.remove(lease.ownerKey);
+        }
+    }
+    emitSnapshot(lease, payload) {
+        this.options.emit?.({
+            type: 'watch.hosted-conversation.snapshot',
+            workbenchConnectionId: lease.workbenchConnectionId,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            nodeId: this.options.nodeId(),
+            templateId: lease.templateId,
+            conversationId: lease.conversationId,
+            revision: 1,
+            snapshotSequence: ++this.snapshotSequence,
+            expiresAt: lease.expiresAt,
+            payload
+        });
+    }
+    emitEvent(lease, event) {
+        this.options.emit?.({
+            type: 'watch.hosted-conversation.event',
+            workbenchConnectionId: lease.workbenchConnectionId,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            nodeId: this.options.nodeId(),
+            templateId: lease.templateId,
+            conversationId: lease.conversationId,
+            expiresAt: lease.expiresAt,
+            event
+        });
+    }
+    accepted(lease) {
+        return {
+            accepted: true,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            expiresAt: lease.expiresAt
+        };
+    }
+    renew(lease) {
+        lease.expiresAt = Date.now() + WATCH_TTL_MS;
+        clearTimeout(lease.timer);
+        lease.timer = this.timer(lease.ownerKey);
+        return this.accepted(lease);
+    }
+    remove(key) {
+        const lease = this.leases.get(key);
+        if (!lease)
+            return;
+        clearTimeout(lease.timer);
+        this.leases.delete(key);
+        this.options.slots.release(key, lease.slotToken);
+    }
+    timer(key) {
+        const timer = setTimeout(() => this.remove(key), WATCH_TTL_MS);
+        timer.unref();
+        return timer;
+    }
+}

package/dist/hosting/runtime-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/marctl-guidance.js

@@ -22,7 +22,7 @@ export const marctlInstructions = [
     'show/config/history/graph/rename, prompt and schedule get/create/update may omit the Session ID to use the current Session. Without a current Session, specify an ID. send/goal/stop/wait/approval always require explicit target IDs.',
     'Use sessions schedule list/get/create/update for the same tasks as the built-in schedule MCP, which remains available in other Runners and is hidden in MAR Agent while its marctl skill is available. list is Workspace-scoped. create requires --cron and text (-m/--message-file, up to 20,000 characters). update requires --expected-revision from get and at least cron or text. get returns task (null if absent), with id, revision, objective, cron, timezone and enabled; applied updates also return task. Reuse that task instead of probing its shape or refetching unchanged state. Schedule text is trimmed at both ends; compare after the same trimming; a conclusive update response needs no extra get. Other-owner edits return a PENDING proposal, not an applied change. Scheduled execution uses normal user permissions. Follow existing approval rules and do not retry conflicts or uncertain writes blindly.',
     'Read results with sessions history <session-id> --limit 10 --json (default: latest 10 SEGMENTs, not messages; --limit 1..100). In segments[].items[], select kind === "assistant_message" and read payload.text; keep segment runId and user_message.payload.clientMessageId for queued-input correlation. Reuse the returned page; follow --cursor <nextCursor> only for missing evidence.',
-    'Use sessions send <session-id> --steer -m "Additional context: focus on the resume path." --json for time-sensitive, decision-changing updates rather than routine reports: it prioritizes the update and may switch the current execution. Node decides delivery from actual state; an idle Session receives ordinary input. Choose exactly one of --steer or --queue, even when idle; missing, conflicting, repeated, or obsolete options are rejected locally before input is read or a request is sent. Use --queue to place input in a subsequent turn without interrupting active execution; during normal active work it waits for the current execution and earlier queued work, and can be delayed by an active Goal. Do not use it when the recipient needs the information during current work. New input resumes a paused queue using ordinary send admission after cancellation settles; later explicit stops still apply; with an active Goal, ordinary queued input waits until the Goal exits. start/send return clientMessageId and the accepted/queued result. A queued result may refer to the currently active Run: associate queueItemId/clientMessageId with history before deciding that input finished. There are no queue-item edit/delete/reorder commands; show returns only queuedCount.',
+    'Use sessions send <session-id> --steer -m "Additional context: focus on the resume path." --json as the preferred delivery for timely cross-Session coordination: blockers, decision requests, corrections, and results the recipient is waiting for. Do not queue a result merely because it is a report; omit routine progress chatter. Steer prioritizes the update, using native delivery when available, and may otherwise switch the current execution. Node decides delivery from actual state; an idle Session receives ordinary input. Choose exactly one of --steer or --queue, even when idle; missing, conflicting, repeated, or obsolete options are rejected locally before input is read or a request is sent. Use --queue only for deliberately deferred follow-up work that should run after the current execution, without interrupting it; during normal active work it waits for the current execution and earlier queued work, and can be delayed by an active Goal. Do not use it when the recipient needs the information during current work. New input resumes a paused queue using ordinary send admission after cancellation settles; later explicit stops still apply; with an active Goal, ordinary queued input waits until the Goal exits. start/send return clientMessageId and the accepted/queued result. A queued result may refer to the currently active Run: associate queueItemId/clientMessageId with history before deciding that input finished. There are no queue-item edit/delete/reorder commands; show returns only queuedCount.',
     'Wait with sessions wait <session-id> --run <run-id> --timeout 5m --json through the existing Watch. Prefer --timeout 5m when blocked on task completion; use 30s for a short deadline. Continue useful independent work before waiting. If your shell tool returns a running process or cell, reuse its process/cell handle rather than starting another wait or polling show/list. A timeout may include progress, the last observed snapshot, not a fresh query. Timeout or cancelled waiting does not stop the task. Use sessions stop <session-id> --run <run-id> --json only to stop that active Run; ownership rules still apply.',
     'Use wait --until approval to return early when a Run needs a decision. Inspect show/history, then use sessions approval decide <session-id> --run <public-run-id> --approval <approval-id> --decision approve|reject --json for one explicitly authorized request. This does not grant authority or auto-approve tools. Acknowledgment is not completion; observe status/history and wait again as needed.',
     'Goal get/set/clear use the existing Session Goal semantics; see marctl help sessions. A Coordinator can work from ordinary messages or its existing schedule without a Goal. Worker completion never automatically wakes it. Actively wait/read results, or finish and reconcile on the next user message or scheduled input.',

package/dist/runner/abstract-runner.js

@@ -65,16 +65,8 @@ export class AbstractRunner {
     usesRunnerTitleForRename() {
         return false;
     }
-    async renameNative(session, input, database) {
-        if (session.externalSessionId === null)
-            return;
-        database.saveNativeSessionMetadata({
-            runner: session.runner,
-            externalSessionId: session.externalSessionId,
-            workspaceId: session.workspaceId,
-            ...(input.title === undefined ? {} : { customTitle: input.title }),
-            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
-        });
+    async renameNative(session, input) {
+        void [session, input];
     }
     async removeNative(session, nativeSessionId) {
         void [session, nativeSessionId];
@@ -96,9 +88,8 @@ export class AbstractRunner {
         void session;
         throw new RunnerCapabilityError(this.name, 'session.clear');
     }
-    projectedRunnerTitle(metadata, input, database) {
-        void database;
-        return input.title ?? metadata?.runnerTitle ?? null;
+    projectedRunnerTitle(metadata, input) {
+        return { title: input.title ?? metadata?.runnerTitle ?? null, clearPending: false };
     }
     managedAliasId(nativeSessionId) {
         void nativeSessionId;

package/dist/{claude-agent-sdk.js → runner/claude/claude-agent-sdk.js}

@@ -1,9 +1,9 @@
-import { NODE_MCP, NODE_MCP_VERSION } from './mcp/naming.js';
+import { NODE_MCP, NODE_MCP_VERSION } from '../../mcp/naming.js';
 import { spawnSync } from 'node:child_process';
 import { createSdkMcpServer, forkSession, getSessionInfo, getSessionMessages, listSessions, query } from '@anthropic-ai/claude-agent-sdk';
 import { tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
-import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
+import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from '../../operational.js';
 const nativeBindings = {
     query,
     listSessions,

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

@@ -1,4 +1,5 @@
-import { boundedConversationItemId, isPlainRecord, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 import { claudeContentBlocks } from './message-parsers.js';
 export function extractClaudeThinkingText(record) {
     return claudeContentBlocks(record).flatMap((block) => {

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

@@ -1,16 +1,16 @@
 import { claudeAssistantBlocks, extractClaudeThinkingText } from './conversation-parser.js';
 import { ClaudeUsageNormalizer } from './tool-normalizer.js';
 import { createEnvelope } from '@myagentroam/protocol';
-import { ClaudeChannelGate } from '../../claude-channel.js';
+import { ClaudeChannelGate } from './claude-channel.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
-import { boundedConversationItemId, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
 import { extractClaudeText, extractClaudeToolUses } from './message-parsers.js';
 import { claudePlanText } from './conversation-parser.js';
 import { normalizeClaudeTool, extractClaudeToolResults } from './tool-normalizer.js';
 import { claudeContentBlocks } from './message-parsers.js';
-import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { parseSecretEnvironment } from '../../mcp/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
-import { runnerErrorProjection } from '../../util/runner-error.js';
+import { runnerErrorProjection } from '../runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 export class ClaudeManagedRunController {
@@ -81,7 +81,7 @@ export class ClaudeManagedRunController {
             typeof payload.input !== 'string' ||
             typeof payload.cwd !== 'string' ||
             this.host.intercepted() ||
-            this.host.active.has(payload.runId))
+            this.host.isExecutionActive(payload.runId))
             return;
         const runId = payload.runId;
         const sessionId = payload.sessionId;
@@ -123,7 +123,7 @@ export class ClaudeManagedRunController {
             this.host.emit(runId, 'run.rejected', { code: 'SESSION_ACTIVATION_REQUIRED' }, 'FAILED');
             return;
         }
-        this.host.active.add(runId);
+        this.host.executionAccepted(runId);
         this.host.emit(runId, 'run.started', {}, 'STARTING');
         if (contextCompactionItemId !== undefined)
             this.host.emitItem(runId, {
@@ -166,7 +166,6 @@ export class ClaudeManagedRunController {
             this.host.emit(runId, eventType, projected ?? eventPayload, status);
             this.runner.execution.runs.delete(runId);
             handle?.cancel();
-            this.host.active.delete(runId);
         };
         try {
             const gate = new ClaudeChannelGate(sessionId);

package/dist/runner/claude/message-parsers.js

@@ -1,4 +1,5 @@
-import { compactRunnerText, compactRunnerValue, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 export function extractClaudeText(message) {
     return claudeContentBlocks(message)
         .flatMap((block) => block.type === 'text' && typeof block.text === 'string' ? [block.text] : [])

package/dist/runner/claude/native-transcript.js

@@ -1,7 +1,8 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { forEachJsonlRecord } from '../../native-jsonl-reader.js';
-import { compactRunnerValue as compactValue, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { compactRunnerValue as compactValue } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 import { stripGoalStartPrompt, publicGoalHistoryText } from '../../service/goal-runtime.js';
 import { readdir } from 'node:fs/promises';
 import { stripClaudePlanTag } from '../../runner-command-engine.js';

package/dist/runner/claude/tool-normalizer.js

@@ -1,5 +1,5 @@
 import { claudeContentBlocks } from './message-parsers.js';
-import { compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue } from '../normalization.js';
 import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';
 export class ClaudeUsageNormalizer {
     tracker;

package/dist/runner/claude-code-runner.js

@@ -1,12 +1,12 @@
 import { withMarctlGuide } from '../mcp/marctl-guide.js';
-import { ClaudeAgentSdkAdapter } from '../claude-agent-sdk.js';
+import { ClaudeAgentSdkAdapter } from './claude/claude-agent-sdk.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { claudeDefaultModel, declaredRunnerProfiles } from '../runner-profiles.js';
 import { withClaudePlanTag } from '../runner-command-engine.js';
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
 import { readClaudeNativeContextUsage } from './claude/native-context-usage.js';
 import { claudeDiscoveredSession } from './claude/conversation-parser.js';
-import { deduplicateDirectSessions, isNativeHistory, isWithinWorkspace, latestNativeActivity } from '../util/runner-native-session-parsers.js';
+import { deduplicateDirectSessions, isNativeHistory, isWithinWorkspace, latestNativeActivity } from '../session/runner-native-session-parsers.js';
 export class ClaudeCodeRunner extends AbstractRunner {
     client;
     environment;