@timurproko/a1 0.2.6-dev.727 → 0.2.6-dev.736

package/dist/features/owned-ui/settings-app.js

@@ -1,6 +1,6 @@
 import { DIALOG_BACK_SHORTCUT_HINT, DIALOG_CLOSE_SHORTCUT_HINT } from "../../contracts/presentation/index.js";
-import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, assertNoShortcutConflicts, blockJumpTarget, numericValues, RAIL_COLUMNS, renderDialogPanel, renderSteppedDialogPanel, renderEmptyState, renderGroupHeader, renderInputRow, renderListRow, renderNote, renderShortcutHintsWithClose, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, truncateToWidth, valueColumnFor, valueMenuFrame, blockRowSpan, displayWidth, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, isThumbRow, layoutList, moveSelection, rowKey, scrollForSelection, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, ScrollbarRails, scrollbarWheelRows, selectableIndexes, } from "../../ui/components/index.js";
-import { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
+import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, assertNoShortcutConflicts, blockJumpTarget, numericValues, RAIL_COLUMNS, renderDialogPanel, renderSteppedDialogPanel, renderEmptyState, renderGroupHeader, renderInputRow, renderListRow, renderNote, renderShortcutHintsWithClose, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, truncateToWidth, valueColumnFor, valueMenuFrame, blockRowSpan, displayWidth, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, layoutList, moveSelection, rowKey, scrollForSelection, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, ScrollbarRails, scrollbarWheelRows, selectableIndexes, } from "../../ui/components/index.js";
+import { SETTINGS_APP_ID } from "./settings-route.js";
 export { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
 const SCOPE = SETTINGS_APP_ID;
 const SETTINGS_TOP_RULE_ROWS = 1;
@@ -265,8 +265,10 @@ export class SettingsApp {
                 const row = rows[selected];
                 if (row?.kind === "element" && row.value.structured)
                     this.#openStructured(row.value);
-                else
+                else if (row?.kind === "element" && typeof this.#shownValue(row.value) === "number")
                     this.#cycle(rows, selected, 1);
+                else
+                    this.#openMenu(rows, selected, true);
                 return { consumed: true };
             }
             case "move-up":
@@ -334,11 +336,11 @@ export class SettingsApp {
                 return { consumed: true, render: false };
             if (overRow === null) {
                 // Invariant: a press anywhere else dismisses the menu rather than acting through it.
-                this.#menu = null;
+                this.#closeMenu(menu);
                 return { consumed: true };
             }
             const value = menu.choices[overRow];
-            this.#menu = null;
+            this.#closeMenu(menu);
             if (value !== undefined)
                 this.#apply(menu.entry, value);
             return { consumed: true };
@@ -442,7 +444,7 @@ export class SettingsApp {
             clearTimeout(this.#activityTimer);
         this.#activityTimer = undefined;
     }
-    #openMenu(rows, selected) {
+    #openMenu(rows, selected, selectCurrent = false) {
         const row = rows[selected];
         if (row === undefined || row.kind !== "element")
             return;
@@ -461,9 +463,30 @@ export class SettingsApp {
             return;
         }
         const current = shown === null ? 0 : Math.max(0, entry.choices.indexOf(shown));
-        // Invariant: the opening press targeted the setting value, not an option. Keep the
-        // effective value as the keyboard origin without painting it as pointer-picked.
-        this.#menu = { entry, current, anchorKey: `${entry.backend}:${entry.id}`, choices: entry.choices, index: -1 };
+        const anchorKey = `${entry.backend}:${entry.id}`;
+        // Compatibility: pointer opening already brightens the source value. Enter borrows that
+        // same value-region state for the life of its menu rather than inventing a keyboard color.
+        if (selectCurrent) {
+            this.#hoverKey = anchorKey;
+            this.#hoverRegion = "value";
+        }
+        // Invariant: pointer opening stays inactive because it targeted the setting value, while
+        // Enter explicitly starts keyboard choice navigation at the value already in effect.
+        this.#menu = {
+            entry,
+            current,
+            anchorKey,
+            choices: entry.choices,
+            keyboardOpened: selectCurrent,
+            index: selectCurrent ? current : -1,
+        };
+    }
+    #closeMenu(menu) {
+        this.#menu = null;
+        if (!menu.keyboardOpened || this.#hoverKey !== menu.anchorKey)
+            return;
+        this.#hoverKey = null;
+        this.#hoverRegion = "label";
     }
     // Rationale: a structured setting opens as its own flag list rather than a value menu.
     #openStructured(entry) {
@@ -640,12 +663,12 @@ export class SettingsApp {
             return { consumed: false };
         const key = KEYS[data] ?? data;
         if (SETTINGS_SHORTCUTS.resolve(key, SCOPE) === "undo") {
-            this.#menu = null;
+            this.#closeMenu(menu);
             this.#undo();
             return { consumed: true };
         }
         if (key === "escape") {
-            this.#menu = null;
+            this.#closeMenu(menu);
             return { consumed: true };
         }
         if (key === "up" || key === "down") {
@@ -656,7 +679,7 @@ export class SettingsApp {
         }
         else if (key === "enter") {
             const value = menu.choices[menu.index];
-            this.#menu = null;
+            this.#closeMenu(menu);
             if (value !== undefined)
                 this.#apply(menu.entry, value);
         }
@@ -1084,9 +1107,6 @@ function changeFailure(outcome) {
 function labelOf(entry) {
     return entry.label ?? humanizeLabel(entry.id);
 }
-function isStepper(entry, shown = entry.value) {
-    return typeof shown === "number" && entry.editable;
-}
 /** Where a setting's number may go: what the engine states, or what it offers. */
 function rangeOf(entry) {
     return { minimum: entry.minimum, maximum: entry.maximum, values: numericValues(entry.choices) };

package/dist/foundation/lifecycle/index.d.ts

@@ -7,7 +7,7 @@ export { resolveCohortEndpoint, resolveProductPaths } from "./paths.js";
 export type { CohortEndpointPaths, ProductPaths } from "./paths.js";
 export { parseSessionSelection, sessionSelectionArguments } from "./session-selection.js";
 export type { SessionSelection } from "./session-selection.js";
-export { activateSessionRepositoryContext, clearSessionRepositoryContext, listSessionRepositoryWorktrees, readSessionRepositoryContext, registerSessionRepositoryRuntime, releaseSessionRepositoryRuntime, setSessionRepositoryContext, } from "./session-repository-context.js";
+export { PRIMARY_SESSION_AGENT_ID, activateSessionRepositoryContext, clearSessionRepositoryContext, listSessionRepositoryWorktrees, readSessionRepositoryContext, registerSessionRepositoryRuntime, releaseSessionRepositoryRuntime, setSessionRepositoryContext, } from "./session-repository-context.js";
 export type { SessionRepositoryContext, SessionRepositoryContextOptions, SessionRepositoryIdentity, SessionWorktreeInventoryEntry, SessionWorktreeStatus, } from "./session-repository-context.js";
 export { createSupervisorStartupAttempt, publishSupervisorStartupResult, readSupervisorStartupResult, supervisorStartupFailure, supervisorStartupReady, supervisorStartupResultPath, } from "./supervisor-startup.js";
 export type { SupervisorStartupAttemptIdentity, SupervisorStartupResult } from "./supervisor-startup.js";

package/dist/foundation/lifecycle/index.js

@@ -2,5 +2,5 @@ export { assertLaunchInstance, assertLaunchInstanceOutcome, assertLaunchInstance
 export { assertDimensions, assertLaunchProfileId, assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile } from "./model.js";
 export { resolveCohortEndpoint, resolveProductPaths } from "./paths.js";
 export { parseSessionSelection, sessionSelectionArguments } from "./session-selection.js";
-export { activateSessionRepositoryContext, clearSessionRepositoryContext, listSessionRepositoryWorktrees, readSessionRepositoryContext, registerSessionRepositoryRuntime, releaseSessionRepositoryRuntime, setSessionRepositoryContext, } from "./session-repository-context.js";
+export { PRIMARY_SESSION_AGENT_ID, activateSessionRepositoryContext, clearSessionRepositoryContext, listSessionRepositoryWorktrees, readSessionRepositoryContext, registerSessionRepositoryRuntime, releaseSessionRepositoryRuntime, setSessionRepositoryContext, } from "./session-repository-context.js";
 export { createSupervisorStartupAttempt, publishSupervisorStartupResult, readSupervisorStartupResult, supervisorStartupFailure, supervisorStartupReady, supervisorStartupResultPath, } from "./supervisor-startup.js";

package/dist/foundation/lifecycle/session-repository-context.d.ts

@@ -1,4 +1,6 @@
 import type { NativeProcessIdentity } from "./model.js";
+/** Records without an agent id were written by a single-agent release and belong to its one agent. */
+export declare const PRIMARY_SESSION_AGENT_ID = "primary";
 export interface SessionRepositoryIdentity {
     readonly sessionId: string;
     readonly sessionFile: string;
@@ -10,20 +12,24 @@ export interface SessionRepositoryContext {
 export type SessionWorktreeStatus = "current" | "busy" | "available" | "unverifiable";
 export interface SessionWorktreeInventoryEntry extends SessionRepositoryContext {
     readonly status: SessionWorktreeStatus;
+    /** Agent holding the claim within its runtime; null when the worktree is unclaimed or unverifiable. */
+    readonly agentId: string | null;
 }
 export interface SessionRepositoryContextOptions {
     readonly dataDir?: string;
     readonly signal?: AbortSignal;
     readonly runtimeId?: string;
+    /** Agent within the runtime that owns the claim; defaults to the primary agent. */
+    readonly agentId?: string;
     readonly runtimeIdentity?: NativeProcessIdentity;
     readonly inspectProcess?: (pid: number) => Promise<NativeProcessIdentity | null>;
     readonly lockTimeoutMs?: number;
 }
 /** Publish the exact live runtime that may acquire a delivery worktree. */
 export declare function registerSessionRepositoryRuntime(identity: SessionRepositoryIdentity, runtimeId: string, runtimeIdentity: NativeProcessIdentity, options?: SessionRepositoryContextOptions): Promise<void>;
-/** Revalidate a durable association and acquire its live claim for this runtime. */
+/** Revalidate a durable association and acquire its live claim for this runtime's agent; sibling agents' claims stay. */
 export declare function activateSessionRepositoryContext(identity: SessionRepositoryIdentity, runtimeId: string, runtimeIdentity: NativeProcessIdentity, options?: SessionRepositoryContextOptions): Promise<SessionRepositoryContext | null>;
-/** Release only this exact runtime generation's cooperative editing claims. */
+/** Release every agent's cooperative editing claims held by this exact runtime generation. */
 export declare function releaseSessionRepositoryRuntime(runtimeId: string, runtimeIdentity: NativeProcessIdentity, options?: SessionRepositoryContextOptions): Promise<void>;
 /** Persist one explicit same-repository worktree association after atomically claiming it. */
 export declare function setSessionRepositoryContext(identity: SessionRepositoryIdentity, worktreePath: string, options?: SessionRepositoryContextOptions): Promise<SessionRepositoryContext>;

package/dist/foundation/lifecycle/session-repository-context.js

@@ -13,52 +13,60 @@ const MAX_WORKTREES = 256;
 const GIT_TIMEOUT_MS = 5_000;
 const LOCK_TIMEOUT_MS = 2_000;
 const LOCK_RETRY_MS = 20;
+/** Records without an agent id were written by a single-agent release and belong to its one agent. */
+export const PRIMARY_SESSION_AGENT_ID = "primary";
+const RECORD_FORMAT_VERSION = 2;
 /** Publish the exact live runtime that may acquire a delivery worktree. */
 export async function registerSessionRepositoryRuntime(identity, runtimeId, runtimeIdentity, options = {}) {
     const header = await readSessionHeader(identity);
     assertRuntimeId(runtimeId);
+    const agentId = requireAgentId(options);
     assertProcessIdentity(runtimeIdentity);
-    await withClaimLock(options, async () => {
-        await writeRuntimeRecord(header, runtimeId, runtimeIdentity, options);
+    await withClaimLock({ ...options, runtimeIdentity }, async () => {
+        await writeRuntimeRecord(header, runtimeId, agentId, runtimeIdentity, options);
     });
 }
-/** Revalidate a durable association and acquire its live claim for this runtime. */
+/** Revalidate a durable association and acquire its live claim for this runtime's agent; sibling agents' claims stay. */
 export async function activateSessionRepositoryContext(identity, runtimeId, runtimeIdentity, options = {}) {
     const header = await readSessionHeader(identity);
     assertRuntimeId(runtimeId);
+    const agentId = requireAgentId(options);
     assertProcessIdentity(runtimeIdentity);
-    return await withClaimLock(options, async () => {
-        await writeRuntimeRecord(header, runtimeId, runtimeIdentity, options);
+    const owner = { runtimeId, agentId };
+    return await withClaimLock({ ...options, runtimeIdentity }, async () => {
+        await writeRuntimeRecord(header, runtimeId, agentId, runtimeIdentity, options);
         const record = await readContextRecord(header, options);
         if (record === null) {
-            await releaseClaimsOwnedBy(runtimeId, null, options);
+            await releaseClaimsOwnedBy(owner, null, options);
             return null;
         }
         const selected = await validateContextRecord(header, record, options.signal).catch(() => null);
         if (selected === null) {
-            await releaseClaimsOwnedBy(runtimeId, null, options);
+            await releaseClaimsOwnedBy(owner, null, options);
             return null;
         }
-        const status = await claimAvailability(selected, runtimeId, options);
+        const status = await claimAvailability(selected, owner, options);
         if (status !== "available" && status !== "current") {
-            await releaseClaimsOwnedBy(runtimeId, null, options);
+            await releaseClaimsOwnedBy(owner, null, options);
             return null;
         }
-        await writeClaim(header, selected, runtimeId, runtimeIdentity, options);
-        await releaseClaimsOwnedBy(runtimeId, selected.gitDir, options);
+        await writeClaim(header, selected, owner, runtimeIdentity, options);
+        await releaseClaimsOwnedBy(owner, selected.gitDir, options);
         return { cwd: selected.root, branch: requireBranch(selected) };
     });
 }
-/** Release only this exact runtime generation's cooperative editing claims. */
+/** Release every agent's cooperative editing claims held by this exact runtime generation. */
 export async function releaseSessionRepositoryRuntime(runtimeId, runtimeIdentity, options = {}) {
     assertRuntimeId(runtimeId);
     assertProcessIdentity(runtimeIdentity);
-    await withClaimLock(options, async () => {
-        const runtime = await readRuntimeRecord(runtimeId, options);
-        if (runtime === null || runtime.pid !== runtimeIdentity.pid || runtime.startIdentity !== runtimeIdentity.startIdentity)
+    await withClaimLock({ ...options, runtimeIdentity }, async () => {
+        const runtimes = (await readRuntimeRecordsOf(runtimeId, options))
+            .filter(({ record }) => record.pid === runtimeIdentity.pid && record.startIdentity === runtimeIdentity.startIdentity);
+        if (runtimes.length === 0)
             return;
-        await releaseClaimsOwnedBy(runtimeId, null, options);
-        await rm(runtimeRecordPath(runtimeId, options), { force: true });
+        await releaseRuntimeClaims(runtimeId, options);
+        for (const { path } of runtimes)
+            await rm(path, { force: true });
     });
 }
 /** Persist one explicit same-repository worktree association after atomically claiming it. */
@@ -69,27 +77,27 @@ export async function setSessionRepositoryContext(identity, worktreePath, option
     if (!samePath(startup.commonDir, selected.commonDir)) {
         throw contextError("associated worktree belongs to a different Git repository", "worktree-foreign-repository");
     }
-    const runtimeId = requireRuntimeId(options);
+    const owner = { runtimeId: requireRuntimeId(options), agentId: requireAgentId(options) };
     return await withClaimLock(options, async () => {
-        const runtime = await requireLiveRuntime(header, runtimeId, options);
-        const status = await claimAvailability(selected, runtimeId, options);
+        const runtime = await requireLiveRuntime(header, owner, options);
+        const status = await claimAvailability(selected, owner, options);
         if (status === "busy")
             throw contextError("worktree is active in another session", "worktree-active-in-another-session");
         if (status === "unverifiable")
             throw contextError("worktree ownership cannot be verified", "worktree-owner-unverifiable");
         const prior = await readContextRecord(header, options);
-        await writeClaim(header, selected, runtimeId, processIdentityOf(runtime), options);
+        await writeClaim(header, selected, owner, processIdentityOf(runtime), options);
         try {
             await writeContextRecord(header, startup, selected, options);
         }
         catch (error) {
             if (status !== "current")
-                await removeMatchingClaim(selected, runtimeId, options);
+                await removeMatchingClaim(selected, owner, options);
             throw error;
         }
-        await releaseClaimsOwnedBy(runtimeId, selected.gitDir, options);
+        await releaseClaimsOwnedBy(owner, selected.gitDir, options);
         if (prior !== null && !samePath(prior.worktreeGitDir, selected.gitDir)) {
-            await removeClaimByGitDir(prior.worktreeCommonDir, prior.worktreeGitDir, runtimeId, options);
+            await removeClaimByGitDir(prior.worktreeCommonDir, prior.worktreeGitDir, owner, options);
         }
         return { cwd: selected.root, branch: requireBranch(selected) };
     });
@@ -101,11 +109,11 @@ export async function clearSessionRepositoryContext(identity, options = {}) {
         await rm(contextRecordPath(header, options), { force: true });
         return;
     }
-    const runtimeId = requireRuntimeId(options);
+    const owner = { runtimeId: requireRuntimeId(options), agentId: requireAgentId(options) };
     await withClaimLock(options, async () => {
-        await requireLiveRuntime(header, runtimeId, options);
+        await requireLiveRuntime(header, owner, options);
         await rm(contextRecordPath(header, options), { force: true });
-        await releaseClaimsOwnedBy(runtimeId, null, options);
+        await releaseClaimsOwnedBy(owner, null, options);
     });
 }
 /** Read and revalidate a persisted association; malformed or stale state fails closed to absence. */
@@ -126,8 +134,8 @@ export async function readSessionRepositoryContext(identity, options = {}) {
 /** List same-repository worktrees without acquiring, releasing, or repairing a claim. */
 export async function listSessionRepositoryWorktrees(identity, options = {}) {
     const header = await readSessionHeader(identity);
-    const runtimeId = requireRuntimeId(options);
-    await requireLiveRuntime(header, runtimeId, options);
+    const owner = { runtimeId: requireRuntimeId(options), agentId: requireAgentId(options) };
+    await requireLiveRuntime(header, owner, options);
     const startup = await readGitWorktreeIdentity(header.cwd, false, options.signal);
     const worktrees = await listGitWorktrees(startup.root, startup.commonDir, options.signal);
     if (worktrees.length > MAX_WORKTREES)
@@ -136,19 +144,17 @@ export async function listSessionRepositoryWorktrees(identity, options = {}) {
     const entries = [];
     for (const selected of worktrees) {
         if (selected.branch === null) {
-            entries.push({ cwd: selected.root, branch: "(detached)", status: "unverifiable" });
+            entries.push({ cwd: selected.root, branch: "(detached)", status: "unverifiable", agentId: null });
             continue;
         }
-        entries.push({
-            cwd: selected.root,
-            branch: selected.branch,
-            status: contended ? "unverifiable" : await claimAvailability(selected, runtimeId, options),
-        });
+        const status = contended ? "unverifiable" : await claimAvailability(selected, owner, options);
+        const claim = status === "current" || status === "busy" ? await readClaim(selected, options) : null;
+        entries.push({ cwd: selected.root, branch: selected.branch, status, agentId: claim?.agentId ?? null });
     }
     return entries.sort((left, right) => pathKey(left.cwd).localeCompare(pathKey(right.cwd)));
 }
-async function requireLiveRuntime(header, runtimeId, options) {
-    const runtime = await readRuntimeRecord(runtimeId, options);
+async function requireLiveRuntime(header, owner, options) {
+    const runtime = await readRuntimeRecord(owner, options);
     if (runtime === null || runtime.sessionId !== header.id || runtime.sessionFile !== header.file) {
         throw contextError("active session runtime is unavailable", "session-runtime-unavailable");
     }
@@ -165,14 +171,15 @@ async function requireLiveRuntime(header, runtimeId, options) {
     }
     return runtime;
 }
-async function claimAvailability(selected, runtimeId, options) {
+async function claimAvailability(selected, owner, options) {
     const claim = await readClaim(selected, options);
     if (claim === undefined)
         return "available";
     if (claim === null || !claimMatchesWorktree(claim, selected))
         return "unverifiable";
-    if (claim.runtimeId === runtimeId)
+    if (ownedBy(claim, owner))
         return "current";
+    // Invariant: a sibling agent of this runtime is live by construction, so its claim reads busy below.
     const inspection = requireInspector(options);
     let observed;
     try {
@@ -184,8 +191,8 @@ async function claimAvailability(selected, runtimeId, options) {
     const live = observed !== null && observed.pid === claim.pid && observed.startIdentity === claim.startIdentity;
     return live ? "busy" : "available";
 }
-async function writeRuntimeRecord(header, runtimeId, runtimeIdentity, options) {
-    const existing = await readRuntimeRecord(runtimeId, options);
+async function writeRuntimeRecord(header, runtimeId, agentId, runtimeIdentity, options) {
+    const existing = await readRuntimeRecord({ runtimeId, agentId }, options);
     if (existing !== null && (existing.pid !== runtimeIdentity.pid || existing.startIdentity !== runtimeIdentity.startIdentity)) {
         const inspection = requireInspector(options);
         let observed;
@@ -201,14 +208,16 @@ async function writeRuntimeRecord(header, runtimeId, runtimeIdentity, options) {
     }
     const record = {
         schema: RUNTIME_SCHEMA,
+        formatVersion: RECORD_FORMAT_VERSION,
         runtimeId,
+        agentId,
         sessionId: header.id,
         sessionFile: header.file,
         pid: runtimeIdentity.pid,
         startIdentity: runtimeIdentity.startIdentity,
         updatedAt: new Date().toISOString(),
     };
-    await atomicWrite(runtimeRecordPath(runtimeId, options), record);
+    await atomicWrite(runtimeRecordPath({ runtimeId, agentId }, options), record);
 }
 async function writeContextRecord(header, startup, selected, options) {
     const record = {
@@ -224,10 +233,12 @@ async function writeContextRecord(header, startup, selected, options) {
     };
     await atomicWrite(contextRecordPath(header, options), record);
 }
-async function writeClaim(header, selected, runtimeId, runtimeIdentity, options) {
+async function writeClaim(header, selected, owner, runtimeIdentity, options) {
     const claim = {
         schema: CLAIM_SCHEMA,
-        runtimeId,
+        formatVersion: RECORD_FORMAT_VERSION,
+        runtimeId: owner.runtimeId,
+        agentId: owner.agentId,
         sessionId: header.id,
         worktreeRoot: selected.root,
         worktreeCommonDir: selected.commonDir,
@@ -241,8 +252,34 @@ async function writeClaim(header, selected, runtimeId, runtimeIdentity, options)
 async function readContextRecord(header, options) {
     return await readJsonRecord(contextRecordPath(header, options), isContextRecord);
 }
-async function readRuntimeRecord(runtimeId, options) {
-    return await readJsonRecord(runtimeRecordPath(runtimeId, options), isRuntimeRecord);
+async function readRuntimeRecord(owner, options) {
+    const record = await readRuntimeRecordAt(runtimeRecordPath(owner, options));
+    return record !== null && ownedBy(record, owner) ? record : null;
+}
+async function readRuntimeRecordAt(path) {
+    const stored = await readJsonRecord(path, isStoredRuntimeRecord);
+    return stored === null ? null : { ...stored, formatVersion: RECORD_FORMAT_VERSION, agentId: stored.agentId ?? PRIMARY_SESSION_AGENT_ID };
+}
+/** Every agent's runtime record of one runtime, with the file that holds it. */
+async function readRuntimeRecordsOf(runtimeId, options) {
+    const directory = runtimesDirectory(options);
+    const names = await readdir(directory).catch(() => []);
+    if (names.length > MAX_WORKTREES * 4)
+        throw contextError("session runtime store exceeds its bounded limit", "session-runtime-limit");
+    const records = [];
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const path = join(directory, name);
+        const record = await readRuntimeRecordAt(path);
+        if (record?.runtimeId === runtimeId)
+            records.push({ path, record });
+    }
+    return records;
+}
+async function readClaimRecordAt(path) {
+    const stored = await readJsonRecord(path, isStoredClaimRecord);
+    return stored === null ? null : normalizeClaim(stored);
 }
 /** Undefined means absent; null means present but invalid. */
 async function readClaim(selected, options) {
@@ -252,7 +289,7 @@ async function readClaim(selected, options) {
         if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size === 0 || metadata.size > MAX_RECORD_BYTES)
             return null;
         const value = JSON.parse((await readFile(path, { signal: options.signal })).toString("utf8"));
-        return isClaimRecord(value) ? value : null;
+        return isStoredClaimRecord(value) ? normalizeClaim(value) : null;
     }
     catch (error) {
         if (error instanceof Error && "code" in error && error.code === "ENOENT")
@@ -274,7 +311,15 @@ async function validateContextRecord(header, record, signal) {
         throw new Error("associated worktree identity changed");
     return selected;
 }
-async function releaseClaimsOwnedBy(runtimeId, keepGitDir, options) {
+/** Release one agent's claims except the one it keeps; sibling agents of the runtime are untouched. */
+async function releaseClaimsOwnedBy(owner, keepGitDir, options) {
+    await releaseClaimsWhere(claim => ownedBy(claim, owner) && (keepGitDir === null || !samePath(claim.worktreeGitDir, keepGitDir)), options);
+}
+/** Release every agent's claims of one runtime; only process exit does this. */
+async function releaseRuntimeClaims(runtimeId, options) {
+    await releaseClaimsWhere(claim => claim.runtimeId === runtimeId, options);
+}
+async function releaseClaimsWhere(release, options) {
     const directory = claimsDirectory(options);
     const names = await readdir(directory).catch(() => []);
     if (names.length > MAX_WORKTREES * 4)
@@ -283,19 +328,18 @@ async function releaseClaimsOwnedBy(runtimeId, keepGitDir, options) {
         if (!name.endsWith(".json"))
             continue;
         const path = join(directory, name);
-        const claim = await readJsonRecord(path, isClaimRecord);
-        if (claim?.runtimeId === runtimeId && (keepGitDir === null || !samePath(claim.worktreeGitDir, keepGitDir))) {
+        const claim = await readClaimRecordAt(path);
+        if (claim !== null && release(claim))
             await rm(path, { force: true });
-        }
     }
 }
-async function removeMatchingClaim(selected, runtimeId, options) {
-    await removeClaimByGitDir(selected.commonDir, selected.gitDir, runtimeId, options);
+async function removeMatchingClaim(selected, owner, options) {
+    await removeClaimByGitDir(selected.commonDir, selected.gitDir, owner, options);
 }
-async function removeClaimByGitDir(commonDir, gitDir, runtimeId, options) {
+async function removeClaimByGitDir(commonDir, gitDir, owner, options) {
     const path = claimRecordPath(commonDir, gitDir, options);
-    const claim = await readJsonRecord(path, isClaimRecord);
-    if (claim?.runtimeId === runtimeId)
+    const claim = await readClaimRecordAt(path);
+    if (claim !== null && ownedBy(claim, owner))
         await rm(path, { force: true });
 }
 async function readSessionHeader(identity) {
@@ -401,21 +445,30 @@ async function withClaimLock(options, operation) {
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const path = join(directory, "mutation.lock");
     const deadline = Date.now() + (options.lockTimeoutMs ?? LOCK_TIMEOUT_MS);
+    const holder = await lockHolderIdentity(options);
     let handle;
-    while (handle === undefined) {
+    for (let attempt = 0; handle === undefined; attempt++) {
         try {
             handle = await open(path, "wx", 0o600);
         }
         catch (error) {
             if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
                 throw error;
+            if (attempt === 0 && await evictDeadLockHolder(path, options))
+                continue;
             if (Date.now() >= deadline)
                 throw contextError("worktree claim mutation is busy", "worktree-claim-busy");
             await new Promise(resolvePromise => setTimeout(resolvePromise, LOCK_RETRY_MS));
         }
     }
     try {
-        await handle.writeFile(`${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`);
+        const record = {
+            pid: process.pid,
+            ...(holder === null ? {} : { startIdentity: holder.startIdentity }),
+            acquiredAt: new Date().toISOString(),
+            nonce: randomUUID(),
+        };
+        await handle.writeFile(`${JSON.stringify(record)}\n`);
         return await operation();
     }
     finally {
@@ -423,6 +476,59 @@ async function withClaimLock(options, operation) {
         await rm(path, { force: true }).catch(() => undefined);
     }
 }
+const lockHolderIdentities = new WeakMap();
+/** This process's identity as recorded in the lock; null leaves the lock unevictable, never wrongly evictable. */
+async function lockHolderIdentity(options) {
+    if (options.runtimeIdentity?.pid === process.pid)
+        return options.runtimeIdentity;
+    const inspection = options.inspectProcess;
+    if (inspection === undefined)
+        return null;
+    let identity = lockHolderIdentities.get(inspection);
+    if (identity === undefined) {
+        identity = inspection(process.pid)
+            .then(observed => observed !== null && observed.pid === process.pid ? observed : null)
+            .catch(() => null);
+        lockHolderIdentities.set(inspection, identity);
+    }
+    return await identity;
+}
+/**
+ * Evict the mutation lock only when its recorded holder is proven dead: the pid is gone or now names a process
+ * with another start identity. A lock without a holder identity, or a holder that cannot be inspected, is kept.
+ */
+async function evictDeadLockHolder(path, options) {
+    const inspection = options.inspectProcess;
+    if (inspection === undefined)
+        return false;
+    const holder = await readJsonRecord(path, isMutationLockRecord);
+    if (holder === null || holder.startIdentity === undefined || holder.pid === process.pid)
+        return false;
+    let observed;
+    try {
+        observed = await inspection(holder.pid);
+    }
+    catch {
+        return false;
+    }
+    if (observed !== null && observed.pid === holder.pid && observed.startIdentity === holder.startIdentity)
+        return false;
+    const evicted = `${path}.${randomUUID()}.evicted`;
+    try {
+        await rename(path, evicted);
+    }
+    catch {
+        return false;
+    }
+    const moved = await readJsonRecord(evicted, isMutationLockRecord);
+    if (moved?.nonce !== holder.nonce) {
+        // Concurrency: another waiter evicted first and a live holder took the lock since; hand it back untouched.
+        await rename(evicted, path).catch(() => undefined);
+        return false;
+    }
+    await rm(evicted, { force: true });
+    return true;
+}
 async function atomicWrite(path, value) {
     const directory = dirname(path);
     await mkdir(directory, { recursive: true, mode: 0o700 });
@@ -455,8 +561,13 @@ function contextRecordPath(header, options) {
 function claimStoreRoot(options) {
     return join(options.dataDir ?? resolveProductPaths().dataDir, PRODUCT_IDENTITY.state.sessionWorktreeClaimDirectory);
 }
-function runtimeRecordPath(runtimeId, options) {
-    return join(claimStoreRoot(options), "runtimes", `${digest(runtimeId)}.json`);
+function runtimesDirectory(options) {
+    return join(claimStoreRoot(options), "runtimes");
+}
+// Compatibility: the primary agent keeps the single-agent file name, so a version-1 runtime record is its record.
+function runtimeRecordPath(owner, options) {
+    const key = owner.agentId === PRIMARY_SESSION_AGENT_ID ? owner.runtimeId : `${owner.runtimeId}\0${owner.agentId}`;
+    return join(runtimesDirectory(options), `${digest(key)}.json`);
 }
 function claimsDirectory(options) {
     return join(claimStoreRoot(options), "worktrees");
@@ -472,6 +583,15 @@ function requireRuntimeId(options) {
     assertRuntimeId(runtimeId);
     return runtimeId;
 }
+function requireAgentId(options) {
+    const agentId = options.agentId ?? PRIMARY_SESSION_AGENT_ID;
+    if (!validSessionId(agentId))
+        throw contextError("session agent identity is invalid", "session-agent-invalid");
+    return agentId;
+}
+function ownedBy(record, owner) {
+    return record.runtimeId === owner.runtimeId && record.agentId === owner.agentId;
+}
 function requireInspector(options) {
     if (options.inspectProcess === undefined)
         throw contextError("native process identity inspection is unavailable", "process-inspection-unavailable");
@@ -520,19 +640,34 @@ function isContextRecord(value) {
         && validPath(value.worktreeRoot) && validPath(value.worktreeCommonDir) && validPath(value.worktreeGitDir)
         && typeof value.updatedAt === "string";
 }
-function isRuntimeRecord(value) {
-    return isRecord(value) && value.schema === RUNTIME_SCHEMA && validSessionId(value.runtimeId) && validSessionId(value.sessionId)
-        && validPath(value.sessionFile) && Number.isSafeInteger(value.pid) && Number(value.pid) > 0
+function isStoredRuntimeRecord(value) {
+    return isRecord(value) && value.schema === RUNTIME_SCHEMA && validRecordVersion(value) && validSessionId(value.runtimeId)
+        && validSessionId(value.sessionId) && validPath(value.sessionFile) && Number.isSafeInteger(value.pid) && Number(value.pid) > 0
         && typeof value.startIdentity === "string" && value.startIdentity.length > 0 && value.startIdentity.length <= 512
         && !value.startIdentity.includes("\0") && typeof value.updatedAt === "string";
 }
-function isClaimRecord(value) {
-    return isRecord(value) && value.schema === CLAIM_SCHEMA && validSessionId(value.runtimeId) && validSessionId(value.sessionId)
+function isStoredClaimRecord(value) {
+    return isRecord(value) && value.schema === CLAIM_SCHEMA && validRecordVersion(value) && validSessionId(value.runtimeId)
+        && validSessionId(value.sessionId)
         && validPath(value.worktreeRoot) && validPath(value.worktreeCommonDir) && validPath(value.worktreeGitDir)
         && Number.isSafeInteger(value.pid) && Number(value.pid) > 0
         && typeof value.startIdentity === "string" && value.startIdentity.length > 0 && value.startIdentity.length <= 512
         && !value.startIdentity.includes("\0") && typeof value.updatedAt === "string";
 }
+function isMutationLockRecord(value) {
+    return isRecord(value) && Number.isSafeInteger(value.pid) && Number(value.pid) > 0
+        && (value.startIdentity === undefined || (typeof value.startIdentity === "string" && value.startIdentity.length > 0
+            && value.startIdentity.length <= 512 && !value.startIdentity.includes("\0")))
+        && typeof value.acquiredAt === "string" && typeof value.nonce === "string" && value.nonce.length > 0;
+}
+function validRecordVersion(value) {
+    if (value.formatVersion === undefined)
+        return value.agentId === undefined;
+    return value.formatVersion === RECORD_FORMAT_VERSION && validSessionId(value.agentId);
+}
+function normalizeClaim(stored) {
+    return { ...stored, formatVersion: RECORD_FORMAT_VERSION, agentId: stored.agentId ?? PRIMARY_SESSION_AGENT_ID };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }