@myagentroam/node 0.11.1 → 0.11.2

package/dist/connector.js

@@ -1343,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),

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-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/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 {

package/dist/service/workspace-change-service.js

@@ -2,7 +2,7 @@ import { lstat } from 'node:fs/promises';
 import { basename, posix, resolve } from 'node:path';
 import { publicErrorMessage } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
-import { GitCommandError, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository } from '../workspace.js';
+import { GitCommandError, isWorkspaceChangeVisible, listGitWorktrees, listGitSubmodules, readCurrentChangesSummary, resolveGitRepository, resolveWorkspaceGitRoot } from '../workspace.js';
 const CACHE_TTL_MS = 5_000;
 const REPOSITORY_READ_CONCURRENCY = 4;
 const WORKTREE_READ_CONCURRENCY = 4;
@@ -13,6 +13,9 @@ export class WorkspaceChangeService {
     constructor(state) {
         this.state = state;
     }
+    revision(workspaceId) {
+        return this.state.changesVersions.get(workspaceId) ?? 0;
+    }
     invalidate(workspaceId) {
         this.state.changesReads.delete(workspaceId);
         this.state.changesCache.delete(workspaceId);
@@ -34,7 +37,9 @@ export class WorkspaceChangeService {
             return existing;
         // Invalidation may arrive during this shared read; its old result must not repopulate the cache.
         const version = this.state.changesVersions.get(workspace.id) ?? 0;
-        const request = this.state.changesLimiter.run(async () => {
+        const request = this.state.changesLimiter
+            .run(async () => {
+            const repositoryRoot = await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true);
             const startedAt = performance.now();
             const errors = [];
             const failure = (code, error) => ({
@@ -66,7 +71,7 @@ export class WorkspaceChangeService {
             };
             const readRepository = async (repositoryPath, repositoryOverride) => {
                 const repository = repositoryOverride ??
-                    (await resolveGitRepository(workspace.path, repositoryPath, [repositoryPath]));
+                    (await resolveGitRepository(repositoryRoot, repositoryPath, [repositoryPath]));
                 if (repositoryPath !== '' || repositoryOverride !== undefined) {
                     const marker = await lstat(resolve(repository, '.git'));
                     if (marker.isSymbolicLink() || (!marker.isFile() && !marker.isDirectory()))
@@ -89,19 +94,14 @@ export class WorkspaceChangeService {
                     changes
                 };
             };
-            const root = await readRepository('').catch((error) => {
-                if (error?.code === 'ENOENT' &&
-                    error.syscall?.startsWith('spawn') === true)
-                    throw new Error('GIT_NOT_FOUND');
-                throw error;
-            });
+            const root = await readRepository('');
             const children = [];
             let parents = [''];
             let submodulesLimited = false;
             while (parents.length > 0 && !submodulesLimited) {
                 const discovered = await mapWithConcurrency(parents, REPOSITORY_READ_CONCURRENCY, async (parent) => {
                     try {
-                        const path = await resolveGitRepository(workspace.path, parent, [parent]);
+                        const path = await resolveGitRepository(repositoryRoot, parent, [parent]);
                         return (await listGitSubmodules(path)).map((entry) => ({
                             ...entry,
                             path: parent === '' ? entry.path : `${parent}/${entry.path}`
@@ -152,7 +152,7 @@ export class WorkspaceChangeService {
                     .map((entry) => entry.repositoryPath);
             }
             children.sort((left, right) => left.repositoryPath.localeCompare(right.repositoryPath));
-            const worktreeList = await listGitWorktrees(workspace.path).catch((error) => {
+            const worktreeList = await listGitWorktrees(repositoryRoot).catch((error) => {
                 discoveryFailure('WORKTREE', '', 'GIT_WORKTREE_DISCOVERY_FAILED', error);
                 return { entries: [], truncated: false };
             });
@@ -229,6 +229,13 @@ export class WorkspaceChangeService {
                 diffAvailable: true
             });
             const value = {
+                repositoryRoot,
+                workspace: {
+                    id: workspace.id,
+                    path: workspace.path,
+                    kind: 'GIT_WORKSPACE',
+                    gitSummary: { branch: root.branch, repositoryRoot }
+                },
                 partial: errors.length > 0 ||
                     children.some((group) => group.status === 'UNAVAILABLE') ||
                     linkedRepositories.some((group) => group.status === 'UNAVAILABLE') ||
@@ -240,7 +247,7 @@ export class WorkspaceChangeService {
                     {
                         ...root,
                         source: 'ROOT',
-                        physicalPath: currentWorktree?.path ?? workspace.path,
+                        physicalPath: currentWorktree?.path ?? repositoryRoot,
                         current: true,
                         ...(currentWorktree === undefined ? {} : { head: currentWorktree.head }),
                         status: root.dirty ? 'DIRTY' : 'CLEAN',
@@ -267,8 +274,17 @@ export class WorkspaceChangeService {
                     durationMs: Math.round(performance.now() - startedAt)
                 });
             if ((this.state.changesVersions.get(workspace.id) ?? 0) === version)
-                this.state.changesCache.set(workspace.id, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+                this.state.changesCache.set(workspace.id, {
+                    value,
+                    expiresAt: Date.now() + CACHE_TTL_MS
+                });
             return value;
+        })
+            .catch((error) => {
+            if (error?.code === 'ENOENT' &&
+                error.syscall?.startsWith('spawn') === true)
+                throw new Error('GIT_NOT_FOUND');
+            throw error;
         });
         this.state.changesReads.set(workspace.id, request);
         try {

package/dist/service/workspace-file-service.js

@@ -176,7 +176,9 @@ export class WorkspaceFileService {
         return { size: metadata.size, revision: metadata.sourceRevision };
     }
     async write(workspace, input) {
-        if (typeof input.path !== 'string' ||
+        if (input.repositoryPath !== undefined ||
+            input.worktreePath !== undefined ||
+            typeof input.path !== 'string' ||
             typeof input.content !== 'string' ||
             typeof input.expectedRevision !== 'string')
             throw new Error('FILE_WRITE_INVALID');

package/dist/service/workspace-git-exclude-service.js

@@ -1,53 +1,91 @@
 import { randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
-import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace.js';
 const MAR_TEMP_DIRECTORY = '/.mar/';
 const BLOCK_BEGIN = '# BEGIN MyAgentRoam';
 const BLOCK_END = '# END MyAgentRoam';
 const LEGACY_BLOCK_BEGIN = '# BEGIN MyAgentRoam Skills';
 const LEGACY_BLOCK_END = '# END MyAgentRoam Skills';
-export async function ensureWorkspaceGitExclude(workspace) {
-    await mutateGitExclude(workspace, () => undefined);
+export async function ensureWorkspaceGitExclude(workspace, includeParentRepository = true) {
+    await mutateGitExclude(workspace, () => undefined, includeParentRepository);
 }
-export async function updateWorkspaceSkillGitExclude(workspace, name, add) {
-    await mutateGitExclude(workspace, (entries) => {
+export async function updateWorkspaceSkillGitExclude(workspace, name, add, includeParentRepository = true) {
+    await mutateGitExclude(workspace, (entries, prefix) => {
         for (const root of ['.agents', '.claude']) {
-            const line = `/${root}/skills/${name}/`;
+            const line = `${prefix}${root}/skills/${name}/`;
             if (add)
                 entries.add(line);
             else
                 entries.delete(line);
         }
-    });
+    }, includeParentRepository);
 }
-export async function rewriteWorkspaceGitExclude(workspace, names) {
-    await mutateGitExclude(workspace, (entries) => {
-        entries.clear();
+export async function rewriteWorkspaceGitExclude(workspace, names, includeParentRepository = true) {
+    await mutateGitExclude(workspace, (entries, prefix) => {
+        for (const entry of entries)
+            if (['.agents', '.claude'].some((root) => entry.startsWith(`${prefix}${root}/skills/`)))
+                entries.delete(entry);
         for (const name of names)
             for (const root of ['.agents', '.claude'])
-                entries.add(`/${root}/skills/${name}/`);
-    });
+                entries.add(`${prefix}${root}/skills/${name}/`);
+    }, includeParentRepository);
 }
-export async function hasBrokenWorkspaceSkillGitExclude(workspace, names) {
-    if (!(await exists(path.join(workspace, '.git'))))
-        return false;
+export async function hasBrokenWorkspaceSkillGitExclude(workspace, names, includeParentRepository = true) {
     try {
-        const exclude = await resolveGitExclude(workspace);
+        const target = await gitExcludeTarget(workspace, includeParentRepository);
+        if (target === undefined)
+            return false;
+        const { exclude, prefix } = target;
         const content = await readFile(exclude, 'utf8');
         return names
-            .flatMap((name) => [`/.agents/skills/${name}/`, `/.claude/skills/${name}/`])
+            .flatMap((name) => [`${prefix}.agents/skills/${name}/`, `${prefix}.claude/skills/${name}/`])
             .some((entry) => !content.includes(entry));
     }
     catch {
         return true;
     }
 }
-async function mutateGitExclude(workspace, mutate) {
-    if (!(await exists(path.join(workspace, '.git'))))
+const mutationTails = new Map();
+async function gitExcludeTarget(workspace, includeParentRepository) {
+    let root;
+    try {
+        root = await resolveWorkspaceGitRoot(workspace, includeParentRepository);
+    }
+    catch (error) {
+        if ((error instanceof GitCommandError && error.code === 128) ||
+            (error instanceof Error && error.message === 'WORKSPACE_NOT_GIT') ||
+            error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    const relative = path
+        .relative(root, await realpath(workspace))
+        .split(path.sep)
+        .join('/');
+    const escaped = relative.replace(/[\\*?\[\]#! ]/g, '\\$&');
+    return { exclude: await resolveGitExclude(root), prefix: relative === '' ? '/' : `/${escaped}/` };
+}
+async function mutateGitExclude(workspace, mutate, includeParentRepository) {
+    const target = await gitExcludeTarget(workspace, includeParentRepository);
+    if (target === undefined)
         return;
-    const exclude = await resolveGitExclude(workspace);
+    const { exclude, prefix } = target;
+    const request = (mutationTails.get(exclude) ?? Promise.resolve())
+        .catch(() => undefined)
+        .then(() => writeGitExclude(exclude, (entries) => mutate(entries, prefix)));
+    mutationTails.set(exclude, request);
+    try {
+        await request;
+    }
+    finally {
+        if (mutationTails.get(exclude) === request)
+            mutationTails.delete(exclude);
+    }
+}
+async function writeGitExclude(exclude, mutate) {
     await mkdir(path.dirname(exclude), { recursive: true });
     let content = '';
     try {
@@ -62,7 +100,7 @@ async function mutateGitExclude(workspace, mutate) {
     }
     const pattern = managedBlockPattern();
     const existing = [...content.matchAll(pattern)].map((match) => match[0]).join('\n');
-    const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/.')));
+    const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/')));
     entries.delete(MAR_TEMP_DIRECTORY);
     mutate(entries);
     const block = entries.size === 0 ? '' : `${BLOCK_BEGIN}\n${[...entries].sort().join('\n')}\n${BLOCK_END}\n`;
@@ -97,17 +135,6 @@ async function resolveGitExclude(workspace) {
         throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
     }
 }
-async function exists(value) {
-    try {
-        await lstat(value);
-        return true;
-    }
-    catch (error) {
-        if (isMissing(error))
-            return false;
-        throw error;
-    }
-}
 function isMissing(error) {
     return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
 }

package/dist/service/workspace-service.js

@@ -1,4 +1,4 @@
-import { rmdir } from 'node:fs/promises';
+import { realpath, rmdir } from 'node:fs/promises';
 import { createWorkspaceDirectory, inspectWorkspace, listWorkspaceDirectories } from '../workspace.js';
 import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
 import { workspaceGitSettingsSchema } from '@myagentroam/protocol';
@@ -7,11 +7,13 @@ export class WorkspaceService {
     config;
     runtime;
     onRemoved;
-    constructor(database, config, runtime, onRemoved) {
+    onGitPolicyChanged;
+    constructor(database, config, runtime, onRemoved, onGitPolicyChanged = () => undefined) {
         this.database = database;
         this.config = config;
         this.runtime = runtime;
         this.onRemoved = onRemoved;
+        this.onGitPolicyChanged = onGitPolicyChanged;
     }
     operations() {
         return {
@@ -36,14 +38,28 @@ export class WorkspaceService {
             const path = typeof input.createDirectoryName === 'string'
                 ? (createdPath = await createWorkspaceDirectory(input.path, input.createDirectoryName, this.config().allowedRoots))
                 : input.path;
-            const inspected = await inspectWorkspace(path, this.config().allowedRoots);
-            await ensureWorkspaceGitExclude(inspected.path);
+            const canonicalPath = await realpath(path);
+            const current = this.database().getWorkspaceByPath(canonicalPath);
+            const includeParentRepository = current?.includeParentRepository ?? true;
+            const inspected = await inspectWorkspace(canonicalPath, this.config().allowedRoots, includeParentRepository);
+            let latest = this.database().getWorkspaceByPath(canonicalPath);
+            if (latest !== undefined &&
+                (latest.includeParentRepository ?? true) !== includeParentRepository)
+                return { workspace: latest };
+            if (inspected.kind === 'GIT_WORKSPACE') {
+                await ensureWorkspaceGitExclude(inspected.path, includeParentRepository);
+                latest = this.database().getWorkspaceByPath(canonicalPath);
+                if (latest !== undefined &&
+                    (latest.includeParentRepository ?? true) !== includeParentRepository)
+                    return { workspace: latest };
+            }
             return {
                 workspace: this.database().saveWorkspace({
                     path: inspected.path,
                     kind: inspected.kind,
                     gitSummary: inspected.gitSummary ?? null,
-                    preserveGitConfig: input.preserveGitConfig === true
+                    preserveGitConfig: input.preserveGitConfig === true,
+                    includeParentRepository
                 })
             };
         }
@@ -80,13 +96,22 @@ export class WorkspaceService {
         if (current === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
         if (!update)
-            return { preserveGitConfig: current.preserveGitConfig ?? true };
+            return {
+                preserveGitConfig: current.preserveGitConfig ?? true,
+                includeParentRepository: current.includeParentRepository ?? true
+            };
         const parsed = workspaceGitSettingsSchema.safeParse({
-            preserveGitConfig: input.preserveGitConfig
+            preserveGitConfig: input.preserveGitConfig,
+            includeParentRepository: input.includeParentRepository
         });
         if (!parsed.success)
             throw new Error('GIT_CONFIGURATION_INVALID');
-        const result = this.database().setWorkspaceGitPolicy(input.workspaceId, parsed.data.preserveGitConfig);
-        return { preserveGitConfig: result.preserveGitConfig };
+        const result = this.database().setWorkspaceGitPolicy(input.workspaceId, parsed.data.preserveGitConfig, parsed.data.includeParentRepository);
+        if (result.includeParentRepository !== current.includeParentRepository)
+            this.onGitPolicyChanged(current.id);
+        return {
+            preserveGitConfig: result.preserveGitConfig,
+            includeParentRepository: result.includeParentRepository
+        };
     }
 }

package/dist/service/workspace-watch-snapshot-service.js

@@ -15,15 +15,23 @@ export class WorkspaceWatchSnapshotService {
         if (watch.topics.files !== undefined)
             this.ensureFilesRefreshTimer();
         await Promise.all(this.subscribedTopics(watch).map(async (topic) => {
+            const revision = this.readRevision(workspace.id, topic);
             try {
                 const payload = await this.read(workspace, topic, watch);
                 if (!this.matches(workspace.id, watch))
                     return;
+                if (revision !== this.readRevision(workspace.id, topic)) {
+                    void this.invalidate(workspace.id, topic);
+                    return;
+                }
                 this.signatures.set(this.viewKey(workspace.id, topic, watch), signature(payload));
                 this.deliver(workspace, watch, topic, payload);
             }
             catch {
-                this.fail(workspace.id, watch, topic);
+                if (revision === this.readRevision(workspace.id, topic))
+                    this.fail(workspace.id, watch, topic);
+                else
+                    void this.invalidate(workspace.id, topic);
             }
         }));
     }
@@ -119,7 +127,22 @@ export class WorkspaceWatchSnapshotService {
             const first = subscribers[0];
             if (first === undefined)
                 return;
-            const payload = await this.read(workspace, topic, first);
+            const revision = this.readRevision(workspaceId, topic);
+            let payload;
+            try {
+                payload = await this.read(workspace, topic, first);
+            }
+            catch (error) {
+                if (revision !== this.readRevision(workspaceId, topic)) {
+                    void this.invalidate(workspaceId, topic);
+                    return;
+                }
+                throw error;
+            }
+            if (revision !== this.readRevision(workspaceId, topic)) {
+                void this.invalidate(workspaceId, topic);
+                return;
+            }
             const activeSubscribers = subscribers.filter((watch) => this.matches(workspaceId, watch));
             if (activeSubscribers.length === 0)
                 return;
@@ -157,7 +180,7 @@ export class WorkspaceWatchSnapshotService {
     read(workspace, topic, watch) {
         const key = topic === 'files'
             ? `${workspace.id}:files:${JSON.stringify(watch.topics.files)}`
-            : `${workspace.id}:${topic}`;
+            : `${workspace.id}:${topic}:${this.readRevision(workspace.id, topic)}`;
         const active = this.reads.get(key);
         if (active !== undefined)
             return active;
@@ -166,8 +189,12 @@ export class WorkspaceWatchSnapshotService {
             : topic === 'changes'
                 ? workspace.kind === 'GIT_WORKSPACE'
                     ? this.options.changes.current(workspace)
-                    : Promise.resolve(null)
-                : this.options.files.list(workspace, watch.topics.files).then((files) => ({ files }))).finally(() => {
+                    : Promise.resolve(workspace.includeParentRepository === false
+                        ? { workspace, changes: [], repositories: [] }
+                        : null)
+                : this.options.files
+                    .list(workspace, watch.topics.files)
+                    .then((files) => ({ files, workspace: this.options.requireWorkspace(workspace.id) }))).finally(() => {
             if (this.reads.get(key) === read)
                 this.reads.delete(key);
         });
@@ -181,6 +208,9 @@ export class WorkspaceWatchSnapshotService {
         this.signatures.set(key, next);
         return true;
     }
+    readRevision(workspaceId, topic) {
+        return topic === 'changes' ? this.options.changes.revision(workspaceId) : 0;
+    }
     viewKey(workspaceId, topic, watch) {
         return topic === 'files'
             ? `${workspaceId}:files:${JSON.stringify(watch.topics.files)}`

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

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
-import { listGitHistoryRefs, openGitHistoryFileContent, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, restoreCurrentChange } from '../workspace.js';
+import { isAbsolute, win32 } from 'node:path';
+import { listGitHistoryRefs, normalizeFilePreviewPath, openGitHistoryFileContent, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, resolveWorkspaceGitRoot, restoreCurrentChange } from '../workspace.js';
 import { WorkspaceCodeNavigationService } from './workspace-code-navigation-service.js';
 import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
 import { WorkspaceWatchController } from './workspace-watch-controller.js';
@@ -98,7 +99,7 @@ export class WorkspaceWorkbenchService {
     }
     async readPredictionFile(workspaceId, path, worktreePath) {
         const workspace = this.options.requireWorkspace(workspaceId);
-        const repository = await this.fileRepository(workspace, worktreePath ? { worktreePath } : {});
+        const repository = await this.fileRepository(workspace, worktreePath ? { worktreePath, path } : {});
         const { readWorkspaceTextFile } = await import('../workspace.js');
         return readWorkspaceTextFile(repository, path, 0, 64 * 1024);
     }
@@ -180,7 +181,7 @@ export class WorkspaceWorkbenchService {
             (input.worktreePath !== undefined && typeof input.worktreePath !== 'string'))
             throw new Error('GIT_DIFF_INVALID');
         const workspace = this.gitWorkspace(input.workspaceId);
-        const repository = await resolveGitRepositoryTarget(workspace.path, input.repositoryPath ?? '', input.worktreePath);
+        const repository = await resolveGitRepositoryTarget(await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true), input.repositoryPath ?? '', input.worktreePath);
         return { diff: await readCurrentChangeDiff(repository, input.path) };
     }
     async restoreChange(input) {
@@ -191,7 +192,7 @@ export class WorkspaceWorkbenchService {
             (input.state !== 'STAGED' && input.state !== 'UNSTAGED' && input.state !== 'UNTRACKED'))
             throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
         const workspace = this.gitWorkspace(input.workspaceId);
-        const repository = await resolveGitRepositoryTarget(workspace.path, input.repositoryPath ?? '', input.worktreePath);
+        const repository = await resolveGitRepositoryTarget(await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true), input.repositoryPath ?? '', input.worktreePath);
         await restoreCurrentChange(repository, input.path, input.state);
         this.options.invalidate(workspace.id);
         return { restored: true };
@@ -201,14 +202,22 @@ export class WorkspaceWorkbenchService {
             (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string'))
             throw new Error('GIT_REPOSITORY_INVALID');
         const workspace = this.gitWorkspace(input.workspaceId);
-        return resolveGitRepository(workspace.path, input.repositoryPath ?? '');
+        return resolveGitRepository(await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true), input.repositoryPath ?? '');
     }
     async fileRepository(workspace, input) {
-        if (input.worktreePath === undefined)
+        if (input.worktreePath === undefined && input.repositoryPath === undefined)
             return workspace.path;
-        if (typeof input.worktreePath !== 'string')
+        if ((input.worktreePath !== undefined && typeof input.worktreePath !== 'string') ||
+            (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string'))
             throw new Error('GIT_REPOSITORY_INVALID');
-        return resolveGitRepositoryTarget(workspace.path, '', input.worktreePath);
+        if (typeof input.path !== 'string' ||
+            input.path.startsWith('mar-attachment:') ||
+            input.previewDirectory !== undefined)
+            throw new Error('FILE_PATH_ESCAPE');
+        const path = normalizeFilePreviewPath(input.path);
+        if (isAbsolute(path) || win32.isAbsolute(path))
+            throw new Error('FILE_PATH_ESCAPE');
+        return resolveGitRepositoryTarget(await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true), input.repositoryPath ?? '', input.worktreePath);
     }
     refs(input) {
         if (input.refs === undefined)
@@ -280,6 +289,9 @@ export class WorkspaceWorkbenchService {
             const input = {
                 workspaceId: workspace.id,
                 path: descriptor.resource.path,
+                ...(descriptor.resource.repositoryPath === undefined
+                    ? {}
+                    : { repositoryPath: descriptor.resource.repositoryPath }),
                 ...(descriptor.resource.worktreePath === undefined
                     ? {}
                     : { worktreePath: descriptor.resource.worktreePath })
@@ -372,12 +384,12 @@ export class WorkspaceWorkbenchService {
             typeof input.toRef !== 'string')
             throw new Error('GIT_DIFF_INVALID');
         const workspace = this.gitWorkspace(input.workspaceId);
-        return { diff: await readRestrictedDiff(workspace.path, input.fromRef, input.toRef) };
+        return {
+            diff: await readRestrictedDiff(await resolveWorkspaceGitRoot(workspace.path, workspace.includeParentRepository ?? true), input.fromRef, input.toRef)
+        };
     }
     gitWorkspace(workspaceId) {
         const workspace = this.options.requireWorkspace(workspaceId);
-        if (workspace.kind !== 'GIT_WORKSPACE')
-            throw new Error('WORKSPACE_NOT_GIT');
         return workspace;
     }
 }

package/dist/workspace.js

@@ -1187,7 +1187,7 @@ export function isWithinAllowedRoot(target, roots, platform = hostPlatform()) {
     });
 }
 /** Resolving both candidate and roots rejects Linux symlinks which point outside a root. */
-export async function inspectWorkspace(requestedPath, allowedRoots) {
+export async function inspectWorkspace(requestedPath, allowedRoots, includeParentRepository = true) {
     const resolvedPath = await realpath(requestedPath);
     const resolvedRoots = await Promise.all(allowedRoots.map((root) => realpath(root)));
     const directory = await stat(resolvedPath);
@@ -1195,16 +1195,40 @@ export async function inspectWorkspace(requestedPath, allowedRoots) {
         throw new Error('WORKSPACE_NOT_ALLOWED');
     }
     try {
-        const summary = await readGitSummary(resolvedPath);
+        const repositoryRoot = await resolveWorkspaceGitRoot(resolvedPath, includeParentRepository);
+        const summary = { ...(await readGitSummary(repositoryRoot)), repositoryRoot };
         return { path: resolvedPath, kind: 'GIT_WORKSPACE', gitSummary: summary };
     }
     catch (error) {
-        if ((error instanceof GitCommandError && error.code === 128) || isGitUnavailable(error)) {
+        if ((error instanceof GitCommandError && error.code === 128) ||
+            isGitUnavailable(error) ||
+            (error instanceof Error && error.message === 'WORKSPACE_NOT_GIT')) {
             return { path: resolvedPath, kind: 'DIRECTORY' };
         }
         throw error;
     }
 }
+/** Resolves the working tree without changing the registered Workspace identity. */
+export async function resolveWorkspaceGitRoot(workspacePath, includeParentRepository = true) {
+    const workspace = await resolveRegisteredWorkspaceRoot(workspacePath);
+    if (!includeParentRepository) {
+        const marker = await lstat(resolve(workspace, '.git')).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (marker === undefined ||
+            marker.isSymbolicLink() ||
+            (!marker.isFile() && !marker.isDirectory()))
+            throw new Error('WORKSPACE_NOT_GIT');
+    }
+    const result = await runReadOnlyGit(workspace, ['rev-parse', '--show-toplevel']);
+    const root = await realpath(result.text.replace(/\n$/u, ''));
+    if (!includeParentRepository &&
+        normalizeWorkspacePath(root) !== normalizeWorkspacePath(workspace))
+        throw new Error('WORKSPACE_NOT_GIT');
+    return root;
+}
 export async function readGitSummary(workspacePath) {
     const commonDir = (await runReadOnlyGit(workspacePath, ['rev-parse', '--git-common-dir'])).text.trim();
     const headResult = await runReadOnlyGitAllowFailure(workspacePath, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.1",
-    "@myagentroam/code-navigation": "0.11.0",
+    "@myagentroam/agent": "0.11.2",
+    "@myagentroam/protocol": "0.11.2",
     "@myagentroam/marctl": "0.11.0",
-    "@myagentroam/protocol": "0.11.1"
+    "@myagentroam/code-navigation": "0.11.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"