@dsh-electron/dsh-plugin-multi-root-workspace 0.1.14 → 0.1.15

package/lib/skills.js

@@ -1,7 +1,8 @@
-import { t as wrapMethod } from "./method-wrapper-CFY3p3j2.js";
+import { t as wrapMethod } from "./method-wrapper-D4oUCsEF.js";
 import { c as withRegistryRead } from "./registry-operation-C2ZV3Jhw.js";
-import { r as isPackageInstalled, t as createInstructionMessage } from "./llm-message-fYORacvh.js";
-import { n as skillsMetadataValid } from "./metadata-DgqSdVX_.js";
+import { t as createInstructionMessage } from "./llm-message-CepyzEBQ.js";
+import { n as skillsMetadataValid } from "./metadata-99jgViHQ.js";
+import { a as skillOrigin, i as skillAgent, n as filesystemSkillsApi, o as volatileField, r as observedSkillOrigin, t as configValue } from "./skills-utyuvmwr.js";
 import { constants, statSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -10,108 +11,6 @@ import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { lstat, open, readdir, stat } from "node:fs/promises";
 import z from "@deepseek-ai/schemastery";
-//#region \0@oxc-project+runtime@0.149.0/helpers/esm/usingCtx.js
-function _usingCtx() {
-	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
-		var n = Error();
-		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
-	}, e = {}, n = [];
-	function using(r, e) {
-		if (null != e) {
-			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
-			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
-			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
-			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
-			t && (o = function o() {
-				try {
-					t.call(e);
-				} catch (r) {
-					return Promise.reject(r);
-				}
-			}), n.push({
-				v: e,
-				d: o,
-				a: r
-			});
-		} else r && n.push({
-			d: e,
-			a: r
-		});
-		return e;
-	}
-	return {
-		e,
-		u: using.bind(null, !1),
-		a: using.bind(null, !0),
-		d: function d() {
-			var o, t = this.e, s = 0;
-			function next() {
-				for (; o = n.pop();) try {
-					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
-					if (o.d) {
-						var r = o.d.call(o.v);
-						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
-					} else s |= 1;
-				} catch (r) {
-					return err(r);
-				}
-				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
-				if (t !== e) throw t;
-			}
-			function err(n) {
-				return t = t !== e ? new r(n, t) : n, next();
-			}
-			return next();
-		}
-	};
-}
-//#endregion
-//#region src/compat/skills.ts
-/** Never infer authority from cwd, a preset key, or a lookalike Agent. */
-function skillAgent(ctx, options) {
-	const scope = options.scope;
-	if (typeof scope !== "object" || scope === null || !("id" in scope) || typeof scope.id !== "string") return void 0;
-	const agent = ctx.get("agents")?.get(scope.id);
-	return agent === scope ? agent : void 0;
-}
-function skillOrigin(ctx, options) {
-	const cwd = skillAgent(ctx, options)?.session.header.cwd;
-	return typeof cwd === "string" && cwd !== "" ? canonicalPath(cwd) : void 0;
-}
-/** Absence is optional; a present but broken module must fail visibly. */
-async function filesystemSkillsApi() {
-	if (!isPackageInstalled("@deepseek-ai/dsh-skill-filesystem")) return void 0;
-	const api = await import("@deepseek-ai/dsh-skill-filesystem");
-	if (typeof api.FileSystemSkillProvider !== "function") throw new Error("multi-root skills: FileSystemSkillProvider is unavailable");
-	return api;
-}
-function volatileField(schema) {
-	const method = schema.volatile;
-	return typeof method === "function" ? method.call(schema) : schema;
-}
-function configValue(value) {
-	if (typeof value === "object" && value !== null && Symbol.for("cosmokit.volatile.write") in value) {
-		const get = value.get;
-		if (typeof get === "function") return get.call(value);
-	}
-	return value;
-}
-/** Cold Browser Catalog supplies a Session header, never a fabricated Agent. */
-async function observedSkillOrigin(ctx, sessionId) {
-	try {
-		var _usingCtx$1 = _usingCtx();
-		const query = ctx.get("sessionQuery");
-		if (query === void 0) throw new Error("multi-root skills: SessionQuery is unavailable");
-		const cwd = _usingCtx$1.u(await query.observeSession(sessionId)).header.cwd;
-		if (typeof cwd !== "string" || cwd === "") throw new Error("multi-root skills: Session has no origin");
-		return canonicalPath(cwd);
-	} catch (_) {
-		_usingCtx$1.e = _;
-	} finally {
-		_usingCtx$1.d();
-	}
-}
-//#endregion
 //#region src/skills/reader.ts
 /** Constrain the native parser before discovery can read a candidate's body. */
 function containsPath(root, target) {

package/lib/{tool-context-CpgIFcCB.js → tool-context-CCeY3mrK.js}

@@ -1,6 +1,6 @@
 //#region src/compat/tool-context.ts
 function aroundTool(ctx, listener) {
-	ctx.on.call(ctx, "tools/execute", listener);
+	ctx.on.call(ctx, "tools/execute", listener, { global: true });
 }
 //#endregion
 export { aroundTool as t };

package/lib/types/authority/protocol.d.ts

@@ -29,7 +29,11 @@ export declare const snapshotSchema: z.ZodObject<{
             invalid: "invalid";
         }>;
         detail: z.ZodOptional<z.ZodString>;
-        invalidReason: z.ZodOptional<z.ZodLiteral<"membership-conflict">>;
+        invalidReason: z.ZodOptional<z.ZodEnum<{
+            "membership-conflict": "membership-conflict";
+            "protected-path": "protected-path";
+            "primary-overlap": "primary-overlap";
+        }>>;
     }, z.core.$strict>>;
     available: z.ZodBoolean;
 }, z.core.$strict>;

package/lib/types/client/locales.d.ts

@@ -21,6 +21,16 @@ export declare const zh: {
     'autoReview.loadFailed': string;
     'autoReview.restartRequired': string;
     'autoReview.settingsFailed': string;
+    'ops.compatibilityEnable': string;
+    'ops.experimental': string;
+    'ops.compatibilityHint': string;
+    'ops.settingsFailed': string;
+    'ops.confirmTitle': string;
+    'ops.confirmDescription': string;
+    'ops.confirmAcknowledge': string;
+    'ops.confirmCancel': string;
+    'ops.confirmClose': string;
+    'ops.confirmEnable': string;
     'skills.userOnly': string;
     'panel.skills': string;
     'panel.skillsEnabled': string;
@@ -65,6 +75,7 @@ export declare const zh: {
     'panel.copied': string;
     'panel.reveal': string;
     'panel.reRegister': string;
+    'panel.redirectedHint': string;
     'panel.moveUp': string;
     'panel.moveDown': string;
     'access.inherit': string;
@@ -101,6 +112,9 @@ export declare const zh: {
     'error.copy-failed': string;
     'error.session-not-found': string;
     'error.unsupported-path': string;
+    'error.protected-path': string;
+    'error.protected-boundary-unknown': string;
+    'error.revive-target-changed': string;
     'error.fallback': string;
 };
 /** The canonical key set. */
@@ -116,6 +130,16 @@ export declare const en: {
     'autoReview.loadFailed': string;
     'autoReview.restartRequired': string;
     'autoReview.settingsFailed': string;
+    'ops.compatibilityEnable': string;
+    'ops.experimental': string;
+    'ops.compatibilityHint': string;
+    'ops.settingsFailed': string;
+    'ops.confirmTitle': string;
+    'ops.confirmDescription': string;
+    'ops.confirmAcknowledge': string;
+    'ops.confirmCancel': string;
+    'ops.confirmClose': string;
+    'ops.confirmEnable': string;
     'skills.userOnly': string;
     'panel.skills': string;
     'panel.skillsEnabled': string;
@@ -160,6 +184,7 @@ export declare const en: {
     'panel.copied': string;
     'panel.reveal': string;
     'panel.reRegister': string;
+    'panel.redirectedHint': string;
     'panel.moveUp': string;
     'panel.moveDown': string;
     'access.inherit': string;
@@ -196,6 +221,9 @@ export declare const en: {
     'error.copy-failed': string;
     'error.session-not-found': string;
     'error.unsupported-path': string;
+    'error.protected-path': string;
+    'error.protected-boundary-unknown': string;
+    'error.revive-target-changed': string;
     'error.fallback': string;
 };
 declare module '@deepseek-ai/dsh-client-ui-slots' {

package/lib/types/client/ops-settings.d.ts

@@ -0,0 +1,6 @@
+import type { SkillsForm } from '../compat/skills-client.ts';
+import type { Translate } from './WorkspaceFoldersAction.tsx';
+export declare function OpsCompatibilitySettingsCard({ form, t }: {
+    form: SkillsForm;
+    t: Translate;
+}): import("react").JSX.Element | null;

package/lib/types/client/skills-settings.d.ts

@@ -10,12 +10,13 @@ export declare function SkillsSettingsCard({ form, t }: CardProps): import("reac
 /**
  * The bundle's one `plugins.bundle.config` cell: every plugin-level switch the
  * package offers, in display order. Each row owns its own form and write path —
- * Skills through its settings namespace, Auto Review through the Plugin
+ * Skills and OPS through their settings namespaces, Auto Review through the Plugin
  * Manager's Loader-row enablement — so one cell never serializes their state.
  */
-export declare function BundleSettingsCard({ form, autoReviewForm, t }: {
+export declare function BundleSettingsCard({ form, autoReviewForm, opsForm, t }: {
     form?: SkillsForm | undefined;
     autoReviewForm?: AutoReviewForm | undefined;
+    opsForm?: SkillsForm | undefined;
     t: Translate;
 }): import("react").JSX.Element;
 export declare function installSkillsSettingsCard(ctx: Context, t: Translate): void;

package/lib/types/command.d.ts

@@ -1,6 +1,6 @@
 /**
- * The user-facing surface: the `/workspace-folders` command and the panel's
- * RPC channel.
+ * The user-facing surface: the `/workspace-folders` command, its `/add-dirs`
+ * alias for adding a root, and the panel's RPC channel.
  *
  * They share one module because they are one thing — the operator-facing edge
  * over `ctx.multiRootRegistry`. The command serves the text surfaces (the
@@ -81,7 +81,7 @@ export declare function apply(ctx: Context, config?: CommandConfig): void;
  *
  * @param ctx - the host context that may carry `sessions`.
  * @param sessionId - the id the panel sent; already required by the wire schema.
- * @returns the canonical cwd of that session.
+ * @returns the session's cwd spelling, verbatim — the Registry key.
  * @throws {RootValidationError} `session-not-found` when the service is absent,
  *   the id does not name a live session, or that session has no cwd.
  */

package/lib/types/compat/instruction-activity.d.ts

@@ -9,9 +9,40 @@ export type FileActivity = {
     failed: boolean;
 };
 export declare function ptcFileActivity(event: unknown): FileActivity | undefined;
+export declare function stableOpsJson(value: unknown): string;
+export declare const opsActivityEvidenceKey: (kind: "native" | "ptc", id: string, name: string, args: unknown) => string;
+export interface OpsActivityEvidence {
+    readonly targets: readonly OpsFileTarget[];
+    readonly complete: boolean;
+}
 /** Rebuild read-only discovery candidates from successful durable activity after resume. */
-export declare function replayedInstructionTargets(events: readonly unknown[], origin: string | undefined): readonly string[];
+export declare function replayedInstructionTargets(events: readonly unknown[], origin: string | undefined, liveOpsEvidence?: ReadonlyMap<string, OpsActivityEvidence>, pendingExec?: {
+    readonly callId: string;
+    readonly name: string;
+    readonly arguments: unknown;
+    readonly parent?: unknown;
+}, options?: {
+    readonly opsCompatibility?: boolean;
+}): readonly string[];
 /** fs tools whose success touches the file at their `file_path` argument. */
 export declare const FILE_TOUCH_TOOL_NAMES: Record<string, true>;
 /** One explicit fs-tool target, shared with live touch capture. */
 export declare function touchedPathOfToolCall(name: string, argumentsJson: string): string | undefined;
+export interface OpsFileActivityInput {
+    name: string;
+    args: unknown;
+    cwd: string | undefined;
+    finalValue: unknown;
+    observedPaths: readonly string[];
+    isError?: boolean;
+}
+export interface OpsFileTarget {
+    path: string;
+    kind: 'read' | 'write' | 'remove';
+}
+export interface OpsFileActivity {
+    targets: readonly OpsFileTarget[];
+    complete: boolean;
+}
+export declare function normalizeOpsFileActivity(input: OpsFileActivityInput): OpsFileActivity;
+export declare function pendingInstructionTargets(name: string, args: unknown): readonly string[];

package/lib/types/compat/ops-confirmation.d.ts

@@ -0,0 +1,17 @@
+/** Keep the optional host confirmation component behind a structural probe. */
+import type { ComponentType } from 'react';
+export interface OpsConfirmationProps {
+    open: boolean;
+    title: string;
+    description: string;
+    acknowledgeLabel: string;
+    cancelLabel: string;
+    closeLabel: string;
+    confirmLabel: string;
+    acknowledged: boolean;
+    disabled?: boolean;
+    onAcknowledgedChange(value: boolean): void;
+    onCancel(): void;
+    onConfirm(): void;
+}
+export declare function opsRiskConfirmation(): ComponentType<OpsConfirmationProps> | undefined;

package/lib/types/compat/ops-settings.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Fiber } from '@deepseek-ai/cordis';
+export declare const OPS_SETTINGS_ID = "multi-root-ops-compatibility";
+/** Product availability policy, independent of structural Settings adaptation. */
+export declare function opsCompatibilityRelease(release: string | undefined): boolean;
+/** Unsupported hosts retain the config input but expose no editable live field. */
+export declare function opsCompatibilityField<S>(schema: S): S;
+export declare function installOpsCompatibilitySettings(ctx: Context, initial: () => unknown, changed: () => void): {
+    read(): unknown;
+    fiber: Fiber;
+};
+export declare function opsCompatibilityToken(ctx: Context): object | undefined;

package/lib/types/compat/ops-tools.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { MultiRootScopeService } from '../scope.ts';
+import type { ToolCaller } from './tool-context.ts';
+export declare const OPS_TOOL_PREFIX = "ops_";
+export declare const OPS_EXEC_NAMES: readonly string[];
+export type OpsToolKind = 'exec' | 'publish' | 'unknown' | 'other';
+export declare function classifyOpsTool(name: string): OpsToolKind;
+export interface OpsProtectionState {
+    owner: object | undefined;
+    entered: number;
+    readonly drainWaiters: Set<() => void>;
+}
+export declare function withOpsSpawnPermit<T>(state: OpsProtectionState, body: () => T): T;
+export declare function opsSpawnPermitted(state: OpsProtectionState): boolean;
+export declare function createOpsProtectionState(): OpsProtectionState;
+export declare function claimOpsProtection(state: OpsProtectionState): object;
+export declare function revokeOpsProtection(state: OpsProtectionState, token: object): void;
+export declare function opsProtectionReady(state: OpsProtectionState): boolean;
+export declare function assertOpsProtectionReady(state: OpsProtectionState): void;
+export declare function assertOpsProtectionOwner(state: OpsProtectionState, token: object): void;
+export declare function enterOpsProtection(state: OpsProtectionState): object;
+export declare function leaveOpsProtection(state: OpsProtectionState): void;
+export declare function drainOpsProtection(state: OpsProtectionState): Promise<void>;
+export declare function assertOpsPosixCacheAdmission(deniedRoots: readonly string[]): void;
+export declare function opsDispatchBarrier(ctx: Context, scope: MultiRootScopeService, exec: ToolCaller): string | undefined;

package/lib/types/compat/skills-client.d.ts

@@ -16,6 +16,7 @@ export interface SkillsForm {
         value: boolean;
     }[], revision?: number): Promise<boolean>;
 }
+export declare function bindSettingsForm(ctx: Context, entryId: string): SkillsForm | undefined;
 export declare function bindSkillsForm(ctx: Context): SkillsForm | undefined;
 export declare function clientInject(ctx: Context, services: string[], callback: (scope: Context) => void | (() => void)): void;
 export interface NamespaceRule {

package/lib/types/compat/tool-context.d.ts

@@ -5,5 +5,9 @@ export interface ToolCaller {
     readonly agent?: Agent;
     readonly callId: string;
     readonly name: string;
+    readonly arguments?: unknown;
+    readonly signal?: AbortSignal;
+    readonly parent?: unknown;
+    readonly token?: object;
 }
 export declare function aroundTool(ctx: Context, listener: (exec: ToolCaller, next: () => Promise<unknown>) => Promise<unknown>): void;

package/lib/types/compat.d.ts

@@ -57,8 +57,8 @@ export declare class DshCompatUnsupportedError extends Error {
  * `./compat/` detect the shape they need STRUCTURALLY — whether a return value
  * is a thenable, which export name a module carries — because a structural
  * probe also survives upstream reshaping something within one release, while a
- * version comparison does not. The release string here is for the gate and for
- * diagnostics.
+ * version comparison does not. The release string here is for installation and
+ * feature-availability gates (such as the OPS 0.2.* policy), and diagnostics.
  */
 export declare class MultiRootCompatService extends Service {
     /** The verdict this composition started under. */

package/lib/types/instructions.d.ts

@@ -4,7 +4,12 @@ declare module '@deepseek-ai/cordis' {
     interface Context {
         multiRootInstructions: {
             knownRoots(session: object): readonly string[];
-            snapshot(agent: Agent, roots: readonly string[], target: string | undefined, signal: AbortSignal): Promise<readonly CurrentRootInstruction[]>;
+            snapshot(agent: Agent, roots: readonly string[], target: string | readonly string[] | undefined, signal: AbortSignal, pending?: {
+                readonly callId: string;
+                readonly name: string;
+                readonly arguments: unknown;
+                readonly parent?: unknown;
+            }): Promise<readonly CurrentRootInstruction[]>;
         };
     }
 }

package/lib/types/ops-compatibility.d.ts

@@ -0,0 +1,34 @@
+import { Service, type Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export interface Config {
+    readonly enabled?: boolean;
+}
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    enabled: z<boolean, boolean, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: z<boolean, boolean, "defined">;
+}>>, "plain">;
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        multiRootOpsCompatibility: MultiRootOpsCompatibility;
+    }
+}
+export declare class MultiRootOpsCompatibility extends Service {
+    private readonly settingsConfig;
+    static Config: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>, "plain">;
+    static provide: string;
+    static inject: string[];
+    constructor(ctx: Context, settingsConfig?: Config);
+    private settingsRead;
+    private currentToken;
+    private enabledNow;
+    private closing;
+    get token(): object | undefined;
+    get enabled(): boolean;
+    private sync;
+}
+export default MultiRootOpsCompatibility;

package/lib/types/registry.d.ts

@@ -121,7 +121,12 @@ export type RegistryAuthorityState = {
 export interface Config {
     /** Absolute path of the store-wide kernel lock file. */
     readonly leasePath?: string;
-    /** Explicit medium binding for the multi-Host authority service. */
+    /**
+     * Medium binding for the multi-Host authority service — REQUIRED since the
+     * single-process mode was removed (ADR-0028). Absent or empty puts the
+     * registry in the fail-closed `config-invalid` state: no lease, no domain,
+     * no grants.
+     */
     readonly sharedStorageRoot?: string;
     /**
      * Cap on STORED additional-root records per primary root (every state
@@ -281,8 +286,15 @@ export declare class MultiRootRegistry extends Service {
     /** Keys already warned about a historical over-limit store (one warning each). */
     private readonly warnedOverLimit;
     /**
-     * @param ctx - the host context; `storageDomain` and `multiRootScope` are injected.
-     * @param config - the patch row's `leasePath` and `maxAdditionalRoots`.
+     * The canonical value each protected boundary resolved to the FIRST time it
+     * could be computed, keyed by boundary kind. Never re-pinned: a later
+     * rename or symlink swap of the DSH home (or of the lease directory) must
+     * not drop the boundary the registration rules were enforced under.
+     */
+    private readonly pinnedProtectedPaths;
+    /**
+     * @param ctx - the host context; `storage` and `multiRootScope` are injected.
+     * @param config - the patch row's `sharedStorageRoot`, `leasePath`, and `maxAdditionalRoots`.
      */
     constructor(ctx: Context, config?: Config);
     /**
@@ -379,6 +391,44 @@ export declare class MultiRootRegistry extends Service {
      */
     withOperation<T>(policy: SandboxExecutionPolicy, kind: RegistryOperationKind, body: (operation: RegistryOperation) => T | Promise<T>): Promise<T>;
     withPrimaryOperation<T>(policy: SandboxExecutionPolicy, body: () => T): T;
+    /**
+     * The spellings one protected boundary contributes: the configured path,
+     * its current canonical resolution, and the canonical value pinned the
+     * first time it resolved — never re-pinned, so a later rename or symlink
+     * swap of the protected directory cannot drop the boundary the
+     * registration rules were enforced under. The list is deduplicated by
+     * {@link samePath}.
+     */
+    private boundarySpellings;
+    /**
+     * The best-known protected-boundary set, plus whether it is COMPLETE.
+     *
+     * The set comes from trusted host configuration, never from a panel or
+     * shell claim: the scope row's `dshHome`, the physical medium
+     * `storeIdentity` bound, and the lease directory beside it.
+     * `complete` is false — and only NEW grants may then be refused — when a
+     * boundary cannot be proven: an invalid `dshHome` config, a configured
+     * home that is not a directory right now, or a medium that was never bound. Stored classification always consumes whatever IS known
+     * (pinned values included), so an unknown boundary never weakens the
+     * revalidation of existing records.
+     */
+    private protectedBoundarySet;
+    /**
+     * The protected DSH directories this Host can prove right now, or
+     * `undefined` when the set cannot be proven. `undefined` blocks every NEW
+     * grant; it never weakens the classification of stored records.
+     */
+    private protectedPaths;
+    /**
+     * Every protected entry this Host can prove — used wherever a partial set
+     * must still protect stored records and received snapshots.
+     */
+    private knownProtectedPaths;
+    /**
+     * The one refusal shared by the owner mutation path and the follower
+     * pre-check: the protected set cannot be proven, so no new grant is safe.
+     */
+    private static protectedBoundaryUnknown;
     /**
      * Registers one additional root.
      * @param primaryRoot - the session workspace root the root belongs to.
@@ -463,7 +513,7 @@ export declare class MultiRootRegistry extends Service {
     recheck(primaryRoot: string): Promise<readonly RootStatus[]>;
     /**
      * Observe registry changes.
-     * @param listener - called with the canonical primary root after each durable change.
+     * @param listener - called with the Registry key (`primaryKey()`, case-folded on Windows) after each durable change.
      * @returns the disposer that stops observing.
      */
     onChange(listener: (primaryRoot: string) => void): () => void;
@@ -495,10 +545,17 @@ export declare class MultiRootRegistry extends Service {
      */
     private statusesOf;
     /**
-     * The stored record set of one key, or `undefined` when there is none (or
-     * when the store itself could not be read: an unusable store reads as
-     * "nothing registered" so reads stay answerable and the surfaces can explain
-     * the situation, while every write fails loudly in `requireTable()`).
+     * The stored record set of one key: `{ record, migrated: false }` when the
+     * spelling key holds it; `{ record, migrated: true }` when only the legacy
+     * CANONICAL key does — stores written before the upstream primary spelling
+     * became the key (v0.1.14 and earlier). The fallback follows the CURRENT
+     * resolution ONLY for such a not-yet-migrated store; the first serialized
+     * access copies the record forward under the spelling key (see
+     * {@link reclassify}), after which resolution can never re-key a grant.
+     * `undefined` when there is no record (or when the store itself could not
+     * be read: an unusable store reads as "nothing registered" so reads stay
+     * answerable and the surfaces can explain the situation, while every write
+     * fails loudly in `requireTable()`).
      */
     private lookupRecords;
     /**
@@ -562,6 +619,8 @@ export declare class MultiRootRegistry extends Service {
     private commit;
     /** Deliver one key's notifications now, or collect them inside a commit. */
     private deliverNotifications;
+    /** Narrow owner rows for this Host, identically for projection and admission. */
+    private localSnapshotRoots;
     private applySnapshot;
     private remoteUnavailable;
     /**

package/lib/types/review-context.d.ts

@@ -8,8 +8,10 @@ declare module '@deepseek-ai/cordis' {
 }
 export interface ReviewExecution {
     readonly agent?: Agent;
+    readonly callId?: string;
     readonly name: string;
     readonly arguments: unknown;
+    readonly parent?: unknown;
 }
 export interface ReviewContext {
     readonly schemaVersion: 1;