@myagentroam/node 0.12.4 → 0.12.6

package/dist/runner/codex-runner.js

@@ -389,16 +389,18 @@ export class CodexRunner extends AbstractRunner {
             return { failureCode: 'RUNNER_RESUME_FAILED' };
         }
     }
-    async cleanupThreads() {
+    async cleanupThreads(signal) {
         await this.start();
         const threads = [];
         const cursors = new Set();
         let cursor;
         for (;;) {
+            signal?.throwIfAborted();
             const result = await this.client.listThreads({
                 limit: 200,
                 ...(cursor === undefined ? {} : { cursor })
             });
+            signal?.throwIfAborted();
             if (!isPlainRecord(result) ||
                 !Array.isArray(result.data) ||
                 result.data.some((entry) => !isPlainRecord(entry) ||
@@ -418,21 +420,25 @@ export class CodexRunner extends AbstractRunner {
         }
     }
     async discoverSessions(context, workspace) {
+        context.signal?.throwIfAborted();
         const [threads, nativeSessions] = context.cleanup
-            ? [await this.cleanupThreads(), []]
+            ? [await this.cleanupThreads(context.signal), []]
             : await Promise.all([
                 (async () => {
                     try {
                         await this.start();
-                        return extractCodexThreads(await this.listThreads());
+                        context.signal?.throwIfAborted();
+                        return extractCodexThreads(await this.listThreads(context.signal));
                     }
                     catch {
+                        context.signal?.throwIfAborted();
                         // Native transcripts remain a valid read-only discovery source.
                         return [];
                     }
                 })(),
                 discoverAllNativeSessions(this.name)
             ]);
+        context.signal?.throwIfAborted();
         const sessions = [];
         for (const thread of threads) {
             if (thread.derived || (thread.source !== 'cli' && thread.source !== 'vscode'))
@@ -642,8 +648,9 @@ export class CodexRunner extends AbstractRunner {
     respond(requestId, result, runId) {
         this.clientFor(runId).respond(requestId, result);
     }
-    async listThreads() {
+    async listThreads(signal) {
         const result = await this.client.listThreads();
+        signal?.throwIfAborted();
         this.observeThreadHistoryModes(result);
         return result;
     }

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

@@ -129,7 +129,8 @@ const collaborationPrompt = [
     "Use native agent_* tools to collaborate within the Agent Network when another Session's context or ongoing work materially helps. Prefer focused requests and avoid unnecessary cross-Session coordination. Peer Sessions retain their own work and lifecycle; do not treat them as task-owned children or stop them merely for task cleanup.",
     'Prefer reusing known Session IDs rather than rediscovering them. Updates are most useful when requested or when the recipient needs to decide or change course; prefer combining related updates.',
     'An accepted message normally needs no separate acknowledgment. Requests for receipt-only replies and immediate agent_view calls solely to confirm receipt are usually unnecessary.',
-    'For delegated work, prefer a concise final handoff over routine progress reports or duplicate completion messages. Early contact is most useful for requested updates, blockers, scope conflicts, or information needed for a decision.'
+    'The parent automatically collects the latest unread public reply and terminal state from each observed direct child before its next natural model request. Usually reply in the child Session itself rather than sending duplicate progress or completion reports with agent_send.',
+    'Contact the parent proactively when timely action or a decision is needed, such as a blocker, scope conflict or major risk, or when explicitly asked to report. Routine child updates usually need no reply; prefer combining related guidance.'
 ].join('\n\n');
 const managementPrompt = [
     '# Workspace management',

package/dist/runner/opencode/opencode-server.js

@@ -4,11 +4,15 @@ import { createServer } from 'node:net';
 import { minimalRunnerEnvironment, platformCliInvocation } from '../../operational.js';
 import { terminateProcessTree } from '../../process-tree.js';
 const START_TIMEOUT_MS = 10_000;
+/** Owns one supervised backend and its startup I/O. Request cancellation is caller-scoped;
+ * Stopping cancels startup and joins it along with child termination.
+ */
 export class OpenCodeServerClient {
     options;
     child;
     client;
     starting;
+    startingController;
     environment = {};
     constructor(options = {}) {
         this.options = options;
@@ -23,19 +27,25 @@ export class OpenCodeServerClient {
             return;
         if (this.starting !== undefined)
             return this.starting;
-        const starting = this.startServer();
+        const controller = new AbortController();
+        const starting = this.startServer(controller.signal);
+        this.startingController = controller;
         this.starting = starting;
         try {
             await starting;
         }
         finally {
-            if (this.starting === starting)
+            if (this.starting === starting) {
                 this.starting = undefined;
+                this.startingController = undefined;
+            }
         }
     }
-    async startServer() {
+    async startServer(signal) {
         const { createOpencodeClient } = await import('@opencode-ai/sdk/v2/client');
+        signal.throwIfAborted();
         const port = await availablePort();
+        signal.throwIfAborted();
         const password = randomBytes(24).toString('base64url');
         const invocation = platformCliInvocation(this.options.command ?? 'opencode', [
             'serve',
@@ -65,11 +75,12 @@ export class OpenCodeServerClient {
             throwOnError: true
         });
         try {
-            await waitUntilHealthy(`http://127.0.0.1:${port}/global/health`, authorization, child, this.options.startTimeoutMs ?? START_TIMEOUT_MS);
+            await waitUntilHealthy(`http://127.0.0.1:${port}/global/health`, authorization, child, this.options.startTimeoutMs ?? START_TIMEOUT_MS, signal);
+            signal.throwIfAborted();
             this.client = client;
         }
         catch (error) {
-            await this.stop();
+            await this.stopChild(child);
             throw error;
         }
     }
@@ -89,9 +100,11 @@ export class OpenCodeServerClient {
             });
         }
     }
-    async sessions(directory, limit = 100) {
+    async sessions(directory, limit = 100, signal) {
+        signal?.throwIfAborted();
         const client = await this.requireClient();
-        return unwrap(await client.session.list({ directory, limit }));
+        signal?.throwIfAborted();
+        return unwrap(await client.session.list({ directory, limit }, { signal: signal ?? null }));
     }
     async session(directory, sessionID) {
         const client = await this.requireClient();
@@ -238,11 +251,17 @@ export class OpenCodeServerClient {
         }
     }
     async stop() {
+        this.startingController?.abort(new Error('OPENCODE_SERVER_STOPPED'));
+        const starting = this.starting;
         this.client = undefined;
-        const child = this.child;
-        this.child = undefined;
-        if (child === undefined)
+        await this.stopChild(this.child);
+        if (starting !== undefined)
+            await Promise.allSettled([starting]);
+    }
+    async stopChild(child) {
+        if (child === undefined || this.child !== child)
             return;
+        this.child = undefined;
         if (child.pid === undefined) {
             child.kill('SIGTERM');
             return;
@@ -280,24 +299,30 @@ async function availablePort() {
         });
     });
 }
-async function waitUntilHealthy(url, authorization, child, timeoutMs) {
+async function waitUntilHealthy(url, authorization, child, timeoutMs, signal) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
+        signal.throwIfAborted();
         if (child.exitCode !== null)
             throw new Error('OPENCODE_SERVER_EXITED');
         try {
             const response = await fetch(url, {
                 headers: { authorization },
-                signal: AbortSignal.timeout(Math.min(1_000, Math.max(1, deadline - Date.now())))
+                signal: AbortSignal.any([
+                    signal,
+                    AbortSignal.timeout(Math.min(1_000, Math.max(1, deadline - Date.now())))
+                ])
             });
             if (response.ok)
                 return;
         }
         catch {
+            signal.throwIfAborted();
             // The child may still be binding its loopback socket.
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
     }
+    signal.throwIfAborted();
     throw new Error('OPENCODE_SERVER_START_TIMEOUT');
 }
 function unwrap(result) {

package/dist/runner/opencode-runner.js

@@ -196,15 +196,18 @@ export class OpenCodeRunner extends AbstractRunner {
     async discoverSessions(context, workspace) {
         const result = [];
         for (const target of workspace === undefined ? context.workspaces : [workspace]) {
+            context.signal?.throwIfAborted();
             let sessions;
             try {
-                sessions = await this.client.sessions(target.path);
+                sessions = await this.client.sessions(target.path, 100, context.signal);
             }
             catch (error) {
+                context.signal?.throwIfAborted();
                 if (context.cleanup)
                     throw error;
                 continue;
             }
+            context.signal?.throwIfAborted();
             for (const value of sessions) {
                 const session = openCodeSession(value);
                 if (session === undefined ||
@@ -213,7 +216,8 @@ export class OpenCodeRunner extends AbstractRunner {
                     continue;
                 const title = context.cleanup
                     ? { title: session.title, titleOrigin: 'OFFICIAL' }
-                    : await this.sessionTitle(session);
+                    : await this.sessionTitle(session, context.signal);
+                context.signal?.throwIfAborted();
                 result.push(context.createProjection({
                     workspace: target,
                     runner: this.name,
@@ -237,16 +241,18 @@ export class OpenCodeRunner extends AbstractRunner {
             return undefined;
         return (await this.sessionTitle(native)).title;
     }
-    async sessionTitle(session) {
+    async sessionTitle(session, signal) {
+        signal?.throwIfAborted();
         const nativeTitle = session.title.trim();
         if (nativeTitle.length === 0 ||
             /^(?:new|untitled) session(?:\s*[-–—:]\s*\d{4}-\d{2}-\d{2}.*)?$/iu.test(nativeTitle)) {
             try {
-                const preview = await this.firstUserMessagePreview(session);
+                const preview = await this.firstUserMessagePreview(session, signal);
                 if (preview)
                     return { title: preview, titleOrigin: 'PREVIEW' };
             }
             catch (error) {
+                signal?.throwIfAborted();
                 nodeLog('runner.opencode.title.failed', {
                     sessionId: session.id,
                     stage: 'preview',
@@ -256,10 +262,12 @@ export class OpenCodeRunner extends AbstractRunner {
         }
         return { title: session.title, titleOrigin: 'OFFICIAL' };
     }
-    async firstUserMessagePreview(session) {
+    async firstUserMessagePreview(session, signal) {
         const key = `${session.directory}\0${session.id}`;
         const cached = this.titlePreviews.get(key);
+        // Only in-flight reads share a cancellation owner; completed values retain their cache lifetime.
         if (cached !== undefined &&
+            (cached.fulfilled || cached.signal === signal) &&
             cached.updatedAt === session.updatedAt &&
             cached.expiresAt > Date.now())
             return cached.result;
@@ -267,6 +275,8 @@ export class OpenCodeRunner extends AbstractRunner {
         if (this.titlePreviews.size >= MAX_TITLE_PREVIEWS)
             this.titlePreviews.delete(this.titlePreviews.keys().next().value);
         const entry = {
+            signal,
+            fulfilled: false,
             updatedAt: session.updatedAt,
             expiresAt: Date.now() + TITLE_PREVIEW_TTL_MS,
             result: (async () => {
@@ -274,10 +284,12 @@ export class OpenCodeRunner extends AbstractRunner {
                 let preview;
                 const cursors = new Set();
                 for (;;) {
+                    signal?.throwIfAborted();
                     const page = await this.client.messagePage(session.directory, session.id, {
                         limit: 100,
                         ...(before === undefined ? {} : { before })
-                    });
+                    }, signal);
+                    signal?.throwIfAborted();
                     preview = openCodeUserMessagePreview(page.messages) ?? preview;
                     if (page.nextCursor === null)
                         return preview;
@@ -290,7 +302,9 @@ export class OpenCodeRunner extends AbstractRunner {
         };
         this.titlePreviews.set(key, entry);
         try {
-            return await entry.result;
+            const preview = await entry.result;
+            entry.fulfilled = true;
+            return preview;
         }
         catch (error) {
             if (this.titlePreviews.get(key) === entry)

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

@@ -0,0 +1,60 @@
+import { agentObservationFromRunEvent } from './agent-network-observations.js';
+import { sessionPendingApprovals } from './session-recent-activity.js';
+/** Projects normalized Run events and owns transient observers from attachment through terminal cleanup.
+ * Run-keyed handles survive Session identity promotion without borrowing a replacement's lifetime.
+ * Runner-owned context observers remain with the Runner; this owner only borrows their delivery port.
+ */
+export class AgentNetworkRunProjection {
+    runtime;
+    observations;
+    transient = new Map();
+    constructor(runtime, observations) {
+        this.runtime = runtime;
+        this.observations = observations;
+    }
+    ensureObservations = (actor) => {
+        const existing = this.observations.get(actor.observationId ?? actor.sessionId);
+        if (existing)
+            return existing;
+        const run = actor.runId === undefined ? undefined : this.runtime.getRun(actor.runId);
+        if (!run ||
+            run.sessionId !== actor.sessionId ||
+            this.runtime.activeSessionRun(actor.sessionId)?.id !== run.id)
+            throw new Error('AGENT_ACTOR_NOT_ACTIVE');
+        const observer = this.observations.attach(actor.sessionId);
+        this.transient.set(run.id, observer);
+        return observer;
+    };
+    accept = ({ run, executionId, eventType, payload, terminalStatus }) => {
+        const child = this.runtime.getAgentSession(run.sessionId);
+        if (!child)
+            return;
+        const parent = child.parentSessionId == null
+            ? undefined
+            : this.runtime.getAgentSession(child.parentSessionId);
+        let observation = agentObservationFromRunEvent({ eventType, payload, terminalStatus });
+        if (eventType === 'approval.request') {
+            const approvals = sessionPendingApprovals(this.runtime, child.id).pendingApprovals;
+            if (approvals.length)
+                observation = { kind: 'message', value: JSON.stringify({ pendingApprovals: approvals }) };
+        }
+        if (observation)
+            this.observations.publishChild({
+                ...(parent?.workspaceId === child.workspaceId ? { parentId: parent.id } : {}),
+                childId: child.id,
+                runId: run.id,
+                executionId,
+                ...observation
+            });
+        if (terminalStatus !== undefined) {
+            const observer = this.transient.get(run.id);
+            this.transient.delete(run.id);
+            observer?.close();
+        }
+    };
+    dispose() {
+        for (const observer of this.transient.values())
+            observer.close();
+        this.transient.clear();
+    }
+}

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

@@ -67,7 +67,7 @@ export async function validateComposerSkills(input, workspacePath, home = homedi
     const directories = new SkillDirectoryService();
     const [node, workspace] = await Promise.all([
         directories.inspectNodeHome(home),
-        directories.inspectWorkspace(workspacePath)
+        directories.inspectWorkspace(workspacePath, true, { includeClaudeCompatibility: false })
     ]);
     const effective = new Map(node.skills.map((skill) => [skill.name, { ...skill, source: 'NODE_HOME' }]));
     for (const skill of workspace.skills)

package/dist/service/session-recent-activity.js

@@ -76,7 +76,7 @@ function activity(runtime, sessionId) {
 }
 export function marctlSessionProgress(runtime, sessionId) {
     const { latestActivity: _latest, ...progress } = activity(runtime, sessionId);
-    return { ...progress, ...pendingApprovals(runtime, sessionId) };
+    return { ...progress, ...sessionPendingApprovals(runtime, sessionId) };
 }
 export function sessionActivityStatus(runtime, sessionId) {
     const run = runtime.activeSessionRun(sessionId);
@@ -100,7 +100,7 @@ function isSleepingTool(item) {
         typeof presentation.startedAt === 'string');
 }
 /** Summarizes current approval facts without exposing tool input or native payloads. */
-function pendingApprovals(runtime, sessionId) {
+export function sessionPendingApprovals(runtime, sessionId) {
     const run = runtime.activeSessionRun(sessionId);
     const executionId = run && runtime.currentExecutionId(run.id);
     const approvals = run && !isTerminalRunStatus(run.status)
@@ -150,7 +150,7 @@ export function marctlSessionDetail(runtime, session, queuedCount) {
         queuedCount,
         latestMessage,
         recentTools,
-        ...pendingApprovals(runtime, session.id)
+        ...sessionPendingApprovals(runtime, session.id)
     };
 }
 /** Agent state views omit execution identities; low-level CLI queries keep their own contract. */

package/dist/service/skill-directory-service.js

@@ -5,25 +5,27 @@ import { hasBrokenWorkspaceSkillGitExclude } from '../workspace/workspace-git-ex
 const MAX_METADATA_BYTES = 64 * 1024;
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
+/** Owns filesystem Skill inspection; effective lists exclude installation compatibility copies. */
 export class SkillDirectoryService {
-    async inspectNodeHome(home, options = {}) {
+    async inspectNodeHome(home) {
         const agentsRoot = path.join(home, '.agents', 'skills');
         const claudeRoot = path.join(home, '.claude', 'skills');
         const compatibilityMode = await nodeCompatibilityMode(agentsRoot, claudeRoot);
         const agents = await scanRoot(agentsRoot, 'AGENTS');
-        const claude = options.includeClaudeCompatibility === true && compatibilityMode !== 'UNAVAILABLE'
-            ? await scanRoot(claudeRoot, 'CLAUDE')
-            : [];
         return {
             targetKind: 'NODE',
             compatibilityMode,
-            skills: options.includeClaudeCompatibility === true
-                ? mergeNodeCompatibilityRoots(agents, claude)
-                : agents.map(withoutSource)
+            skills: agents.map(withoutSource)
         };
     }
-    async inspectWorkspace(workspace, includeParentRepository = true) {
+    async inspectWorkspace(workspace, includeParentRepository = true, options = {}) {
         const agents = await scanRoot(path.join(workspace, '.agents', 'skills'), 'AGENTS');
+        if (options.includeClaudeCompatibility === false)
+            return {
+                targetKind: 'WORKSPACE',
+                compatibilityMode: 'MANAGED_COPY',
+                skills: agents.map(withoutSource)
+            };
         const claude = await scanRoot(path.join(workspace, '.claude', 'skills'), 'CLAUDE');
         const skills = mergeWorkspaceCopies(agents, claude);
         const gitExcludeBroken = await hasBrokenWorkspaceSkillGitExclude(workspace, skills.map((skill) => skill.name), includeParentRepository);
@@ -181,29 +183,6 @@ function mergeWorkspaceCopies(agents, claude) {
         return withoutSource(copies.agents);
     });
 }
-function mergeNodeCompatibilityRoots(agents, claude) {
-    const byName = new Map();
-    for (const item of agents)
-        byName.set(item.name, { agents: item });
-    for (const item of claude)
-        byName.set(item.name, { ...byName.get(item.name), claude: item });
-    return [...byName.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([name, copies]) => {
-        if (copies.agents === undefined || copies.claude === undefined)
-            return withoutSource((copies.agents ?? copies.claude));
-        if (copies.agents.description !== copies.claude.description ||
-            copies.agents.localStatus !== copies.claude.localStatus ||
-            JSON.stringify(copies.agents.install) !== JSON.stringify(copies.claude.install))
-            return {
-                name,
-                description: copies.agents.description,
-                localStatus: 'PARTIAL',
-                skillFilePath: copies.agents.skillFilePath
-            };
-        return withoutSource(copies.agents);
-    });
-}
 function withoutSource(entry) {
     return {
         name: entry.name,

package/dist/service/skill-node-operation-service.js

@@ -17,18 +17,16 @@ export class SkillNodeOperationService {
     }
     operations() {
         return {
-            'node.skills.inspect': async (data) => {
+            'node.skills.inspect': async (_data) => {
                 await this.installer.recoverNodeHome(homedir());
-                return this.directories.inspectNodeHome(homedir(), {
-                    includeClaudeCompatibility: record(data)['includeClaudeCompatibility'] === true
-                });
+                return this.directories.inspectNodeHome(homedir());
             },
             'node.skills.install': (data) => this.install('NODE', data),
             'node.skills.remove': (data) => this.remove('NODE', data),
             'workspace.skills.inspect': async (data) => {
                 const workspace = this.workspacePath(record(data)['workspaceId']);
                 await this.installer.recoverWorkspace(workspace);
-                return this.directories.inspectWorkspace(workspace, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
+                return this.directories.inspectWorkspace(workspace, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true, { includeClaudeCompatibility: record(data)['includeClaudeCompatibility'] !== false });
             },
             'workspace.skills.install': (data) => this.install('WORKSPACE', data),
             'workspace.skills.remove': (data) => this.remove('WORKSPACE', data),

package/dist/session/native-session-projection-service.js

@@ -1,4 +1,8 @@
 import { deduplicateDirectSessions } from './runner-native-session-parsers.js';
+/** Owns native identity/metadata projection, not Runner execution.
+ * Discovery borrows its caller's lifetime; cancellation revokes database projection before
+ * releasing the wait on a third-party read that may not itself support interruption.
+ */
 export class NativeSessionProjectionService {
     options;
     directNative = new Map();
@@ -8,7 +12,8 @@ export class NativeSessionProjectionService {
     constructor(options) {
         this.options = options;
     }
-    async discover(runnerName, workspaceId, cleanup = false) {
+    async discover(runnerName, workspaceId, cleanup = false, signal) {
+        signal?.throwIfAborted();
         const database = this.requireDatabase();
         const workspace = workspaceId === undefined ? undefined : database.getWorkspace(workspaceId);
         if (workspaceId !== undefined && workspace === undefined)
@@ -16,11 +21,16 @@ export class NativeSessionProjectionService {
         const runner = this.options.runners.product(runnerName);
         if (runner === undefined || !runner.available(this.options.capabilities()))
             throw new Error('RUNNER_UNAVAILABLE');
-        const sessions = await runner.discoverSessions({
+        const sessions = await awaitDiscovery(runner.discoverSessions({
+            ...(signal === undefined ? {} : { signal }),
             ...(cleanup ? { cleanup: true } : {}),
             workspaces: database.listWorkspaces(),
-            createProjection: (input) => this.project(input)
-        }, workspace);
+            createProjection: (input) => {
+                signal?.throwIfAborted();
+                return this.project(input);
+            }
+        }, workspace), signal);
+        signal?.throwIfAborted();
         const ordered = deduplicateDirectSessions(sessions);
         if (!cleanup) {
             this.remember(ordered);
@@ -57,16 +67,19 @@ export class NativeSessionProjectionService {
         this.remember(sessions);
         return sessions.map(this.options.present);
     }
-    async discoverWorkspace(workspaceId, onRunnerDiscovered, cleanup = false) {
+    async discoverWorkspace(workspaceId, onRunnerDiscovered, cleanup = false, signal) {
+        signal?.throwIfAborted();
         const discovered = await Promise.allSettled(this.options.runners
             .advertised()
             .filter((runner) => runner.available(this.options.capabilities()))
             .map(async (runner) => {
             const name = runner.name;
-            const sessions = await this.discover(name, workspaceId, cleanup);
+            const sessions = await this.discover(name, workspaceId, cleanup, signal);
+            signal?.throwIfAborted();
             onRunnerDiscovered?.(name, sessions);
             return sessions;
         }));
+        signal?.throwIfAborted();
         const failed = discovered.find((result) => result.status === 'rejected');
         if (failed?.status === 'rejected')
             throw failed.reason;
@@ -435,6 +448,28 @@ export class NativeSessionProjectionService {
         return database;
     }
 }
+/** The callback capability is revoked by discover(); late SDK outcomes are still consumed. */
+function awaitDiscovery(read, signal) {
+    if (signal === undefined)
+        return read;
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            signal.removeEventListener('abort', abort);
+            reject(signal.reason);
+        };
+        read.then((sessions) => {
+            signal.removeEventListener('abort', abort);
+            resolve(sessions);
+        }, (error) => {
+            signal.removeEventListener('abort', abort);
+            reject(error);
+        });
+        if (signal.aborted)
+            abort();
+        else
+            signal.addEventListener('abort', abort, { once: true });
+    });
+}
 function sessionIdDistance(left, right, maximum) {
     if (Math.abs(left.length - right.length) > maximum)
         return maximum + 1;

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

@@ -7,12 +7,23 @@ import { sessionPage } from './pagination.js';
 import { latestSessionActivityAt } from './session-presentation-service.js';
 import { marctlSessionSummary, sessionActivityStatus } from '../service/session-recent-activity.js';
 import { WorkspaceSessionCleanupBudget, WorkspaceSessionCleanupDeadline } from '../service/workspace-session-cleanup-budget.js';
+/** Owns catalog queries and Session catalog mutations; borrows the Workspace native cache.
+ * Public operations and internal observation share query rules, not transport/admission routing.
+ */
 export class SessionCatalogService {
     options;
     rewindQueue = Promise.resolve();
     constructor(options) {
         this.options = options;
     }
+    /** Internal observation uses the same catalog query without public operation dispatch. */
+    listWorkspacePage(workspaceId, sessionGroup) {
+        return this.list({
+            workspaceId,
+            limit: 30,
+            ...(sessionGroup === undefined ? {} : { sessionGroup })
+        });
+    }
     operations() {
         return {
             'session.list': (data) => this.list(record(data)),