@myagentroam/node 0.11.0 → 0.11.2

package/dist/connector.js

@@ -87,7 +87,8 @@ import { NodeControlChannel } from './service/node-control-channel.js';
 import { NodeControlMessageService } from './service/node-control-message-service.js';
 import { NodeRequestService } from './service/node-request-service.js';
 import { WorkbenchManifestService } from './service/workbench-manifest-service.js';
-import { NodeRunEventBridge, workbenchPayloadSessionId } from './service/node-run-event-bridge.js';
+import { NodeRunEventBridge } from './service/node-run-event-bridge.js';
+import { workbenchPayloadSessionId } from './service/workbench-event-projection.js';
 import { NodeWorkspaceCoordinator } from './service/node-workspace-coordinator.js';
 import { FakeManagedRunService } from './service/fake-managed-run-service.js';
 import { RunnerChannelMessageService } from './service/runner-channel-message-service.js';
@@ -203,9 +204,18 @@ export class NodeConnector {
     configPath;
     reconnect;
     claudeApprovalTimeoutMs;
-    workbenchEventService = new WorkbenchEventService((envelope) => this.sendEnvelope(envelope), (category, payload) => {
-        const sessionId = workbenchPayloadSessionId(this.runtime, category, payload);
-        return sessionId === undefined || !this.sessionIdentityService.bootstrapIds.has(sessionId);
+    workbenchEventService = new WorkbenchEventService({
+        send: (envelope) => this.sendEnvelope(envelope),
+        accepts: (category, payload) => {
+            const sessionId = workbenchPayloadSessionId((id) => this.runtime.getRun(id), category, payload);
+            return sessionId === undefined || !this.sessionIdentityService.bootstrapIds.has(sessionId);
+        },
+        projection: {
+            getRun: (id) => this.runtime.getRun(id),
+            conversationTurnForRun: (id) => this.runtime.conversationTurnForRun(id),
+            progress: (sessionId) => marctlSessionProgress(this.runtime, sessionId)
+        },
+        emitRealtime: (sessionId, event) => this.nativeSessionWatchService.emitRealtime(sessionId, event)
     });
     fakeRunner;
     fakeScript;
@@ -1146,8 +1156,10 @@ export class NodeConnector {
                     nodeLog('node.connection.replaced', {
                         message: 'This Node connection was replaced by a newer instance with the same identity. Check for duplicate processes.'
                     });
-                if (code === 4003 || code === 1001)
-                    void this.terminalManager.shutdown();
+                // Credential revocation ends terminals, but the control channel can still reconnect.
+                // Only final Node disposal shuts down the manager and its idle collector.
+                if (code === 4003)
+                    void this.terminalManager.closeAll();
             }
         });
         this.controlMessages = new NodeControlMessageService({
@@ -1331,7 +1343,7 @@ export class NodeConnector {
             this.workspaceCoordinator.clearWatches(workspaceId);
             this.workspaceWorkbenchService.clearWorkspace(workspaceId);
             this.promptCompletion?.invalidateWorkspace(workspaceId);
-        });
+        }, (workspaceId) => this.workspaceCoordinator.gitPolicyChanged(workspaceId));
         this.workspaceWorkbenchService = new WorkspaceWorkbenchService({
             requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
             inspectWorkspace: (workspace) => this.workspaceCoordinator.inspectMetadata(workspace),
@@ -1718,24 +1730,7 @@ export class NodeConnector {
         }
         this.emitWorkbenchEvent('session', payload);
     };
-    emitWorkbenchEvent = (category, payload) => {
-        payload = this.runEventBridge.projectWorkbenchPayload(category, payload);
-        if (payload === undefined)
-            return;
-        const event = this.workbenchEventService.next(category, payload);
-        if (event === undefined)
-            return;
-        const notification = category === 'conversation' &&
-            isPlainRecord(payload) &&
-            isPlainRecord(payload.event) &&
-            payload.event.eventType === 'notification';
-        const sessionId = workbenchPayloadSessionId(this.runtime, category, payload);
-        if (!notification &&
-            sessionId !== undefined &&
-            this.nativeSessionWatchService.emitRealtime(sessionId, event))
-            return;
-        this.workbenchEventService.publish(event);
-    };
+    emitWorkbenchEvent = (category, payload) => this.workbenchEventService.dispatch(category, payload);
     discoverWorkspaceSessions = (workspaceId, onRunnerDiscovered) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId, onRunnerDiscovered);
     invalidateWorkspaceWatchTopics = (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId);
     reconcilePersistedRuns = () => undefined;

package/dist/database.js

@@ -2,6 +2,7 @@ import { NODE_SCHEMA_MIGRATION_V17 } from './migrations/v017.js';
 import { NODE_SCHEMA_MIGRATION_V18 } from './migrations/v018.js';
 import { NODE_SCHEMA_MIGRATION_V19 } from './migrations/v019.js';
 import { NODE_SCHEMA_MIGRATION_V20 } from './migrations/v020.js';
+import { NODE_SCHEMA_MIGRATION_V21 } from './migrations/v021.js';
 import { normalizeSessionPrompt } from './util/personal-instructions.js';
 import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
@@ -23,7 +24,8 @@ export const NODE_SCHEMA_MIGRATIONS = [
     NODE_SCHEMA_MIGRATION_V17,
     NODE_SCHEMA_MIGRATION_V18,
     NODE_SCHEMA_MIGRATION_V19,
-    NODE_SCHEMA_MIGRATION_V20
+    NODE_SCHEMA_MIGRATION_V20,
+    NODE_SCHEMA_MIGRATION_V21
 ];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 const OBSOLETE_NODE_SCHEMA_V16 = 16;
@@ -71,27 +73,22 @@ export class NodeDatabase {
         this.raw.close();
     }
     getRunnerDefaults() {
-        const rows = this.raw
-            .prepare('SELECT runner, model, effort, access FROM runner_defaults ORDER BY runner')
-            .all();
-        return rows.flatMap((row) => {
-            const parsed = runnerDefaultConfigurationSchema.safeParse({
-                runner: stringValue(row, 'runner'),
-                model: stringValue(row, 'model'),
-                effort: stringValue(row, 'effort'),
-                access: stringValue(row, 'access')
-            });
+        return Object.entries(this.getNodeSettings().runnerDefaults ?? {})
+            .sort(([a], [b]) => a.localeCompare(b))
+            .flatMap(([runner, settings]) => {
+            const parsed = runnerDefaultConfigurationSchema.safeParse({ runner, ...settings });
             return parsed.success ? [parsed.data] : [];
         });
     }
+    getNodeSettings() {
+        const row = this.raw.prepare('SELECT settings FROM node_settings WHERE id = 1').get();
+        return JSON.parse(stringValue(row, 'settings'));
+    }
     saveRunnerDefaults(input) {
+        const { runner, ...settings } = runnerDefaultConfigurationSchema.parse(input);
         this.raw
-            .prepare(`INSERT INTO runner_defaults (runner, model, effort, access)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(runner) DO UPDATE SET
-           model = excluded.model, effort = excluded.effort,
-           access = excluded.access`)
-            .run(input.runner, input.model, input.effort, input.access);
+            .prepare(`UPDATE node_settings SET settings = json_patch(settings, ?) WHERE id = 1`)
+            .run(JSON.stringify({ runnerDefaults: { [runner]: settings } }));
         return input;
     }
     listMcpInstallations(targetKind, targetId = '') {
@@ -188,45 +185,64 @@ export class NodeDatabase {
     }
     saveWorkspace(input) {
         const current = this.raw
-            .prepare('SELECT id, preserve_git_config FROM workspaces WHERE path = ?')
+            .prepare('SELECT id, settings FROM workspaces WHERE path = ?')
             .get(input.path);
+        const settings = current === undefined
+            ? {
+                git: {
+                    preserveGitConfig: input.preserveGitConfig ?? false,
+                    includeParentRepository: input.includeParentRepository ?? true
+                }
+            }
+            : JSON.parse(stringValue(current, 'settings'));
         const workspace = {
             id: current === undefined ? (input.id ?? randomUUID()) : stringValue(current, 'id'),
             path: input.path,
             kind: input.kind,
             gitSummary: input.gitSummary,
-            preserveGitConfig: current === undefined
-                ? (input.preserveGitConfig ?? false)
-                : Number(current.preserve_git_config) === 1
+            settings,
+            includeParentRepository: settings.git?.includeParentRepository ?? true,
+            preserveGitConfig: settings.git?.preserveGitConfig ?? false
         };
         const timestamp = this.now();
         this.raw
-            .prepare(`INSERT INTO workspaces (id, path, kind, git_summary, created_at, updated_at, preserve_git_config)
+            .prepare(`INSERT INTO workspaces (id, path, kind, git_summary, created_at, updated_at, settings)
          VALUES (?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(path) DO UPDATE SET kind = excluded.kind,
            git_summary = excluded.git_summary, updated_at = excluded.updated_at`)
-            .run(workspace.id, workspace.path, workspace.kind, workspace.gitSummary === null ? null : JSON.stringify(workspace.gitSummary), timestamp, timestamp, workspace.preserveGitConfig ? 1 : 0);
+            .run(workspace.id, workspace.path, workspace.kind, workspace.gitSummary === null ? null : JSON.stringify(workspace.gitSummary), timestamp, timestamp, JSON.stringify(settings));
         return workspace;
     }
     listWorkspaces() {
         return this.raw
-            .prepare('SELECT id, path, kind, git_summary, preserve_git_config FROM workspaces ORDER BY created_at ASC')
+            .prepare('SELECT id, path, kind, git_summary, settings FROM workspaces ORDER BY created_at ASC')
             .all()
             .map((row) => workspace(row));
     }
     getWorkspace(id) {
         const row = this.raw
-            .prepare('SELECT id, path, kind, git_summary, preserve_git_config FROM workspaces WHERE id = ?')
+            .prepare('SELECT id, path, kind, git_summary, settings FROM workspaces WHERE id = ?')
             .get(id);
         return row === undefined ? undefined : workspace(row);
     }
-    /** Unregisters a Workspace registration without deleting its local directory. */
-    setWorkspaceGitPolicy(id, preserveGitConfig) {
+    getWorkspaceByPath(path) {
+        const row = this.raw
+            .prepare('SELECT id, path, kind, git_summary, settings FROM workspaces WHERE path = ?')
+            .get(path);
+        return row === undefined ? undefined : workspace(row);
+    }
+    /** Updates only supplied policy fields without replacing Workspace metadata. */
+    setWorkspaceGitPolicy(id, preserveGitConfig, includeParentRepository) {
         if (this.getWorkspace(id) === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
         this.raw
-            .prepare('UPDATE workspaces SET preserve_git_config=?, updated_at=? WHERE id=?')
-            .run(preserveGitConfig ? 1 : 0, this.now(), id);
+            .prepare('UPDATE workspaces SET settings=json_patch(settings, ?), updated_at=? WHERE id=?')
+            .run(JSON.stringify({
+            git: {
+                preserveGitConfig,
+                ...(includeParentRepository === undefined ? {} : { includeParentRepository })
+            }
+        }), this.now(), id);
         return this.getWorkspace(id);
     }
     /** Unregisters a Workspace registration without deleting its local directory. */
@@ -474,7 +490,10 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
         throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
     if (migratedVersions.some((version, index) => version !== NODE_SCHEMA_VERSION_V13 + index))
         throw new Error('NODE_DATABASE_MIGRATION_HISTORY_INVALID');
-    assertNodeSchemaV13(database);
+    if (current < NODE_SCHEMA_MIGRATION_V21.version)
+        assertNodeSchemaV13(database);
+    else
+        catalog[current - NODE_SCHEMA_VERSION_V13 - 1].assert(database);
     for (const entry of catalog) {
         if (entry.version <= current)
             continue;
@@ -623,9 +642,12 @@ function acquireNodeMigrationLock(databasePath) {
 }
 function workspace(row) {
     const summary = nullableString(row, 'git_summary');
+    const settings = JSON.parse(stringValue(row, 'settings'));
     return {
         id: stringValue(row, 'id'),
-        preserveGitConfig: Number(row.preserve_git_config) === 1,
+        settings,
+        preserveGitConfig: settings.git?.preserveGitConfig ?? false,
+        includeParentRepository: settings.git?.includeParentRepository ?? true,
         path: stringValue(row, 'path'),
         kind: stringValue(row, 'kind'),
         gitSummary: summary === null ? null : JSON.parse(summary)

package/dist/migrations/v021.js

@@ -0,0 +1,64 @@
+import { DatabaseSync } from 'node:sqlite';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './v016.js';
+import { NODE_SCHEMA_MIGRATION_V17 } from './v017.js';
+import { NODE_SCHEMA_MIGRATION_V18 } from './v018.js';
+import { NODE_SCHEMA_MIGRATION_V19 } from './v019.js';
+import { NODE_SCHEMA_MIGRATION_V20 } from './v020.js';
+const sql = `ALTER TABLE workspaces ADD COLUMN settings TEXT NOT NULL DEFAULT '{}'
+  CHECK (json_valid(settings) AND json_type(settings) = 'object');
+UPDATE workspaces SET settings = json_object('git', json_object(
+  'preserveGitConfig', json(CASE WHEN preserve_git_config = 1 THEN 'true' ELSE 'false' END),
+  'includeParentRepository', json('true')));
+ALTER TABLE workspaces DROP COLUMN preserve_git_config;
+CREATE TABLE node_settings (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  settings TEXT NOT NULL CHECK (json_valid(settings) AND json_type(settings) = 'object')
+) STRICT;
+INSERT INTO node_settings (id, settings)
+SELECT 1, json_object('runnerDefaults', json_group_object(runner,
+  json_object('model', model, 'effort', effort, 'access', access))) FROM runner_defaults;
+DROP TABLE runner_defaults;`;
+export const NODE_SCHEMA_MIGRATION_V21 = {
+    version: 21,
+    sql,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V20.assert(database),
+    assert(database) {
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            for (const migration of [
+                NODE_SCHEMA_MIGRATION_V14,
+                NODE_SCHEMA_MIGRATION_V15,
+                NODE_SCHEMA_MIGRATION_V16,
+                NODE_SCHEMA_MIGRATION_V17,
+                NODE_SCHEMA_MIGRATION_V18,
+                NODE_SCHEMA_MIGRATION_V19,
+                NODE_SCHEMA_MIGRATION_V20
+            ])
+                reference.exec(migration.sql);
+            reference.exec(sql);
+            const schema = (db) => db
+                .prepare("SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name")
+                .all()
+                .map((row) => [
+                row.type,
+                row.name,
+                row.name === 'node_schema_migrations'
+                    ? String(row.sql).replace(/\s+/g, '')
+                    : String(row.sql).replace(/\s+/g, ' ').trim()
+            ]);
+            const expected = schema(reference);
+            const actual = schema(database);
+            const mismatch = expected.find((row) => !actual.some((value) => JSON.stringify(value) === JSON.stringify(row))) ??
+                actual.find((row) => !expected.some((value) => JSON.stringify(value) === JSON.stringify(row)));
+            if (mismatch !== undefined)
+                throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${String(mismatch[1])}`);
+        }
+        finally {
+            reference.close();
+        }
+    }
+};

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

@@ -1,122 +1,9 @@
-import { conversationSegmentIdentityForItem, conversationSegments } from './conversation-segment-service.js';
-import { runConversationItemId } from '../runtime-state.js';
-import { marctlSessionProgress } from './session-recent-activity.js';
-import { isNodeAgentRun, isNodeConversationTurn, isPlainRecord } from '../runner/codex/conversation-parser.js';
-export function workbenchPayloadSessionId(runtime, category, payload) {
-    if (!isPlainRecord(payload))
-        return undefined;
-    if (category === 'session') {
-        if (isPlainRecord(payload.session)) {
-            const id = payload.session.id;
-            if (typeof id === 'string')
-                return id;
-        }
-        return typeof payload.sessionId === 'string' ? payload.sessionId : undefined;
-    }
-    if (category === 'run' && isNodeAgentRun(payload.run))
-        return payload.run.sessionId;
-    if (category === 'conversation') {
-        if (isNodeConversationTurn(payload.turn))
-            return payload.turn.sessionId;
-        if (typeof payload.sessionId === 'string')
-            return payload.sessionId;
-        if (isPlainRecord(payload.event)) {
-            const runId = payload.event.runId;
-            return typeof runId === 'string' ? runtime.getRun(runId)?.sessionId : undefined;
-        }
-    }
-    if (category === 'queue') {
-        const id = payload.sessionId;
-        return typeof id === 'string' ? id : undefined;
-    }
-    return undefined;
-}
 /** Bridges process-local Run state to normalized control and Workbench events. */
 export class NodeRunEventBridge {
     options;
     constructor(options) {
         this.options = options;
     }
-    /** The sole public projection boundary for normalized Run callbacks. */
-    projectWorkbenchPayload(category, payload) {
-        if (category === 'conversation' &&
-            isPlainRecord(payload) &&
-            isPlainRecord(payload.event) &&
-            payload.event.eventType !== 'notification') {
-            const runId = typeof payload.event.runId === 'string' ? payload.event.runId : undefined;
-            const sequence = typeof payload.event.sequence === 'number' ? payload.event.sequence : undefined;
-            const turn = runId === undefined ? undefined : this.options.runtime.conversationTurnForRun(runId);
-            if (turn === undefined)
-                return;
-            const rawPayload = isPlainRecord(payload.event.payload) ? payload.event.payload : undefined;
-            const text = payload.event.eventType === 'text.delta' && typeof rawPayload?.text === 'string'
-                ? rawPayload.text
-                : undefined;
-            const nativeItemId = typeof rawPayload?.itemId === 'string'
-                ? rawPayload.itemId
-                : typeof rawPayload?.approvalId === 'string'
-                    ? `approval:${rawPayload.approvalId}`
-                    : undefined;
-            const item = text !== undefined && sequence !== undefined
-                ? turn.items.find((candidate) => candidate.kind === 'assistant_message' && candidate.revision === sequence)
-                : nativeItemId === undefined
-                    ? undefined
-                    : turn.items.find((candidate) => candidate.id ===
-                        runConversationItemId(runId, nativeItemId, typeof rawPayload?.kind === 'string' ? rawPayload.kind : undefined));
-            if (text !== undefined && item?.kind === 'assistant_message') {
-                const segment = conversationSegmentIdentityForItem(turn, item.id, item.kind);
-                payload = {
-                    sessionId: turn.sessionId,
-                    delta: {
-                        turnId: turn.id,
-                        segmentId: segment.id,
-                        segmentIndex: segment.index,
-                        runId: turn.runId,
-                        itemId: item.id,
-                        text,
-                        createdAt: typeof payload.event.createdAt === 'number' ? payload.event.createdAt : Date.now()
-                    }
-                };
-            }
-            else if (item !== undefined) {
-                const segment = conversationSegmentIdentityForItem(turn, item.id, item.kind);
-                payload = {
-                    sessionId: turn.sessionId,
-                    runId: turn.runId,
-                    ...(['assistant_message', 'tool_call', 'command_execution', 'file_change'].includes(item.kind) &&
-                        (rawPayload?.append === undefined || item.status !== 'IN_PROGRESS')
-                        ? { progress: marctlSessionProgress(this.options.runtime, turn.sessionId) }
-                        : {}),
-                    item: {
-                        turnId: turn.id,
-                        itemId: item.id,
-                        kind: item.kind,
-                        status: item.status,
-                        payload: item.payload,
-                        startedAt: item.startedAt,
-                        completedAt: item.completedAt,
-                        segmentId: segment.id,
-                        segmentIndex: segment.index
-                    }
-                };
-            }
-            else {
-                if (payload.event.eventType !== 'run.started' && payload.event.eventType !== 'run.running')
-                    return;
-                payload = { turn };
-            }
-        }
-        if (category === 'conversation' &&
-            isPlainRecord(payload) &&
-            isNodeConversationTurn(payload.turn))
-            return { ...payload, segments: conversationSegments(payload.turn) };
-        if (category === 'run' && isPlainRecord(payload) && isNodeAgentRun(payload.run))
-            return {
-                ...payload,
-                progress: marctlSessionProgress(this.options.runtime, payload.run.sessionId)
-            };
-        return payload;
-    }
     emitConversationItem(runId, item) {
         this.emitRun(runId, 'conversation.item', item);
     }

package/dist/service/node-workspace-coordinator.js

@@ -1,3 +1,5 @@
+import { realpath } from 'node:fs/promises';
+import { nodeLog } from '../operational.js';
 import { inspectWorkspace, normalizeWorkspacePath } from '../workspace.js';
 import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
 /** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
@@ -18,7 +20,7 @@ export class NodeWorkspaceCoordinator {
         const config = this.options.config();
         if (config === undefined)
             throw new Error('NODE_CONFIG_UNAVAILABLE');
-        const inspection = await inspectWorkspace(workspace.path, config.allowedRoots);
+        const inspection = await inspectWorkspace(workspace.path, config.allowedRoots, workspace.includeParentRepository ?? true);
         if (normalizeWorkspacePath(inspection.path) !== normalizeWorkspacePath(workspace.path))
             throw new Error('WORKSPACE_NOT_ALLOWED');
         return inspection;
@@ -29,8 +31,14 @@ export class NodeWorkspaceCoordinator {
             throw new Error('NODE_DATABASE_UNAVAILABLE');
         if (normalizeWorkspacePath(inspection.path) !== normalizeWorkspacePath(workspace.path))
             throw new Error('WORKSPACE_NOT_ALLOWED');
+        const current = this.require(workspace.id);
+        if ((current.includeParentRepository ?? true) !== (workspace.includeParentRepository ?? true))
+            return current;
         if (workspace.kind !== 'GIT_WORKSPACE' && inspection.kind === 'GIT_WORKSPACE')
-            await ensureWorkspaceGitExclude(workspace.path);
+            await ensureWorkspaceGitExclude(workspace.path, workspace.includeParentRepository ?? true);
+        if ((this.require(workspace.id).includeParentRepository ?? true) !==
+            (workspace.includeParentRepository ?? true))
+            return this.require(workspace.id);
         const saved = database.saveWorkspace({
             id: workspace.id,
             path: workspace.path,
@@ -57,6 +65,14 @@ export class NodeWorkspaceCoordinator {
     invalidateChanges(workspaceId) {
         this.options.changes.invalidate(workspaceId);
     }
+    gitPolicyChanged(workspaceId) {
+        this.invalidate(workspaceId);
+        const workspace = this.require(workspaceId);
+        void this.inspectMetadata(workspace)
+            .then((inspection) => this.commitMetadata(workspace, inspection))
+            .then(() => this.invalidate(workspaceId))
+            .catch(() => nodeLog('workspace.git-policy.refresh-failed', { workspaceId }));
+    }
     persistTerminal(summary) {
         const database = this.options.database();
         if (database === undefined)
@@ -87,7 +103,9 @@ export class NodeWorkspaceCoordinator {
             return;
         }
         try {
-            const inspection = await inspectWorkspace(requestedPath, config.allowedRoots);
+            const path = await realpath(requestedPath);
+            const current = this.options.database()?.getWorkspaceByPath(path);
+            const inspection = await inspectWorkspace(path, config.allowedRoots, current?.includeParentRepository ?? true);
             this.options.send('workspace.inspect.result', inspection, envelope.id);
         }
         catch {

package/dist/service/scheduled-session-coordinator.js

@@ -16,24 +16,22 @@ export class ScheduledSessionCoordinator {
         const store = this.options.store();
         store.finish(run.clientMessageId, status === 'SUCCEEDED' ? 'SUCCEEDED' : 'FAILED', status === 'SUCCEEDED' ? undefined : `SCHEDULE_RUN_${status}`, run.id);
         const task = store.getById(run.clientMessageId.split(':', 1)[0]);
-        if (task !== undefined) {
-            if (task.notifyOnTerminal)
-                this.publishTaskNotification(task, run.clientMessageId, {
-                    kind: 'SCHEDULE_TERMINAL',
-                    outcome: status,
-                    runId: run.id
-                });
-            else if (status !== 'SUCCEEDED')
-                this.notify(task, run.clientMessageId, `SCHEDULE_RUN_${status}`, 'FAILED');
-        }
+        if (task !== undefined)
+            this.publishTaskNotification(task, run.clientMessageId, {
+                kind: 'SCHEDULE_TERMINAL',
+                outcome: status,
+                runId: run.id
+            });
     }
     notify = (task, occurrenceId, code, status) => this.publishTaskNotification(task, occurrenceId, {
         kind: status === 'FAILED' ? 'SCHEDULE_FAILED' : 'SCHEDULE_SKIPPED',
         code
     });
     publishTaskNotification = (task, occurrenceId, event) => {
+        const currentTask = this.options.store().getById(task.id) ?? task;
+        if (!currentTask.notifyOnTerminal)
+            return;
         const occurredAt = Date.now();
-        const recipient = this.options.store().getById(task.id)?.ownerUserId ?? task.ownerUserId;
         this.options.emitNotification({
             event: {
                 runId: event.kind === 'SCHEDULE_TERMINAL' ? event.runId : occurrenceId,
@@ -41,7 +39,7 @@ export class ScheduledSessionCoordinator {
                 eventType: 'notification',
                 payload: {
                     targetType: 'WORKSPACE_SESSION',
-                    userId: recipient,
+                    userId: currentTask.ownerUserId,
                     workspaceId: task.workspaceId,
                     sessionId: task.sessionId,
                     sessionTitle: this.options.sessionTitle(task.sessionId),

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

@@ -22,11 +22,11 @@ export class SkillDirectoryService {
                 : agents.map(withoutSource)
         };
     }
-    async inspectWorkspace(workspace) {
+    async inspectWorkspace(workspace, includeParentRepository = true) {
         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 hasBrokenWorkspaceSkillGitExclude(workspace, skills.map((skill) => skill.name));
+        const gitExcludeBroken = await hasBrokenWorkspaceSkillGitExclude(workspace, skills.map((skill) => skill.name), includeParentRepository);
         return {
             targetKind: 'WORKSPACE',
             compatibilityMode: 'MANAGED_COPY',

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 { GitCommandError, resolveWorkspaceGitRoot } from '../workspace.js';
 import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
 export class SkillInstallService {
     async recoverNodeHome(home) {
@@ -59,15 +60,15 @@ export class SkillInstallService {
         await mkdir(claudeRoot, { recursive: true });
         await assertContainedDirectory(workspace, agentsRoot);
         await assertContainedDirectory(workspace, claudeRoot);
-        await replacePair(agentsRoot, claudeRoot, name, bundle, metadata, () => updateWorkspaceSkillGitExclude(workspace, name, true), () => updateWorkspaceSkillGitExclude(workspace, name, false));
+        await replacePair(agentsRoot, claudeRoot, name, bundle, metadata, () => updateWorkspaceSkillGitExclude(workspace, name, true, options.includeParentRepository ?? true), () => updateWorkspaceSkillGitExclude(workspace, name, false, options.includeParentRepository ?? true));
     }
-    async removeWorkspace(workspace, name) {
+    async removeWorkspace(workspace, name, includeParentRepository = true) {
         assertName(name);
         const agentsRoot = path.join(workspace, '.agents', 'skills');
         const claudeRoot = path.join(workspace, '.claude', 'skills');
         await assertExistingContainedDirectory(workspace, agentsRoot);
         await assertExistingContainedDirectory(workspace, claudeRoot);
-        await removePair(agentsRoot, claudeRoot, name, () => updateWorkspaceSkillGitExclude(workspace, name, false), () => updateWorkspaceSkillGitExclude(workspace, name, true));
+        await removePair(agentsRoot, claudeRoot, name, () => updateWorkspaceSkillGitExclude(workspace, name, false, includeParentRepository), () => updateWorkspaceSkillGitExclude(workspace, name, true, includeParentRepository));
     }
     async removeNodeHome(home, name) {
         assertName(name);
@@ -81,7 +82,7 @@ export class SkillInstallService {
         else
             await removeSingle(agentsRoot, name);
     }
-    async repairWorkspaceGitExclude(workspace) {
+    async repairWorkspaceGitExclude(workspace, includeParentRepository = true) {
         const root = path.join(workspace, '.agents', 'skills');
         const names = new Set();
         try {
@@ -101,13 +102,20 @@ export class SkillInstallService {
             if (!isMissing(error))
                 throw error;
         }
-        await rewriteWorkspaceGitExclude(workspace, names);
+        await rewriteWorkspaceGitExclude(workspace, names, includeParentRepository);
     }
 }
 export async function workspaceSkillTracked(workspace, name) {
     assertName(name);
-    if (!(await exists(path.join(workspace, '.git'))))
-        return false;
+    try {
+        await resolveWorkspaceGitRoot(workspace);
+    }
+    catch (error) {
+        if ((error instanceof GitCommandError && error.code === 128) ||
+            error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
     try {
         const result = await promisify(execFile)('git', ['-C', workspace, 'ls-files', '--', `.agents/skills/${name}`, `.claude/skills/${name}`], { timeout: 5_000, windowsHide: true });
         return result.stdout.trim() !== '';

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

@@ -28,14 +28,14 @@ export class SkillNodeOperationService {
             'workspace.skills.inspect': async (data) => {
                 const workspace = this.workspacePath(record(data)['workspaceId']);
                 await this.installer.recoverWorkspace(workspace);
-                return this.directories.inspectWorkspace(workspace);
+                return this.directories.inspectWorkspace(workspace, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
             },
             'workspace.skills.install': (data) => this.install('WORKSPACE', data),
             'workspace.skills.remove': (data) => this.remove('WORKSPACE', data),
             'workspace.skills.git-exclude-repair': async (data) => {
                 const workspace = this.workspacePath(record(data)['workspaceId']);
                 await this.installer.recoverWorkspace(workspace);
-                await this.installer.repairWorkspaceGitExclude(workspace);
+                await this.installer.repairWorkspaceGitExclude(workspace, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
                 return { repaired: true };
             },
             'skill.install.job.get': (data) => this.job(data)
@@ -113,7 +113,8 @@ export class SkillNodeOperationService {
             await this.installer.installNodeHome(homedir(), input.name, bundle, input.metadata);
         else
             await this.installer.installWorkspace(input.workspace, input.name, bundle, input.metadata, {
-                confirmTracked: true
+                confirmTracked: true,
+                includeParentRepository: this.database().getWorkspaceByPath(input.workspace)?.includeParentRepository ?? true
             });
     }
     async remove(target, data) {
@@ -131,7 +132,7 @@ export class SkillNodeOperationService {
             }
             else {
                 await this.installer.recoverWorkspace(workspace);
-                await this.installer.removeWorkspace(workspace, name);
+                await this.installer.removeWorkspace(workspace, name, this.database().getWorkspaceByPath(workspace)?.includeParentRepository ?? true);
             }
         }
         finally {