@myagentroam/node 0.9.96 → 0.9.98

package/dist/codex-app-server.js

@@ -9,22 +9,11 @@ import { createInterface } from 'node:readline';
 import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
 const REQUEST_TIMEOUT_MS = 15_000;
 /**
- * Maps the facts that the Node can actually establish to user-visible
- * controls.  In particular, seeing an external thread never implies that it
- * is safe to write to its active turn.
+ * Maps the facts that the Node can establish to the unified session controls.
+ * Native-session activation is validated atomically with the first message.
  */
 export function codexSessionControl(input) {
-    if (!input.available)
-        return { level: 'UNAVAILABLE', capabilities: [] };
-    if (input.sharedControl) {
-        return {
-            level: 'SHARED_CONTROL',
-            capabilities: ['history.read', 'events.live', 'turn.start', 'turn.steer', 'turn.interrupt']
-        };
-    }
-    if (input.nativeThreadId !== null && input.nativeControl === 'EXTERNAL') {
-        return { level: 'OBSERVE_ONLY', capabilities: ['history.read'] };
-    }
+    void [input.available, input.nativeThreadId, input.nativeControl];
     if (input.activeTurn) {
         return {
             level: 'MANAGED',
@@ -32,7 +21,7 @@ export function codexSessionControl(input) {
         };
     }
     return {
-        level: 'RESUMABLE',
+        level: 'MANAGED',
         capabilities: ['history.read', 'turn.start']
     };
 }

package/dist/connector.js

@@ -635,7 +635,6 @@ export class NodeConnector {
             runners: this.runners,
             capabilities: () => this.capabilities,
             hasManagedActiveRun: (session) => hasManagedActiveRun(this.runtime, session),
-            externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
             projectionForNative: (session) => this.nativeSessionProjectionService.projectionForNative(session)
         });
         this.nativeSessionProjectionService = new NativeSessionProjectionService({
@@ -851,28 +850,12 @@ export class NodeConnector {
             configuration: (session) => this.nativeSessionProjectionService.resumedConfiguration(session),
             workspacePath: (workspaceId) => this.database?.getWorkspace(workspaceId)?.path,
             rememberNative: (nativeSessionId, sessionId) => this.managedRunnerSessions.remember(nativeSessionId, sessionId),
-            stage: (session) => {
-                const configuration = this.nativeSessionProjectionService.resumedConfiguration(session);
-                return this.runtime.createAgentSession({
-                    workspaceId: session.workspaceId,
-                    runner: session.runner,
-                    externalSessionId: session.externalSessionId ?? session.id,
-                    nativeControl: 'EXTERNAL',
-                    cwd: session.cwd,
-                    model: configuration.model,
-                    effort: configuration.effort,
-                    access: configuration.access,
-                    ...(session.runnerTitle === null ? {} : { title: session.runnerTitle }),
-                    ...(session.customTitle === null ? {} : { customTitle: session.customTitle })
-                });
-            },
             resolve: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId)
         });
         this.sessionCommandService = new SessionCommandService({
             runtime: this.runtime,
             runners: this.runners,
             projection: this.nativeSessionProjectionService,
-            resume: this.externalSessionResumeService,
             profiles: () => this.runnerService.profiles(),
             present: (session) => this.sessionPresentationService.present(session),
             resumeQueueAfterCommandRun: (sessionId) => this.workspaceQueueWorkbenchService.resumeAfterCommandRun(sessionId),
@@ -1018,7 +1001,6 @@ export class NodeConnector {
             runtime: this.runtime,
             runners: this.runners,
             projection: this.nativeSessionProjectionService,
-            resume: this.externalSessionResumeService,
             cachedNative: () => [...this.sessionState.directNative.values()],
             cachedWorkspace: (workspaceId) => this.workspaceCoordinator.cachedSessions(workspaceId),
             discoverWorkspace: (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId),

package/dist/ctags-binary.js

@@ -1,3 +1,4 @@
+import { chmod } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 export const BUNDLED_CTAGS_VERSION = '6.2.1';
@@ -16,3 +17,12 @@ export function bundledCtagsPath(platform = process.platform, architecture = pro
         throw new Error('CTAGS_PLATFORM_UNSUPPORTED');
     return resolve(bundledCtagsDirectory(packageRoot), ...target);
 }
+/**
+ * Restores the execute bit when an installation mechanism lost the bundled
+ * Linux binary's archive mode. Explicit Ctags overrides are never modified.
+ */
+export async function repairBundledCtagsExecutable(platform = process.platform, architecture = process.arch, packageRoot) {
+    if (platform !== 'linux')
+        return;
+    await chmod(bundledCtagsPath(platform, architecture, packageRoot), 0o755);
+}

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

@@ -115,7 +115,7 @@ export class ClaudeManagedRunController {
             return;
         if (typeof payload.externalSessionId === 'string' &&
             !this.runner.execution.managedNativeIds.has(payload.externalSessionId)) {
-            this.host.emit(runId, 'run.rejected', { code: 'EXTERNAL_SESSION_OBSERVE_ONLY' }, 'FAILED');
+            this.host.emit(runId, 'run.rejected', { code: 'SESSION_ACTIVATION_REQUIRED' }, 'FAILED');
             return;
         }
         this.host.active.add(runId);

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

@@ -147,62 +147,28 @@ export class ClaudeCodeRunner extends AbstractRunner {
             : this.client.forkSession(session.externalSessionId, session.cwd, boundary, title);
     }
     presentSession(session, capabilities, context) {
-        if (capabilities.claudeCode.available && session.nativeControl === 'MAR_MANAGED') {
-            const runtimeCapabilities = [
-                'history.read',
-                'events.live',
-                'turn.start',
-                'turn.queue',
-                'turn.interrupt',
-                'run.cancel',
-                'approval.respond',
-                'session.rename',
-                'session.remove',
-                'session.pin',
-                ...(session.externalSessionId === null ? [] : ['session.rewind'])
-            ];
-            return {
-                activity: context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE',
-                control: {
-                    level: 'MANAGED',
-                    capabilities: ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
-                },
-                commandStates: context.commandStates,
-                runtime: { level: 'MANAGED', capabilities: runtimeCapabilities, reasonCode: null }
-            };
-        }
-        if (capabilities.claudeCode.available && session.externalSessionId !== null) {
-            const runtimeCapabilities = [
-                'history.read',
-                'turn.start',
-                'session.rename',
-                'session.remove',
-                'session.pin',
-                'session.rewind'
-            ];
-            return {
-                activity: 'IDLE',
-                control: { level: 'RESUMABLE', capabilities: ['history.read', 'turn.start'] },
-                commandStates: context.commandStates,
-                runtime: { level: 'RESUMABLE', capabilities: runtimeCapabilities, reasonCode: null }
-            };
-        }
+        void capabilities;
         const runtimeCapabilities = [
             'history.read',
             'events.live',
+            'turn.start',
+            'turn.queue',
+            'turn.interrupt',
+            'run.cancel',
+            'approval.respond',
             'session.rename',
             'session.remove',
-            'session.pin'
+            'session.pin',
+            ...(session.externalSessionId === null ? [] : ['session.rewind'])
         ];
         return {
-            activity: 'UNAVAILABLE',
-            control: { level: 'OBSERVE_ONLY', capabilities: ['history.read', 'events.live'] },
+            activity: context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE',
+            control: {
+                level: 'MANAGED',
+                capabilities: ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
+            },
             commandStates: context.commandStates,
-            runtime: {
-                level: 'OBSERVE_ONLY',
-                capabilities: runtimeCapabilities,
-                reasonCode: 'EXTERNAL_SESSION_OBSERVE_ONLY'
-            }
+            runtime: { level: 'MANAGED', capabilities: runtimeCapabilities, reasonCode: null }
         };
     }
     prepareMessageInput(input, collaborationMode) {

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

@@ -357,7 +357,7 @@ export class CodexManagedRunController {
         }
         if (typeof payload.externalSessionId === 'string' &&
             (session === undefined || session.nativeControl !== 'MAR_MANAGED')) {
-            this.host.emit(runId, 'run.rejected', { code: 'EXTERNAL_THREAD_OBSERVE_ONLY' }, 'FAILED');
+            this.host.emit(runId, 'run.rejected', { code: 'SESSION_ACTIVATION_REQUIRED' }, 'FAILED');
             return;
         }
         try {

package/dist/runner/codex-runner.js

@@ -309,10 +309,7 @@ export class CodexRunner extends AbstractRunner {
             return { activity: 'IDLE', session: context.create(external) };
         }
         catch {
-            return {
-                activity: 'UNAVAILABLE',
-                failureCode: 'RUNNER_RESUME_FAILED'
-            };
+            return { failureCode: 'RUNNER_RESUME_FAILED' };
         }
     }
     async discoverSessions(context, workspace) {
@@ -391,13 +388,7 @@ export class CodexRunner extends AbstractRunner {
             nativeControl: session.nativeControl,
             activeTurn
         });
-        const activity = !capabilities.codex.available
-            ? 'UNAVAILABLE'
-            : context.managedActive
-                ? 'MANAGED_ACTIVE'
-                : session.nativeControl === 'EXTERNAL'
-                    ? (context.externalActivity ?? 'IDLE')
-                    : 'IDLE';
+        const activity = context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE';
         return {
             control,
             activity,
@@ -406,13 +397,15 @@ export class CodexRunner extends AbstractRunner {
                 level: control.level,
                 capabilities: [
                     ...control.capabilities,
-                    ...(control.level === 'MANAGED' ? ['turn.queue', 'run.cancel', 'approval.respond'] : []),
+                    'turn.queue',
+                    'run.cancel',
+                    'approval.respond',
                     'session.rename',
                     'session.remove',
                     'session.pin',
                     ...(session.externalSessionId === null ? [] : ['session.rewind'])
                 ],
-                reasonCode: control.level === 'UNAVAILABLE' ? 'RUNNER_UNAVAILABLE' : null
+                reasonCode: null
             }
         };
     }

package/dist/runner/mar-agent-runner.js

@@ -170,14 +170,7 @@ export class MarAgentRunner extends AbstractRunner {
         };
     }
     presentSession(session, capabilities, context) {
-        if (!this.available(capabilities))
-            return {
-                activity: 'UNAVAILABLE',
-                control: { level: 'UNAVAILABLE', capabilities: [] },
-                runtime: { level: 'UNAVAILABLE', capabilities: [], reasonCode: 'RUNNER_UNAVAILABLE' },
-                commandStates: context.commandStates
-            };
-        const managed = session.nativeControl === 'MAR_MANAGED';
+        void capabilities;
         const activity = context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE';
         const runtimeCapabilities = [
             'history.read',
@@ -195,11 +188,11 @@ export class MarAgentRunner extends AbstractRunner {
         return {
             activity,
             control: {
-                level: managed ? 'MANAGED' : 'RESUMABLE',
+                level: 'MANAGED',
                 capabilities: ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
             },
             runtime: {
-                level: managed ? 'MANAGED' : 'RESUMABLE',
+                level: 'MANAGED',
                 capabilities: runtimeCapabilities,
                 reasonCode: null
             },

package/dist/runner/opencode-runner.js

@@ -206,7 +206,7 @@ export class OpenCodeRunner extends AbstractRunner {
         const projection = context.projectionFor(external);
         const session = projection === undefined ? context.create(external) : context.promote(projection.id);
         return session === undefined
-            ? { activity: 'UNAVAILABLE', failureCode: 'RUNNER_RESUME_FAILED' }
+            ? { failureCode: 'RUNNER_RESUME_FAILED' }
             : { activity: 'IDLE', session: context.ensureConfiguration(session) };
     }
     async readOfficialConversation(session, input, managedTurn) {
@@ -227,18 +227,8 @@ export class OpenCodeRunner extends AbstractRunner {
         return this.managedTurns.get(nativeTurnId);
     }
     presentSession(session, capabilities, context) {
-        const available = capabilities.openCode?.available === true;
-        const managed = session.nativeControl === 'MAR_MANAGED';
-        const activity = context.managedActive
-            ? 'MANAGED_ACTIVE'
-            : (context.externalActivity ?? (available ? 'IDLE' : 'UNAVAILABLE'));
-        if (!available)
-            return {
-                activity: 'UNAVAILABLE',
-                control: { level: 'UNAVAILABLE', capabilities: [] },
-                runtime: { level: 'UNAVAILABLE', capabilities: [], reasonCode: 'RUNNER_UNAVAILABLE' },
-                commandStates: context.commandStates
-            };
+        void capabilities;
+        const activity = context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE';
         const runtimeCapabilities = [
             'history.read',
             'events.live',
@@ -256,15 +246,13 @@ export class OpenCodeRunner extends AbstractRunner {
         return {
             activity,
             control: {
-                level: managed ? 'MANAGED' : activity === 'IDLE' ? 'RESUMABLE' : 'OBSERVE_ONLY',
-                capabilities: managed || activity === 'IDLE'
-                    ? ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
-                    : ['history.read', 'events.live']
+                level: 'MANAGED',
+                capabilities: ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
             },
             runtime: {
-                level: managed ? 'MANAGED' : activity === 'IDLE' ? 'RESUMABLE' : 'OBSERVE_ONLY',
+                level: 'MANAGED',
                 capabilities: runtimeCapabilities,
-                reasonCode: activity === 'EXTERNAL_ACTIVE' ? 'EXTERNAL_SESSION_OBSERVE_ONLY' : null
+                reasonCode: null
             },
             commandStates: context.commandStates
         };

package/dist/service/code-navigation/c-family-path-specifier-resolver.js

@@ -0,0 +1,40 @@
+import { posix } from 'node:path';
+import { matchesPathSuffix } from './path-specifier-resolver.js';
+function accepts(value) {
+    return /^(?:\.\.?\/)?(?:[A-Za-z0-9_$+.-]+\/)*[A-Za-z0-9_$+.-]+$/u.test(value);
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).some((candidate) => path === candidate || matchesPathSuffix(path, candidate));
+}
+function score(path, currentPath, specifier) {
+    const resolvedCandidates = candidates(currentPath, specifier);
+    const exact = resolvedCandidates.indexOf(path);
+    if (exact >= 0)
+        return exact;
+    const suffix = resolvedCandidates.findIndex((candidate) => matchesPathSuffix(path, candidate));
+    return suffix >= 0 ? resolvedCandidates.length + suffix + path.length : Number.MAX_SAFE_INTEGER;
+}
+function candidates(currentPath, specifier) {
+    const relative = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (relative.startsWith('../') || relative === '..' || relative === specifier)
+        return [specifier];
+    return [relative.replace(/^\.\//u, ''), specifier];
+}
+export const cFamilyPathSpecifierResolver = {
+    id: 'c-family.path-specifier',
+    accepts,
+    directCandidates: candidates,
+    matches,
+    score
+};
+function createCFamilyNavigationResolutionDefinition(languageId) {
+    return {
+        languageId,
+        resolver: { ...cFamilyPathSpecifierResolver, id: `${languageId}.path-specifier` }
+    };
+}
+export const cNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('c');
+export const cppNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('cpp');
+export const objectiveCNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('objective-c');
+export const objectiveCppNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('objective-cpp');
+export const cFamilyNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('c-family');

package/dist/service/code-navigation/csharp-path-specifier-resolver.js

@@ -0,0 +1,32 @@
+import { matchesPathSuffix } from './path-specifier-resolver.js';
+function accepts(value) {
+    return /^[\p{L}_\p{Nl}][\p{L}\p{Nl}\p{Nd}\p{Pc}\p{Mn}\p{Mc}]*(?:\.[\p{L}_\p{Nl}][\p{L}\p{Nl}\p{Nd}\p{Pc}\p{Mn}\p{Mc}]*)*$/u.test(value);
+}
+function matches(path, _currentPath, specifier) {
+    if (!path.endsWith('.cs'))
+        return false;
+    return namespaceSuffixes(specifier).some((suffix) => matchesPathSuffix(path, `${suffix}.cs`) ||
+        path.startsWith(`${suffix}/`) ||
+        path.includes(`/${suffix}/`));
+}
+function score(path, _currentPath, specifier) {
+    const suffixes = namespaceSuffixes(specifier);
+    const index = suffixes.findIndex((suffix) => matchesPathSuffix(path, `${suffix}.cs`) ||
+        path.startsWith(`${suffix}/`) ||
+        path.includes(`/${suffix}/`));
+    return index < 0 ? Number.MAX_SAFE_INTEGER : index * 10_000 + path.length;
+}
+function namespaceSuffixes(specifier) {
+    const segments = specifier.split('.');
+    return segments.map((_, index) => segments.slice(index).join('/'));
+}
+export const csharpPathSpecifierResolver = {
+    id: 'csharp.path-specifier',
+    accepts,
+    matches,
+    score
+};
+export const csharpNavigationResolutionDefinition = {
+    languageId: 'csharp',
+    resolver: csharpPathSpecifierResolver
+};