@myagentroam/node 0.9.0 → 0.9.2

package/dist/service/conversation-segment-service.js

@@ -0,0 +1,155 @@
+const TURN_PAGE_SIZE = 30;
+export function conversationSegments(turn) {
+    const groups = [];
+    let current = [];
+    for (const item of turn.items) {
+        current.push(item);
+        if (item.kind !== 'assistant_message')
+            continue;
+        groups.push(current);
+        current = [];
+    }
+    if (current.length > 0 || groups.length === 0)
+        groups.push(current);
+    return groups.map((items, index) => {
+        const id = `${turn.id}:segment:${index}`;
+        const latest = index === groups.length - 1;
+        const projectedItems = items.map((item) => ({
+            ...item,
+            segmentId: id,
+            segmentIndex: index
+        }));
+        return {
+            id,
+            sessionId: turn.sessionId,
+            turnId: turn.id,
+            runId: turn.runId,
+            index,
+            status: (latest ? turn.status : 'SUCCEEDED'),
+            ...(latest && turn.rewind !== undefined ? { rewind: turn.rewind } : {}),
+            items: projectedItems,
+            startedAt: projectedItems[0]?.startedAt ?? turn.startedAt,
+            completedAt: projectedItems.at(-1)?.completedAt ?? null
+        };
+    });
+}
+export function conversationSegmentIdentityForItem(turn, itemId, itemKind) {
+    let index = 0;
+    const runtimeItemId = turn.runId === null ? itemId : `${turn.runId}:${itemId}`;
+    for (const item of turn.items) {
+        if (item.id === itemId || item.id === runtimeItemId)
+            return { id: `${turn.id}:segment:${index}`, index };
+        if (item.kind === 'assistant_message')
+            index += 1;
+    }
+    if (itemKind === 'assistant_message' && turn.items.at(-1)?.kind === 'assistant_message')
+        index -= 1;
+    return { id: `${turn.id}:segment:${index}`, index };
+}
+export class ConversationSegmentService {
+    readTurns;
+    constructor(readTurns) {
+        this.readTurns = readTurns;
+    }
+    projectInitial(session, page, limit) {
+        const all = page.turns.flatMap(conversationSegments);
+        const segments = all.slice(-limit);
+        return {
+            snapshotSequence: page.snapshotSequence,
+            source: page.source,
+            readAt: page.readAt,
+            latestVisibleAt: page.latestVisibleAt,
+            unit: 'SEGMENT',
+            segments,
+            nextCursor: segments.length === 0 || (segments.length === all.length && page.nextCursor === null)
+                ? null
+                : encodeCursor({
+                    version: 1,
+                    sessionId: session.id,
+                    beforeSegmentId: segments[0].id
+                })
+        };
+    }
+    async read(session, input) {
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const boundary = input.cursor === undefined ? undefined : decodeCursor(input.cursor, session.id);
+        const collected = [];
+        const visited = new Set();
+        let turnCursor;
+        let locatingBoundary = boundary !== undefined;
+        let hasOlder = false;
+        let metadata;
+        while (collected.length < limit) {
+            const page = await this.readTurns(session, {
+                ...(turnCursor === undefined ? {} : { cursor: turnCursor }),
+                limit: TURN_PAGE_SIZE
+            });
+            metadata ??= {
+                snapshotSequence: page.snapshotSequence,
+                source: page.source,
+                readAt: page.readAt,
+                latestVisibleAt: page.latestVisibleAt
+            };
+            const pageSegments = page.turns.flatMap(conversationSegments);
+            let eligible = pageSegments;
+            if (locatingBoundary) {
+                const boundaryIndex = pageSegments.findIndex((segment) => segment.id === boundary?.beforeSegmentId);
+                if (boundaryIndex >= 0) {
+                    eligible = pageSegments.slice(0, boundaryIndex);
+                    locatingBoundary = false;
+                }
+                else
+                    eligible = [];
+            }
+            if (!locatingBoundary && eligible.length > 0) {
+                const remaining = Math.max(0, limit - collected.length);
+                const take = eligible.slice(-remaining);
+                hasOlder = eligible.length > take.length || page.nextCursor !== null;
+                collected.unshift(...take);
+            }
+            if (collected.length >= limit || page.nextCursor === null)
+                break;
+            if (visited.has(page.nextCursor))
+                throw new Error('EVENT_CURSOR_INVALID');
+            visited.add(page.nextCursor);
+            turnCursor = page.nextCursor;
+        }
+        if (locatingBoundary)
+            throw new Error('EVENT_CURSOR_INVALID');
+        const nextCursor = collected.length === 0 || !hasOlder
+            ? null
+            : encodeCursor({
+                version: 1,
+                sessionId: session.id,
+                beforeSegmentId: collected[0].id
+            });
+        return {
+            ...(metadata ?? {
+                snapshotSequence: 0,
+                source: 'runtime',
+                readAt: Date.now(),
+                latestVisibleAt: 0
+            }),
+            unit: 'SEGMENT',
+            segments: collected,
+            nextCursor
+        };
+    }
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor)).toString('base64url');
+}
+function decodeCursor(value, sessionId) {
+    try {
+        const decoded = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (decoded.version !== 1 ||
+            decoded.sessionId !== sessionId ||
+            typeof decoded.beforeSegmentId !== 'string' ||
+            decoded.beforeSegmentId.length === 0)
+            throw new Error('EVENT_CURSOR_INVALID');
+        return decoded;
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}

package/dist/service/mcp-installation-verifier.js

@@ -4,7 +4,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 const INSTALL_TIMEOUT_MS = 90_000;
 export class McpInstallationVerifier {
     async verify(input) {
-        const client = new Client({ name: 'myagentroam-node-installer', version: '0.9.0' });
+        const client = new Client({ name: 'myagentroam-node-installer', version: '0.9.1' });
         try {
             await withTimeout((async () => {
                 if (input.entry.runtime.transport === 'STDIO') {

package/dist/service/native-session-watch-service.d.ts

@@ -8,6 +8,7 @@ export interface NativeSessionWatchOptions<TPage extends {
     readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
     readonly present: (session: NodeAgentSession) => unknown;
     readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
+    readonly projectInitialPage?: (session: NodeAgentSession, page: TPage, unit: 'SEGMENT', limit: number) => unknown;
     readonly emitSession: (session: unknown) => void;
     readonly emitTurn: (turn: unknown) => void;
 }

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

@@ -15,7 +15,12 @@ export class NativeSessionWatchService {
         };
     }
     async executeWatch(input) {
-        if (typeof input.sessionId !== 'string' || (input.mode !== 'initial' && input.mode !== 'renew'))
+        const projectInitialPage = this.options.projectInitialPage;
+        if (input.unit === 'SEGMENT' && projectInitialPage === undefined)
+            throw new Error('SESSION_INVALID');
+        if (typeof input.sessionId !== 'string' ||
+            (input.mode !== 'initial' && input.mode !== 'renew') ||
+            (input.unit !== undefined && input.unit !== 'SEGMENT'))
             throw new Error('SESSION_INVALID');
         const session = await this.options.resolve(input.sessionId);
         if (session === undefined || session.externalSessionId === null)
@@ -27,9 +32,21 @@ export class NativeSessionWatchService {
             return { renewed: true };
         }
         const watch = this.watch(session);
-        const snapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT);
-        if (watch !== undefined && snapshot === undefined)
+        const turnSnapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT);
+        if (watch !== undefined && turnSnapshot === undefined) {
+            this.stop(session.id);
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        }
+        let snapshot = turnSnapshot;
+        if (turnSnapshot !== undefined && input.unit === 'SEGMENT') {
+            try {
+                snapshot = projectInitialPage(session, turnSnapshot, 'SEGMENT', 10);
+            }
+            catch (error) {
+                this.stop(session.id);
+                throw error;
+            }
+        }
         return {
             session: this.options.present(session),
             watch: watch === undefined ? null : { expiresAt: watch.expiresAt },
@@ -131,7 +148,7 @@ export class NativeSessionWatchService {
             }
             const page = await this.options.readPage(session, limit);
             watch.failures = 0;
-            const turns = page.turns.length <= 10 ? page.turns : page.turns.slice(0, 10);
+            const turns = page.turns.length <= 10 ? page.turns : page.turns.slice(-10);
             const signature = JSON.stringify(turns);
             if (signature === watch.signature)
                 return page;

package/dist/service/node-request-service.js

@@ -1,5 +1,6 @@
 import { nodeLog } from '../operational.js';
 import { validUserAuthorization } from '../runner/codex/conversation-parser.js';
+import { safeErrorCode } from '../util/safe-error.js';
 /** Validates and executes the closed Admin-facing Node operation envelope. */
 export class NodeRequestService {
     options;
@@ -44,7 +45,7 @@ export class NodeRequestService {
                 durationMs: Math.round(performance.now() - startedAt),
                 error: error instanceof Error ? error.message : 'INTERNAL_ERROR'
             });
-            this.options.send('node.response', { error: error instanceof Error ? error.message : 'INTERNAL_ERROR' }, envelope.id);
+            this.options.send('node.response', { error: safeErrorCode(error, 'INTERNAL_ERROR') }, envelope.id);
         }
     }
 }

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

@@ -11,14 +11,15 @@ export interface NativeImageSource {
     readonly name: string;
     readonly mime: string;
     readonly path: string;
+    readonly root: string;
 }
 export type RunnerImageAttachment = NodeMessageAttachmentInput & {
     readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
 };
 export declare class RunAttachmentService {
-    private readonly nativeImageRoot;
+    private readonly nativeImageRoots;
     readonly state: AttachmentDomainState<CachedRunImages, NativeImageSource>;
-    constructor(nativeImageRoot: (session: NodeAgentSession) => string | undefined);
+    constructor(nativeImageRoots: (session: NodeAgentSession) => readonly string[]);
     materializeCodex(runId: string, attachments: readonly RunnerImageAttachment[]): Promise<readonly Extract<CodexComposerInput, {
         readonly type: 'localImage';
     }>[]>;

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

@@ -1,14 +1,14 @@
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve } from 'node:path';
-import { lstat, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
 import { AttachmentDomainState } from './attachment-domain-state.js';
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const IMAGE_CACHE_TTL_MS = 60 * 60_000;
 export class RunAttachmentService {
-    nativeImageRoot;
+    nativeImageRoots;
     state = new AttachmentDomainState();
-    constructor(nativeImageRoot) {
-        this.nativeImageRoot = nativeImageRoot;
+    constructor(nativeImageRoots) {
+        this.nativeImageRoots = nativeImageRoots;
     }
     async materializeCodex(runId, attachments) {
         if (attachments.length === 0)
@@ -95,8 +95,8 @@ export class RunAttachmentService {
         return cached.images[imageIndex];
     }
     registerNative(session, images) {
-        const root = this.nativeImageRoot(session);
-        if (root === undefined)
+        const roots = this.nativeImageRoots(session).map((root) => resolve(root));
+        if (roots.length === 0)
             return [];
         const runId = `native-history:${session.id}`;
         const sources = this.state.nativeHistoryImages.get(runId) ?? [];
@@ -107,15 +107,18 @@ export class RunAttachmentService {
                 continue;
             }
             const path = resolve(image.localPath);
-            const relation = relative(root, path);
-            if (relation.length === 0 || relation.startsWith('..') || isAbsolute(relation)) {
+            const root = roots.find((candidate) => {
+                const relation = relative(candidate, path);
+                return relation.length > 0 && !relation.startsWith('..') && !isAbsolute(relation);
+            });
+            if (root === undefined) {
                 attachments.push({ name: image.name, mime: image.mime });
                 continue;
             }
             let imageIndex = sources.findIndex((source) => source.path === path);
             if (imageIndex < 0) {
                 imageIndex = sources.length;
-                sources.push({ name: image.name, mime: image.mime, path });
+                sources.push({ name: image.name, mime: image.mime, path, root });
             }
             attachments.push({ name: image.name, mime: image.mime, runId, imageIndex });
         }
@@ -128,10 +131,17 @@ export class RunAttachmentService {
         if (source === undefined)
             return undefined;
         try {
-            const info = await lstat(source.path);
+            const [actualRoot, actualPath] = await Promise.all([
+                realpath(source.root),
+                realpath(source.path)
+            ]);
+            const relation = relative(actualRoot, actualPath);
+            if (relation.length === 0 || relation.startsWith('..') || isAbsolute(relation))
+                return undefined;
+            const info = await lstat(actualPath);
             if (!info.isFile() || info.size <= 0 || info.size > MAX_ATTACHMENT_BYTES)
                 return undefined;
-            return { ...source, dataBase64: (await readFile(source.path)).toString('base64') };
+            return { ...source, dataBase64: (await readFile(actualPath)).toString('base64') };
         }
         catch {
             return undefined;

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

@@ -25,6 +25,7 @@ export declare class RunEventService {
     constructor(options: RunEventServiceOptions);
     emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
     clear(): void;
+    flushPendingText(runId: string): void;
     private enqueueText;
     private flushText;
     private emitNow;

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;
@@ -59,8 +62,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,
@@ -84,7 +88,9 @@ 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 (status === undefined || !isTerminalRunStatus(status))
             return;
         const turn = this.options.runtime.conversationTurnForRun(runId);

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-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.js

@@ -1,8 +1,7 @@
-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;
@@ -21,7 +20,7 @@ export class SkillDirectoryService {
         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 +30,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 {

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.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;
@@ -76,7 +77,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);

package/dist/service/workspace-git-exclude-service.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureWorkspaceGitExclude(workspace: string): Promise<void>;
+export declare function updateWorkspaceSkillGitExclude(workspace: string, name: string, add: boolean): Promise<void>;
+export declare function rewriteWorkspaceGitExclude(workspace: string, names: ReadonlySet<string>): Promise<void>;
+export declare function hasBrokenWorkspaceSkillGitExclude(workspace: string, names: readonly string[]): Promise<boolean>;