@myagentroam/node 0.9.0 → 0.9.3

package/dist/service/run-event-service.js

@@ -25,6 +25,9 @@ export class RunEventService {
             clearTimeout(pending.timer);
         this.pendingText.clear();
     }
+    flushPendingText(runId) {
+        this.flushText(runId);
+    }
     enqueueText(runId, text) {
         if (text.length === 0)
             return;
@@ -47,6 +50,9 @@ export class RunEventService {
         this.emitNow(runId, 'text.delta', { text: pending.text });
     }
     emitNow(runId, eventType, payload, status) {
+        if (this.options.runtime.getRun(runId) === undefined)
+            return;
+        const notificationPayload = this.notificationPayload(runId, eventType, payload, status);
         const event = {
             runId,
             sequence: (this.sequences.get(runId) ?? 0) + 1,
@@ -59,8 +65,9 @@ export class RunEventService {
             nodeLog('run.event', { runId, eventType, status });
         if (status === 'FAILED')
             this.options.metrics.runnerFailed();
+        let persisted = undefined;
         try {
-            this.options.runtime.appendRunEvent({
+            persisted = this.options.runtime.appendRunEvent({
                 runId,
                 sequence: event.sequence,
                 eventType,
@@ -72,6 +79,7 @@ export class RunEventService {
             /* A stale relayed run may race the storage boundary. */
         }
         if (status !== undefined && isTerminalRunStatus(status)) {
+            this.options.state.active.delete(runId);
             this.options.state.interruptRequested.delete(runId);
             const terminalRun = this.options.runtime.getRun(runId);
             if (terminalRun !== undefined && this.options.isBootstrapSession(terminalRun.sessionId))
@@ -84,7 +92,14 @@ export class RunEventService {
             if (session !== undefined)
                 this.options.emitWorkbench('session', { session: this.options.presentSession(session) });
         }
-        this.options.emitWorkbench('conversation', { event });
+        this.options.emitWorkbench('conversation', {
+            event: { ...event, createdAt: persisted?.createdAt ?? Date.now() }
+        });
+        if (notificationPayload !== undefined)
+            this.emitNow(runId, 'notification', {
+                ...notificationPayload,
+                occurredAt: persisted?.createdAt ?? Date.now()
+            });
         if (status === undefined || !isTerminalRunStatus(status))
             return;
         const turn = this.options.runtime.conversationTurnForRun(runId);
@@ -96,7 +111,67 @@ export class RunEventService {
         const run = this.options.runtime.getRun(runId);
         if (run !== undefined) {
             this.options.scheduleContextRefresh(run.sessionId);
+            this.options.runtime.removeTerminalRun(runId);
+            this.sequences.delete(runId);
             void this.options.dispatchQueue(run.sessionId);
         }
     }
+    notificationPayload(runId, eventType, payload, status) {
+        if (eventType === 'notification')
+            return undefined;
+        const run = this.options.runtime.getRun(runId);
+        if (run === undefined)
+            return undefined;
+        const session = this.options.runtime.getAgentSession(run.sessionId);
+        if (session === undefined)
+            return undefined;
+        const base = {
+            workspaceId: run.workspaceId,
+            sessionId: run.sessionId,
+            sessionTitle: session.customTitle ?? session.runnerTitle ?? session.id,
+            runId
+        };
+        if (status !== undefined && isTerminalRunStatus(status)) {
+            if (this.options.state.interruptRequested.has(runId))
+                return undefined;
+            if (status === 'SUCCEEDED' &&
+                this.options.runtime.sessionQueue(run.sessionId).runIds.length > 0)
+                return undefined;
+            return {
+                ...base,
+                notificationId: `run:${run.workspaceId}:${runId}`,
+                kind: 'RUN_TERMINAL',
+                outcome: status
+            };
+        }
+        if (eventType === 'approval.request' && isPlainRecord(payload)) {
+            const approvalId = payload.approvalId;
+            if (typeof approvalId !== 'string')
+                return undefined;
+            return {
+                ...base,
+                notificationId: `approval:${run.workspaceId}:${runId}:${approvalId}`,
+                kind: 'APPROVAL_REQUIRED'
+            };
+        }
+        if (eventType !== 'conversation.item' || !isPlainRecord(payload))
+            return undefined;
+        if (payload.kind === 'plan' && typeof payload.itemId === 'string')
+            return {
+                ...base,
+                notificationId: `plan:${run.workspaceId}:${run.sessionId}`,
+                kind: 'PLAN_READY'
+            };
+        if (payload.kind === 'user_input_request' &&
+            typeof payload.itemId === 'string' &&
+            isPlainRecord(payload.payload) &&
+            Array.isArray(payload.payload.questions) &&
+            payload.payload.questions.length > 0)
+            return {
+                ...base,
+                notificationId: `user-input:${run.workspaceId}:${runId}:${payload.itemId}`,
+                kind: 'USER_INPUT_REQUIRED'
+            };
+        return undefined;
+    }
 }

package/dist/service/run-workbench-service.d.ts

@@ -6,6 +6,7 @@ export interface RunWorkbenchServiceOptions {
     readonly respondUserInput: (runId: string, requestId: string, answers: Record<string, unknown>) => void;
     readonly deleteQueuedStart: (runId: string) => void;
     readonly clearImages: (runId: string) => void;
+    readonly cleanupAttachments: (runId: string) => void;
     readonly emitQueue: (workspaceId: string, sessionId: string) => void;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'CANCELLED') => void;
     readonly control: (operation: string, payload: Record<string, unknown>) => void;
@@ -16,7 +17,6 @@ export declare class RunWorkbenchService {
     constructor(options: RunWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private get;
-    private snapshot;
     private image;
     private respond;
     private interruptSession;

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

@@ -8,7 +8,6 @@ export class RunWorkbenchService {
     operations() {
         return {
             'run.get': (data) => this.get(record(data)),
-            'run.snapshot': (data) => this.snapshot(record(data)),
             'run.image.read': (data) => this.image(record(data)),
             'run.user-input.respond': (data) => this.respond(record(data)),
             'session.interrupt': (data) => this.interruptSession(record(data)),
@@ -21,10 +20,6 @@ export class RunWorkbenchService {
     get(input) {
         return { run: this.requireRun(input.runId) };
     }
-    snapshot(input) {
-        const run = this.requireRun(input.runId);
-        return { snapshot: this.options.runtime.getSnapshot(run.id) ?? null };
-    }
     async image(input) {
         if (typeof input.runId !== 'string' ||
             typeof input.imageIndex !== 'number' ||
@@ -63,6 +58,7 @@ export class RunWorkbenchService {
             this.options.runtime.deleteQueuedRun(run.id);
             this.options.deleteQueuedStart(run.id);
             this.options.clearImages(run.id);
+            this.options.cleanupAttachments(run.id);
             this.options.emitQueue(run.workspaceId, run.sessionId);
             return { cancelled: true };
         }

package/dist/service/runner-interaction-service.d.ts

@@ -13,7 +13,6 @@ interface RunnerInteractionServiceOptions {
     readonly runners: RunnerRegistry;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED' | 'INTERRUPTED') => void;
     readonly emitItem: (runId: string, item: PublicConversationItem) => void;
-    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
     readonly approvalTimeoutMs: number;
     readonly publishApproval: (input: {
         readonly runId: string;
@@ -33,7 +32,7 @@ export declare class RunnerInteractionService {
     cancelClaudeRun(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
     cancelCodexTurn(runId: string, threadId: string, turnId: string, cwd: string, terminalStatus: 'CANCELLED' | 'INTERRUPTED'): Promise<void>;
     respondUserInput(runId: string, requestId: string, rawAnswers: Record<string, unknown>): void;
-    completeCancelledRun(runId: string, cwd: string | undefined): boolean;
+    completeCancelledRun(runId: string): boolean;
     private respondCodexUserInput;
     private answers;
 }

package/dist/service/runner-interaction-service.js

@@ -162,7 +162,6 @@ export class RunnerInteractionService {
             codex.execution.runs.delete(runId);
             codex.releaseEnvironment(runId);
             this.options.state.active.delete(runId);
-            void this.options.captureSnapshot(runId, cwd);
         }
     }
     respondUserInput(runId, requestId, rawAnswers) {
@@ -194,7 +193,7 @@ export class RunnerInteractionService {
             merge: true
         });
     }
-    completeCancelledRun(runId, cwd) {
+    completeCancelledRun(runId) {
         const run = this.options.runtime.getRun(runId);
         if (run === undefined)
             return false;
@@ -206,8 +205,6 @@ export class RunnerInteractionService {
             return false;
         this.options.codex().execution.runs.delete(runId);
         this.options.state.active.delete(runId);
-        if (cwd !== undefined)
-            void this.options.captureSnapshot(runId, cwd);
         return true;
     }
     respondCodexUserInput(runId, requestId, rawAnswers) {

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

@@ -1,5 +1,6 @@
 import { removeNativeSession } from '../native-session-history.js';
 import { isTerminalRunStatus, sessionPage } from '../util/node-operation-parsers.js';
+import { latestSessionActivityAt } from './session-presentation-service.js';
 export class SessionCatalogService {
     options;
     rewindQueue = Promise.resolve();
@@ -35,7 +36,7 @@ export class SessionCatalogService {
                     pinOrder: source.pinOrder ?? null,
                     externalDiscovered: true,
                     titleSource: session.customTitle === null ? source.titleSource : session.titleSource,
-                    lastActivityAt: source.lastActivityAt
+                    lastActivityAt: latestSessionActivityAt(session.lastActivityAt, source.lastActivityAt)
                 });
         });
         const merged = new Map([
@@ -100,8 +101,7 @@ export class SessionCatalogService {
             delivery: resumed === undefined ? 'REJECTED' : 'RESUMABLE',
             ...(resumed === undefined
                 ? {
-                    reasonCode: failure?.code ?? 'SESSION_RESUME_REJECTED',
-                    ...(failure?.detail === undefined ? {} : { reasonDetail: failure.detail })
+                    reasonCode: failure?.code ?? 'SESSION_RESUME_REJECTED'
                 }
                 : {})
         };
@@ -130,7 +130,7 @@ export class SessionCatalogService {
         const expected = input.position === 'BEFORE' ? turn?.rewind?.before : turn?.rewind?.after;
         if (turn === undefined || expected !== input.boundary)
             throw new Error('SESSION_REWIND_TARGET_INVALID');
-        const title = rewindTitle(source.customTitle ?? source.runnerTitle ?? '未命名会话', this.options.runtime
+        const title = rewindTitle(source.customTitle ?? source.runnerTitle ?? 'Untitled session', this.options.runtime
             .listAgentSessions()
             .flatMap((candidate) => [candidate.customTitle ?? candidate.runnerTitle].filter(isString)));
         const runner = this.options.runners.require(source.runner);

package/dist/service/session-context-service.d.ts

@@ -24,6 +24,7 @@ export interface SessionContextServiceOptions {
 export declare class SessionContextService {
     private readonly options;
     private readonly snapshots;
+    private readonly snapshotTimers;
     private readonly timers;
     private readonly versions;
     constructor(options: SessionContextServiceOptions);

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

@@ -1,7 +1,9 @@
 const REFRESH_DELAYS_MS = [100, 400, 1_000];
+const CONTEXT_SNAPSHOT_TTL_MS = 30 * 60_000;
 export class SessionContextService {
     options;
     snapshots = new Map();
+    snapshotTimers = new Map();
     timers = new Map();
     versions = new Map();
     constructor(options) {
@@ -20,6 +22,15 @@ export class SessionContextService {
             percentage: Math.round((usage.usedTokens / usage.maxTokens) * 1000) / 10
         };
         this.snapshots.set(session.id, context);
+        const previousTimer = this.snapshotTimers.get(session.id);
+        if (previousTimer !== undefined)
+            clearTimeout(previousTimer);
+        const timer = setTimeout(() => {
+            this.snapshotTimers.delete(session.id);
+            this.snapshots.delete(session.id);
+        }, CONTEXT_SNAPSHOT_TTL_MS);
+        timer.unref();
+        this.snapshotTimers.set(session.id, timer);
         return { context, pending: false };
     }
     schedule(sessionId) {
@@ -71,7 +82,10 @@ export class SessionContextService {
     dispose() {
         for (const timer of this.timers.values())
             clearTimeout(timer);
+        for (const timer of this.snapshotTimers.values())
+            clearTimeout(timer);
         this.timers.clear();
+        this.snapshotTimers.clear();
         this.versions.clear();
         this.snapshots.clear();
     }

package/dist/service/session-domain-state.d.ts

@@ -5,4 +5,5 @@ export declare class SessionDomainState<TSession, TActivity> {
     readonly resumeFailures: Map<string, string>;
     readonly messageResumeFailures: Map<string, string>;
     readonly resumeFailureDetails: Map<string, string>;
+    readonly failureTimers: Map<string, NodeJS.Timeout>;
 }

package/dist/service/session-domain-state.js

@@ -5,4 +5,5 @@ export class SessionDomainState {
     resumeFailures = new Map();
     messageResumeFailures = new Map();
     resumeFailureDetails = new Map();
+    failureTimers = new Map();
 }

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

@@ -68,11 +68,13 @@ export class SessionMessageService {
         this.options.attachments.cache(created.run.id, imageAttachments);
         let attachmentPaths;
         try {
-            attachmentPaths = await this.persistAttachments(session, created.run.id, attachmentIds, attachments, uploaded);
+            attachmentPaths = await this.persistAttachments(session, created.run.id, attachments);
+            await this.options.uploads.consume(attachmentIds);
         }
         catch (error) {
             this.options.runtime.deleteQueuedRun(created.run.id);
             this.options.attachments.clear(created.run.id);
+            this.options.attachments.cleanup(created.run.id);
             throw error;
         }
         const runnerInput = withNonImageAttachmentPrompt(input.content, attachmentPaths);
@@ -117,15 +119,8 @@ export class SessionMessageService {
             idempotent: false
         };
     }
-    async persistAttachments(session, runId, attachmentIds, attachments, uploaded) {
-        return [
-            ...uploaded
-                .filter(({ attachment }) => !isRunnerImageAttachment(attachment))
-                .map(({ path }) => path),
-            ...(await this.options.attachments.persistFiles(session.cwd, runId, attachmentIds.length === 0
-                ? attachments.filter((attachment) => !isRunnerImageAttachment(attachment))
-                : []))
-        ];
+    async persistAttachments(session, runId, attachments) {
+        return this.options.attachments.persistFiles(session.cwd, runId, attachments.filter((attachment) => !isRunnerImageAttachment(attachment)));
     }
     channelMessage(input) {
         if (typeof input.sessionId !== 'string' ||

package/dist/service/session-presentation-service.d.ts

@@ -30,4 +30,5 @@ export declare class SessionPresentationService {
     present(session: NodeAgentSession): PresentedSession;
     presentDiscovered(sessions: readonly NodeAgentSession[]): readonly PresentedSession[];
 }
+export declare function latestSessionActivityAt(current: number, discovered: number): number;
 export {};

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

@@ -30,7 +30,14 @@ export class SessionPresentationService {
             const synchronized = session.runnerTitle === null
                 ? projected
                 : this.options.runtime.setRunnerTitleFromNative(projected.id, session.runnerTitle);
-            return this.present({ ...synchronized, lastActivityAt: session.lastActivityAt });
+            return this.present({
+                ...synchronized,
+                lastActivityAt: latestSessionActivityAt(synchronized.lastActivityAt, session.lastActivityAt)
+            });
         });
     }
 }
+export function latestSessionActivityAt(current, discovered) {
+    const known = [current, discovered].filter((value) => Number.isFinite(value) && value > 0);
+    return known.length === 0 ? 0 : Math.max(...known);
+}

package/dist/service/session-query-service.d.ts

@@ -13,6 +13,10 @@ export interface SessionQueryServiceOptions {
         readonly cursor?: string;
         readonly limit?: number;
     }) => Promise<unknown>;
+    readonly segments: (session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }) => Promise<unknown>;
     readonly context: SessionContextService;
     readonly discover: (runner: RunnerName, workspaceId?: string) => Promise<readonly NodeAgentSession[]>;
     readonly workspaceIdForCwd: (cwd: string) => string | undefined;

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

@@ -23,7 +23,12 @@ export class SessionQueryService {
     }
     async turns(input) {
         const page = pageInput(input);
-        return this.options.history(await this.requireSession(input.sessionId), page);
+        const session = await this.requireSession(input.sessionId);
+        if (input.unit === 'SEGMENT')
+            return this.options.segments(session, page);
+        if (input.unit !== undefined && input.unit !== 'TURN')
+            throw new Error('EVENT_CURSOR_INVALID');
+        return this.options.history(session, page);
     }
     events(input) {
         const page = pageInput(input);

package/dist/service/skill-directory-service.d.ts

@@ -12,6 +12,8 @@ export interface LocalSkillTargetInspection {
     readonly skills: readonly LocalSkillInspection[];
 }
 export declare class SkillDirectoryService {
-    inspectNodeHome(home: string): Promise<LocalSkillTargetInspection>;
+    inspectNodeHome(home: string, options?: {
+        readonly includeClaudeCompatibility?: boolean;
+    }): Promise<LocalSkillTargetInspection>;
     inspectWorkspace(workspace: string): Promise<LocalSkillTargetInspection>;
 }

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

@@ -1,27 +1,32 @@
-import { lstat, open, readFile, readdir, readlink, realpath } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+import { lstat, open, readdir, readlink, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
+import { hasBrokenWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
 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;
 export class SkillDirectoryService {
-    async inspectNodeHome(home) {
+    async inspectNodeHome(home, options = {}) {
         const agentsRoot = path.join(home, '.agents', 'skills');
         const claudeRoot = path.join(home, '.claude', 'skills');
-        const skills = await scanRoot(agentsRoot, 'AGENTS');
+        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: await nodeCompatibilityMode(agentsRoot, claudeRoot),
-            skills
+            compatibilityMode,
+            skills: options.includeClaudeCompatibility === true
+                ? mergeNodeCompatibilityRoots(agents, claude)
+                : agents.map(withoutSource)
         };
     }
     async inspectWorkspace(workspace) {
         const agents = await scanRoot(path.join(workspace, '.agents', 'skills'), 'AGENTS');
         const claude = await scanRoot(path.join(workspace, '.claude', 'skills'), 'CLAUDE');
         const skills = mergeWorkspaceCopies(agents, claude);
-        const gitExcludeBroken = await hasBrokenGitExclude(workspace, skills.map((skill) => skill.name));
+        const gitExcludeBroken = await hasBrokenWorkspaceSkillGitExclude(workspace, skills.map((skill) => skill.name));
         return {
             targetKind: 'WORKSPACE',
             compatibilityMode: 'MANAGED_COPY',
@@ -31,28 +36,6 @@ export class SkillDirectoryService {
         };
     }
 }
-async function hasBrokenGitExclude(workspace, names) {
-    if (names.length === 0)
-        return false;
-    try {
-        await lstat(path.join(workspace, '.git'));
-    }
-    catch (error) {
-        if (isMissing(error))
-            return false;
-        return true;
-    }
-    try {
-        const result = await promisify(execFile)('git', ['-C', workspace, 'rev-parse', '--git-path', 'info/exclude'], { timeout: 5_000, windowsHide: true });
-        const exclude = path.resolve(workspace, result.stdout.trim());
-        const content = await readFile(exclude, 'utf8');
-        return names.some((name) => !content.includes(`/.agents/skills/${name}/`) ||
-            !content.includes(`/.claude/skills/${name}/`));
-    }
-    catch {
-        return true;
-    }
-}
 async function scanRoot(root, source) {
     let entries;
     try {
@@ -170,6 +153,24 @@ 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' };
+        return withoutSource(copies.agents);
+    });
+}
 function withoutSource(entry) {
     return {
         name: entry.name,

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

@@ -4,6 +4,7 @@ import { promisify } from 'node:util';
 import { lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
+import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
 export class SkillInstallService {
     async recoverNodeHome(home) {
         const agentsRoot = path.join(home, '.agents', 'skills');
@@ -58,7 +59,7 @@ export class SkillInstallService {
         await mkdir(claudeRoot, { recursive: true });
         await assertContainedDirectory(workspace, agentsRoot);
         await assertContainedDirectory(workspace, claudeRoot);
-        await replacePair(agentsRoot, claudeRoot, name, bundle, metadata, () => updateGitExclude(workspace, name, true), () => updateGitExclude(workspace, name, false));
+        await replacePair(agentsRoot, claudeRoot, name, bundle, metadata, () => updateWorkspaceSkillGitExclude(workspace, name, true), () => updateWorkspaceSkillGitExclude(workspace, name, false));
     }
     async removeWorkspace(workspace, name) {
         assertName(name);
@@ -66,7 +67,7 @@ export class SkillInstallService {
         const claudeRoot = path.join(workspace, '.claude', 'skills');
         await assertExistingContainedDirectory(workspace, agentsRoot);
         await assertExistingContainedDirectory(workspace, claudeRoot);
-        await removePair(agentsRoot, claudeRoot, name, () => updateGitExclude(workspace, name, false), () => updateGitExclude(workspace, name, true));
+        await removePair(agentsRoot, claudeRoot, name, () => updateWorkspaceSkillGitExclude(workspace, name, false), () => updateWorkspaceSkillGitExclude(workspace, name, true));
     }
     async removeNodeHome(home, name) {
         assertName(name);
@@ -100,7 +101,7 @@ export class SkillInstallService {
             if (!isMissing(error))
                 throw error;
         }
-        await rewriteGitExclude(workspace, names);
+        await rewriteWorkspaceGitExclude(workspace, names);
     }
 }
 export async function workspaceSkillTracked(workspace, name) {
@@ -405,74 +406,6 @@ async function ensureClaudeRoot(agentsRoot, claudeRoot) {
         }
     }
 }
-async function updateGitExclude(workspace, name, add) {
-    await mutateGitExclude(workspace, (entries) => {
-        for (const root of ['.agents', '.claude']) {
-            const line = `/${root}/skills/${name}/`;
-            if (add)
-                entries.add(line);
-            else
-                entries.delete(line);
-        }
-    });
-}
-async function rewriteGitExclude(workspace, names) {
-    await mutateGitExclude(workspace, (entries) => {
-        entries.clear();
-        for (const name of names)
-            for (const root of ['.agents', '.claude'])
-                entries.add(`/${root}/skills/${name}/`);
-    });
-}
-async function mutateGitExclude(workspace, mutate) {
-    const git = path.join(workspace, '.git');
-    if (!(await exists(git)))
-        return;
-    let exclude;
-    try {
-        const result = await promisify(execFile)('git', ['-C', workspace, 'rev-parse', '--git-path', 'info/exclude', '--git-common-dir'], { timeout: 5_000, windowsHide: true });
-        const [excludeOutput, commonOutput] = result.stdout.trim().split(/\r?\n/u);
-        if (!excludeOutput || !commonOutput)
-            throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
-        exclude = path.resolve(workspace, excludeOutput);
-        const common = path.resolve(workspace, commonOutput);
-        const relative = path.relative(common, exclude);
-        if (relative.startsWith('..') || path.isAbsolute(relative))
-            throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
-    }
-    catch {
-        throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
-    }
-    await mkdir(path.dirname(exclude), { recursive: true });
-    const begin = '# BEGIN MyAgentRoam Skills';
-    const end = '# END MyAgentRoam Skills';
-    let content = '';
-    try {
-        const excludeStat = await lstat(exclude);
-        if (!excludeStat.isFile() || excludeStat.isSymbolicLink())
-            throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
-        content = await readFile(exclude, 'utf8');
-    }
-    catch (error) {
-        if (!isMissing(error))
-            throw error;
-    }
-    const pattern = new RegExp(`${escapeRegExp(begin)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, 'u');
-    const existing = pattern.exec(content)?.[0] ?? '';
-    const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/.')));
-    mutate(entries);
-    const block = entries.size === 0 ? '' : `${begin}\n${[...entries].sort().join('\n')}\n${end}\n`;
-    const next = content.replace(pattern, '').replace(/\s*$/u, '\n') + block;
-    const staging = path.join(path.dirname(exclude), `.mar-git-exclude-${randomUUID()}.tmp`);
-    try {
-        await writeFile(staging, next, { encoding: 'utf8', flag: 'wx' });
-        await rename(staging, exclude);
-    }
-    catch (error) {
-        await rm(staging, { force: true });
-        throw error;
-    }
-}
 function assertName(name) {
     if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name) ||
         /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u.test(name))
@@ -499,6 +432,3 @@ async function exists(value) {
 function isMissing(error) {
     return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-}

package/dist/service/skill-node-operation-service.d.ts

@@ -9,7 +9,7 @@ export declare class SkillNodeOperationService {
     private readonly jobs;
     constructor(database: () => NodeDatabase, config: () => NodeConfig);
     operations(): {
-        'node.skills.inspect': () => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
+        'node.skills.inspect': (data: unknown) => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
         'node.skills.install': (data: unknown) => Promise<{
             accepted: boolean;
             installJobId: `${string}-${string}-${string}-${string}-${string}`;

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

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
 import { SkillDirectoryService } from './skill-directory-service.js';
 import { SkillInstallService, workspaceSkillTracked } from './skill-install-service.js';
+import { safeErrorCode } from '../util/safe-error.js';
 export class SkillNodeOperationService {
     database;
     config;
@@ -16,9 +17,11 @@ export class SkillNodeOperationService {
     }
     operations() {
         return {
-            'node.skills.inspect': async () => {
+            'node.skills.inspect': async (data) => {
                 await this.installer.recoverNodeHome(homedir());
-                return this.directories.inspectNodeHome(homedir());
+                return this.directories.inspectNodeHome(homedir(), {
+                    includeClaudeCompatibility: record(data)['includeClaudeCompatibility'] === true
+                });
             },
             'node.skills.install': (data) => this.install('NODE', data),
             'node.skills.remove': (data) => this.remove('NODE', data),
@@ -76,7 +79,7 @@ export class SkillNodeOperationService {
             catch (error) {
                 terminal = {
                     status: 'FAILED',
-                    errorCode: error instanceof Error ? error.message : 'SKILL_INSTALL_FAILED'
+                    errorCode: safeErrorCode(error, 'SKILL_INSTALL_FAILED')
                 };
             }
             this.activeTargets.delete(targetKey);