@llblab/pi-actors 0.38.1 → 0.40.0

package/dist/lib/recipes-usage.js

@@ -5,7 +5,8 @@
  */
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
-import { writeJsonAtomic } from "./file-state.js";
+import { basename, dirname, join } from "node:path";
+import { withFileMutationLock, writeJsonAtomic } from "./file-state.js";
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -28,25 +29,38 @@ function getRecipeFingerprint(raw) {
     const { usage: _usage, ...content } = raw;
     return createHash("sha256").update(stableStringify(content)).digest("hex");
 }
+export function getRecipeUsagePath(path) {
+    return join(dirname(path), ".usage", `${basename(path)}.json`);
+}
+export function readRecipeUsage(path) {
+    try {
+        const value = JSON.parse(readFileSync(getRecipeUsagePath(path), "utf8"));
+        return isRecord(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function launchCounterKey(kind) {
     return `${kind}_calls`;
 }
 export function recordRecipeLaunch(path, now = new Date(), kind = "direct") {
     if (!existsSync(path))
         return false;
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        if (!isRecord(raw))
-            return false;
-        const usage = isRecord(raw.usage) ? raw.usage : {};
-        const fingerprint = getRecipeFingerprint(raw);
-        const changed = typeof usage.fingerprint === "string" &&
-            usage.fingerprint !== fingerprint;
-        const nowIso = now.toISOString();
-        const counterKey = launchCounterKey(kind);
-        writeJsonAtomic(path, {
-            ...raw,
-            usage: {
+    const usagePath = getRecipeUsagePath(path);
+    return withFileMutationLock(usagePath, () => {
+        try {
+            const raw = JSON.parse(readFileSync(path, "utf8"));
+            if (!isRecord(raw))
+                return false;
+            const storedUsage = readRecipeUsage(path);
+            const usage = storedUsage ?? (isRecord(raw.usage) ? raw.usage : {});
+            const fingerprint = getRecipeFingerprint(raw);
+            const changed = typeof usage.fingerprint === "string" &&
+                usage.fingerprint !== fingerprint;
+            const nowIso = now.toISOString();
+            const counterKey = launchCounterKey(kind);
+            writeJsonAtomic(usagePath, {
                 ...usage,
                 calls: (changed ? 0 : normalizeCalls(usage.calls)) + 1,
                 [counterKey]: (changed ? 0 : normalizeCalls(usage[counterKey])) + 1,
@@ -59,11 +73,11 @@ export function recordRecipeLaunch(path, now = new Date(), kind = "direct") {
                         reset_reason: "recipe content fingerprint changed",
                     }
                     : {}),
-            },
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
 }

package/dist/lib/registry.d.ts

@@ -9,7 +9,6 @@ export interface RegisterToolInput {
     name?: string;
     description?: string;
     async?: boolean;
-    state_dir?: string;
     template?: CommandTemplates.CommandTemplateValue | null;
     draft?: string;
     args?: string;
@@ -24,7 +23,6 @@ export interface RegisterToolResultDetails {
     draft?: string;
     promoted?: boolean;
     recipeName?: string;
-    state_dir?: string;
     template?: CommandTemplates.CommandTemplateValue;
     templateWarnings?: string[];
     tool: string;

package/dist/lib/registry.js

@@ -3,11 +3,12 @@
  * Zones: registry mutations, persistence, runtime activation
  * Owns register/update/delete validation, persistence, runtime side effects, and result payloads
  */
-import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import * as CommandTemplates from "./command-templates.js";
+import * as Config from "./config.js";
 import * as ExecutionOutput from "./execution-output.js";
-import { writeJsonAtomic } from "./file-state.js";
+import { withFileMutationLock, writeJsonAtomic } from "./file-state.js";
 import * as Identity from "./identity.js";
 import * as Paths from "./paths.js";
 import * as RecipesReferences from "./recipes-references.js";
@@ -94,7 +95,6 @@ function persistToolRecipe(deps, cfg) {
     writeJsonAtomic(path, {
         description: cfg.description,
         ...(cfg.recipe?.async !== undefined ? { async: cfg.recipe.async } : {}),
-        ...(cfg.recipe?.state_dir ? { state_dir: cfg.recipe.state_dir } : {}),
         ...(cfg.storedArgs ? { args: cfg.storedArgs } : {}),
         ...(cfg.storedDefaults ? { defaults: cfg.storedDefaults } : {}),
         ...(cfg.recipe?.values ? { values: cfg.recipe.values } : {}),
@@ -125,6 +125,23 @@ function deleteTool(name, ctx, deps) {
         details: { config: recipePath, tool: name },
     };
 }
+function readAuthoritativeStoredTool(deps, name) {
+    const path = getToolRecipePath(deps, name);
+    if (!existsSync(path))
+        return { exists: false };
+    try {
+        const normalized = Config.normalizeStoredTool(name, JSON.parse(readFileSync(path, "utf8")), deps.reservedToolNames);
+        if (!normalized.cfg)
+            return { exists: true };
+        return {
+            exists: true,
+            tool: { ...normalized.cfg, sourcePath: path },
+        };
+    }
+    catch {
+        return { exists: true };
+    }
+}
 function getInputTemplate(value) {
     if (typeof value === "string")
         return value.trim();
@@ -167,9 +184,6 @@ function buildConfig(name, input, existing) {
         ? {
             name: inputRecipe,
             ...(typeof input.async === "boolean" ? { async: input.async } : {}),
-            ...(typeof input.state_dir === "string" && input.state_dir.trim()
-                ? { state_dir: input.state_dir.trim() }
-                : {}),
             template: finalTemplate,
             ...(input.values && typeof input.values === "object"
                 ? { values: input.values }
@@ -219,7 +233,7 @@ function buildConfig(name, input, existing) {
         ...(storedDefaults !== undefined ? { storedDefaults } : {}),
     };
 }
-export async function executeRegisterTool(params, ctx, deps) {
+function executeRegisterToolUnlocked(params, ctx, deps) {
     const input = params;
     if (!input.name)
         return listTools(deps);
@@ -237,11 +251,12 @@ export async function executeRegisterTool(params, ctx, deps) {
     if (templateProvided && (template === null || template === ""))
         return deleteTool(name, ctx, deps);
     const tools = deps.getTools();
-    const existing = tools.get(name);
+    const authoritative = readAuthoritativeStoredTool(deps, name);
+    const existing = authoritative.tool ?? tools.get(name);
     const blocker = deps.getToolNameBlocker(name);
     if (blocker)
         throw new Error(ExecutionOutput.formatToolText(blocker));
-    if (existing && !input.update) {
+    if ((authoritative.exists || existing) && !input.update) {
         throw new Error(ExecutionOutput.formatToolText(`Tool "${name}" already registered. Use update=true to overwrite.`));
     }
     if (template === undefined && !existing) {
@@ -275,10 +290,18 @@ export async function executeRegisterTool(params, ctx, deps) {
             defaults: cfg.defaults,
             ...(cfg.recipe?.async !== undefined ? { async: cfg.recipe.async } : {}),
             ...(cfg.recipe?.name ? { recipeName: cfg.recipe.name } : {}),
-            ...(cfg.recipe?.state_dir ? { state_dir: cfg.recipe.state_dir } : {}),
             ...(cfg.template ? { template: cfg.template } : {}),
             ...(templateWarnings.length > 0 ? { templateWarnings } : {}),
             tool: name,
         },
     };
 }
+export async function executeRegisterTool(params, ctx, deps) {
+    const input = params;
+    if (!input.name)
+        return executeRegisterToolUnlocked(params, ctx, deps);
+    const name = Identity.normalizeToolName(input.name);
+    if (!name)
+        return executeRegisterToolUnlocked(params, ctx, deps);
+    return withFileMutationLock(getToolRecipePath(deps, name), () => executeRegisterToolUnlocked(params, ctx, deps));
+}

package/dist/lib/runs-ownership.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Async run state-directory ownership.
+ * Owns the marker proof required before launch and destructive retention.
+ */
+export declare const RUN_STATE_OWNERSHIP_FILE = ".pi-actors-run-state.json";
+export declare function claimRunStateDirectory(stateDir: string, run: string): string;
+export declare function assertOwnedRunStateDirectory(stateDir: string, run: string): string;

package/dist/lib/runs-ownership.js

@@ -0,0 +1,82 @@
+/**
+ * Async run state-directory ownership.
+ * Owns the marker proof required before launch and destructive retention.
+ */
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join, resolve } from "node:path";
+import { writeJsonAtomic } from "./file-state.js";
+export const RUN_STATE_OWNERSHIP_FILE = ".pi-actors-run-state.json";
+function markerPath(stateDir) {
+    return join(stateDir, RUN_STATE_OWNERSHIP_FILE);
+}
+function comparablePath(path) {
+    const resolved = resolve(path);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function assertCanonicalDirectory(stateDir) {
+    const resolved = resolve(stateDir);
+    if (lstatSync(resolved).isSymbolicLink()) {
+        throw new Error(`Run state directory cannot be a symlink: ${resolved}`);
+    }
+    const canonical = realpathSync(resolved);
+    if (comparablePath(canonical) !== comparablePath(resolved)) {
+        throw new Error(`Run state directory has an ambiguous symlink alias: ${resolved}`);
+    }
+    return resolved;
+}
+function readMarker(stateDir) {
+    try {
+        const value = JSON.parse(readFileSync(markerPath(stateDir), "utf8"));
+        if (value.version !== 1 ||
+            typeof value.run !== "string" ||
+            typeof value.state_dir !== "string" ||
+            typeof value.ownership_token !== "string" ||
+            !value.ownership_token) {
+            return undefined;
+        }
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertMarkerMatches(marker, stateDir, run) {
+    if (!marker) {
+        throw new Error(`Run state ownership marker is missing or invalid: ${stateDir}`);
+    }
+    if (marker.state_dir !== stateDir || marker.run !== run) {
+        throw new Error(`Run state ownership marker does not match run ${run}: ${stateDir}`);
+    }
+    return marker;
+}
+export function claimRunStateDirectory(stateDir, run) {
+    const resolved = resolve(stateDir);
+    if (existsSync(resolved) && lstatSync(resolved).isSymbolicLink()) {
+        throw new Error(`Run state directory cannot be a symlink: ${resolved}`);
+    }
+    mkdirSync(resolved, { recursive: true });
+    const canonical = assertCanonicalDirectory(resolved);
+    const existing = readMarker(canonical);
+    if (existing) {
+        assertMarkerMatches(existing, canonical, run);
+        return canonical;
+    }
+    const existingEntries = readdirSync(canonical).filter((entry) => entry !== ".start.lock");
+    if (existingEntries.length > 0) {
+        throw new Error(`Refusing to claim existing non-run directory: ${canonical}`);
+    }
+    writeJsonAtomic(markerPath(canonical), {
+        created_at: new Date().toISOString(),
+        ownership_token: randomUUID(),
+        run,
+        state_dir: canonical,
+        version: 1,
+    });
+    return canonical;
+}
+export function assertOwnedRunStateDirectory(stateDir, run) {
+    const canonical = assertCanonicalDirectory(stateDir);
+    assertMarkerMatches(readMarker(canonical), canonical, run);
+    return canonical;
+}

package/dist/lib/runs-process.d.ts

@@ -1,7 +1,22 @@
 /**
  * Async run process identity helpers.
- * Owns liveness checks and Linux runner identity matching for run-owned processes.
+ * Owns cross-platform liveness and stable runner process identity proofs.
  */
+export interface RunProcessIdentity {
+    command: string;
+    cwd?: string;
+    platform: NodeJS.Platform;
+    start_time: string;
+}
+export type RunProcessIdentityStatus = "valid" | "dead_pid" | "owner_mismatch" | "unsupported_proof";
+export interface RunProcessIdentityResult {
+    status: RunProcessIdentityStatus;
+    valid: boolean;
+}
+type ProcessIdentityReader = (pid: number, runtimePlatform: NodeJS.Platform) => RunProcessIdentity | undefined;
 export declare function isAlive(pid: number): boolean;
-export declare function pidMatchesRun(pid: number, cwd: string, stateDir: string, runnerPath: string): boolean;
+export declare function readProcessIdentity(pid: number, runtimePlatform?: NodeJS.Platform): RunProcessIdentity | undefined;
+export declare function captureRunProcessIdentity(pid: number, cwd: string, stateDir: string, runnerPath: string, runtimePlatform?: NodeJS.Platform, reader?: ProcessIdentityReader): RunProcessIdentity | undefined;
+export declare function verifyRunProcessIdentity(pid: number, expected: RunProcessIdentity | undefined, runtimePlatform?: NodeJS.Platform, reader?: ProcessIdentityReader, alive?: (pid: number) => boolean): RunProcessIdentityResult;
 export declare function isWithinRunnerIdentityGrace(meta: Record<string, unknown>, graceMs: number): boolean;
+export {};

package/dist/lib/runs-process.js

@@ -1,8 +1,9 @@
 /**
  * Async run process identity helpers.
- * Owns liveness checks and Linux runner identity matching for run-owned processes.
+ * Owns cross-platform liveness and stable runner process identity proofs.
  */
-import { existsSync, readFileSync, readlinkSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
 import { platform } from "node:os";
 import { resolve } from "node:path";
 export function isAlive(pid) {
@@ -14,19 +15,106 @@ export function isAlive(pid) {
         return false;
     }
 }
-export function pidMatchesRun(pid, cwd, stateDir, runnerPath) {
-    if (platform() !== "linux" || !existsSync(`/proc/${pid}`))
-        return isAlive(pid);
+function readLinuxIdentity(pid) {
+    if (!existsSync(`/proc/${pid}`))
+        return undefined;
     try {
-        const procCwd = readlinkSync(`/proc/${pid}/cwd`);
-        const cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf8");
-        return (procCwd === resolve(cwd) &&
-            cmdline.includes(runnerPath) &&
-            cmdline.includes(stateDir));
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const close = stat.lastIndexOf(")");
+        const fields = stat.slice(close + 2).trim().split(/\s+/);
+        const startTime = fields[19];
+        if (!startTime)
+            return undefined;
+        return {
+            command: readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\0", " ").trim(),
+            cwd: readlinkSync(`/proc/${pid}/cwd`),
+            platform: "linux",
+            start_time: startTime,
+        };
     }
     catch {
-        return false;
+        return undefined;
+    }
+}
+function readDarwinIdentity(pid) {
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "lstart=", "-o", "command="], { encoding: "utf8" });
+    if (result.status !== 0)
+        return undefined;
+    const match = result.stdout.trim().match(/^(.{24})\s+(.+)$/s);
+    if (!match)
+        return undefined;
+    return {
+        command: match[2].trim(),
+        platform: "darwin",
+        start_time: match[1].trim(),
+    };
+}
+function readWindowsIdentity(pid) {
+    const command = [
+        `$p = Get-CimInstance Win32_Process -Filter \"ProcessId = ${pid}\";`,
+        "if ($null -eq $p) { exit 3 };",
+        "$p | Select-Object CreationDate,ExecutablePath,CommandLine | ConvertTo-Json -Compress",
+    ].join(" ");
+    const result = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0)
+        return undefined;
+    try {
+        const value = JSON.parse(result.stdout);
+        if (typeof value.CreationDate !== "string")
+            return undefined;
+        const executable = typeof value.ExecutablePath === "string" ? value.ExecutablePath : "";
+        const commandLine = typeof value.CommandLine === "string" ? value.CommandLine : "";
+        return {
+            command: `${executable}\n${commandLine}`.trim(),
+            platform: "win32",
+            start_time: value.CreationDate,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readProcessIdentity(pid, runtimePlatform = platform()) {
+    if (runtimePlatform === "linux")
+        return readLinuxIdentity(pid);
+    if (runtimePlatform === "darwin")
+        return readDarwinIdentity(pid);
+    if (runtimePlatform === "win32")
+        return readWindowsIdentity(pid);
+    return undefined;
+}
+export function captureRunProcessIdentity(pid, cwd, stateDir, runnerPath, runtimePlatform = platform(), reader = readProcessIdentity) {
+    const identity = reader(pid, runtimePlatform);
+    if (!identity)
+        return undefined;
+    if (!identity.command.includes(runnerPath) || !identity.command.includes(stateDir)) {
+        return undefined;
+    }
+    const resolvedCwd = resolve(cwd);
+    const canonicalCwd = existsSync(resolvedCwd)
+        ? realpathSync.native(resolvedCwd)
+        : resolvedCwd;
+    const expectedCwd = runtimePlatform === "win32" ? canonicalCwd.toLowerCase() : canonicalCwd;
+    const actualCwd = runtimePlatform === "win32" && identity.cwd
+        ? identity.cwd.toLowerCase()
+        : identity.cwd;
+    if (actualCwd && actualCwd !== expectedCwd)
+        return undefined;
+    return identity;
+}
+export function verifyRunProcessIdentity(pid, expected, runtimePlatform = platform(), reader = readProcessIdentity, alive = isAlive) {
+    if (!alive(pid))
+        return { status: "dead_pid", valid: false };
+    if (!expected || expected.platform !== runtimePlatform) {
+        return { status: "unsupported_proof", valid: false };
     }
+    const current = reader(pid, runtimePlatform);
+    if (!current)
+        return { status: "unsupported_proof", valid: false };
+    const valid = current.start_time === expected.start_time &&
+        current.command === expected.command &&
+        current.cwd === expected.cwd;
+    return { status: valid ? "valid" : "owner_mismatch", valid };
 }
 export function isWithinRunnerIdentityGrace(meta, graceMs) {
     const createdAt = typeof meta.createdAt === "string" ? Date.parse(meta.createdAt) : NaN;

package/dist/lib/runs-retention.d.ts

@@ -2,7 +2,10 @@
  * Async run retention operations.
  * Owns terminal-run archive and prune filesystem behavior.
  */
+import { cpSync } from "node:fs";
 export declare function archiveTerminalRun(status: Record<string, unknown>): Record<string, unknown>;
 export declare function pruneTerminalRun(status: Record<string, unknown>, options?: {
     preserveArtifacts?: boolean;
+}, deps?: {
+    copyArtifact?: typeof cpSync;
 }): Record<string, unknown>;

package/dist/lib/runs-retention.js

@@ -2,11 +2,21 @@
  * Async run retention operations.
  * Owns terminal-run archive and prune filesystem behavior.
  */
+import { createHash } from "node:crypto";
 import { cpSync, mkdirSync, renameSync, rmSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { writeJsonAtomic } from "./file-state.js";
 import { resolveArtifactManifest, } from "./runs-artifacts.js";
 import { safeRunId } from "./runs-identity.js";
+import { assertOwnedRunStateDirectory } from "./runs-ownership.js";
+function retainedArtifactFilename(name, path) {
+    const readableName = name.replace(/[^A-Za-z0-9_.-]+/g, "_") || "artifact";
+    const identity = createHash("sha256")
+        .update(`${name}\0${path}`)
+        .digest("hex")
+        .slice(0, 8);
+    return `${readableName}-${identity}--${basename(path)}`;
+}
 function archivePathFor(run, stateDir) {
     const archiveRoot = join(dirname(stateDir), "archived");
     mkdirSync(archiveRoot, { recursive: true });
@@ -15,6 +25,7 @@ function archivePathFor(run, stateDir) {
 export function archiveTerminalRun(status) {
     const stateDir = String(status.state_dir);
     const run = String(status.run ?? basename(stateDir));
+    assertOwnedRunStateDirectory(stateDir, run);
     const archiveDir = archivePathFor(run, stateDir);
     renameSync(stateDir, archiveDir);
     mkdirSync(stateDir, { recursive: true });
@@ -29,9 +40,10 @@ export function archiveTerminalRun(status) {
     writeJsonAtomic(join(stateDir, "archive-tombstone.json"), tombstone);
     return tombstone;
 }
-export function pruneTerminalRun(status, options = {}) {
+export function pruneTerminalRun(status, options = {}, deps = {}) {
     const stateDir = String(status.state_dir);
     const run = String(status.run ?? basename(stateDir));
+    assertOwnedRunStateDirectory(stateDir, run);
     const manifest = resolveArtifactManifest(status.artifacts);
     const preserved = {};
     if (options.preserveArtifacts && manifest) {
@@ -40,8 +52,11 @@ export function pruneTerminalRun(status, options = {}) {
         for (const [name, artifact] of Object.entries(manifest)) {
             if (!artifact.exists)
                 continue;
-            const target = join(preserveRoot, basename(artifact.path));
-            cpSync(artifact.path, target, { force: true });
+            const target = join(preserveRoot, retainedArtifactFilename(name, artifact.path));
+            (deps.copyArtifact ?? cpSync)(artifact.path, target, {
+                force: true,
+                preserveTimestamps: true,
+            });
             preserved[name] = target;
         }
     }

package/dist/lib/runs-start.d.ts

@@ -4,6 +4,6 @@
  * preparation before a new runner process is spawned.
  */
 export type RunJsonReader = (path: string) => Record<string, unknown> | undefined;
-export declare function assertNoActiveRunState(stateDir: string, readJson: RunJsonReader, runnerPath: string): void;
+export declare function assertNoActiveRunState(stateDir: string, readJson: RunJsonReader, _runnerPath: string): void;
 export declare function acquireStateStartLock(stateDir: string): () => void;
-export declare function prepareStateDirForStart(stateDir: string, readJson: RunJsonReader, runnerPath: string): void;
+export declare function prepareStateDirForStart(stateDir: string, readJson: RunJsonReader, _runnerPath: string): void;

package/dist/lib/runs-start.js

@@ -3,33 +3,64 @@
  * Owns active-run reuse checks, start lock acquisition, and safe state-dir
  * preparation before a new runner process is spawned.
  */
-import { mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
-import { isAlive, pidMatchesRun } from "./runs-process.js";
+import { isAlive, readProcessIdentity, verifyRunProcessIdentity, } from "./runs-process.js";
 const START_LOCK_MAX_AGE_MS = 5 * 60 * 1000;
-export function assertNoActiveRunState(stateDir, readJson, runnerPath) {
+export function assertNoActiveRunState(stateDir, readJson, _runnerPath) {
     const meta = readJson(join(stateDir, "run.json"));
     if (!meta)
         return;
     const pid = Number(meta.pid || 0);
     const cwd = String(meta.cwd ?? "");
-    if (!pid || !isAlive(pid) || !pidMatchesRun(pid, cwd, stateDir, runnerPath))
+    if (!pid || !isAlive(pid))
         return;
-    throw new Error(`Run state already has an active owned process: ${String(meta.run ?? stateDir)}. Stop it before reusing the same run_id or state_dir.`);
+    const identity = verifyRunProcessIdentity(pid, meta.process_identity);
+    if (identity.status === "owner_mismatch") {
+        throw new Error(`Run state process identity does not match the live pid: ${String(meta.run ?? stateDir)}. Refusing to reuse the state directory while pid ${pid} is alive.`);
+    }
+    if (identity.status === "unsupported_proof") {
+        throw new Error(`Run state process identity proof is unavailable: ${String(meta.run ?? stateDir)}. Refusing to reuse the state directory while pid ${pid} is alive.`);
+    }
+    if (identity.valid) {
+        throw new Error(`Run state already has an active owned process: ${String(meta.run ?? stateDir)}. Stop it before reusing the same run_id or state_dir.`);
+    }
+}
+function writeStartLockOwner(lockDir, recovered = false) {
+    const processIdentity = readProcessIdentity(process.pid);
+    writeFileSync(join(lockDir, "owner.json"), `${JSON.stringify({
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+        ...(processIdentity ? { process_identity: processIdentity } : {}),
+        ...(recovered ? { recovered: true } : {}),
+    })}\n`, "utf8");
+}
+function isStartLockOwnerProvenDead(lockDir) {
+    try {
+        const owner = JSON.parse(readFileSync(join(lockDir, "owner.json"), "utf8"));
+        const pid = Number(owner.pid || 0);
+        if (!pid)
+            return false;
+        return verifyRunProcessIdentity(pid, owner.process_identity).status === "dead_pid";
+    }
+    catch {
+        return false;
+    }
 }
 export function acquireStateStartLock(stateDir) {
     const lockDir = join(stateDir, ".start.lock");
     try {
         mkdirSync(lockDir);
-        writeFileSync(join(lockDir, "owner.json"), `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`, "utf8");
+        writeStartLockOwner(lockDir);
     }
     catch (error) {
         try {
             const stat = statSync(lockDir);
-            if (Date.now() - stat.mtimeMs > START_LOCK_MAX_AGE_MS) {
+            if (Date.now() - stat.mtimeMs > START_LOCK_MAX_AGE_MS &&
+                isStartLockOwnerProvenDead(lockDir)) {
                 rmSync(lockDir, { recursive: true, force: true });
                 mkdirSync(lockDir);
-                writeFileSync(join(lockDir, "owner.json"), `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString(), recovered: true })}\n`, "utf8");
+                writeStartLockOwner(lockDir, true);
                 return () => rmSync(lockDir, { recursive: true, force: true });
             }
         }
@@ -40,17 +71,20 @@ export function acquireStateStartLock(stateDir) {
     }
     return () => rmSync(lockDir, { recursive: true, force: true });
 }
-export function prepareStateDirForStart(stateDir, readJson, runnerPath) {
+export function prepareStateDirForStart(stateDir, readJson, _runnerPath) {
     const existing = readJson(join(stateDir, "run.json"));
     const existingPid = Number(existing?.pid || 0);
-    const existingCwd = typeof existing?.cwd === "string" ? existing.cwd : undefined;
-    const existingResult = readJson(join(stateDir, "result.json"));
-    if (!existingResult &&
-        existingPid &&
-        existingCwd &&
-        isAlive(existingPid) &&
-        pidMatchesRun(existingPid, existingCwd, stateDir, runnerPath)) {
-        throw new Error(`Run state already has an active owned process: ${String(existing?.run ?? stateDir)}. Stop it before restarting.`);
+    if (existingPid && isAlive(existingPid)) {
+        const identity = verifyRunProcessIdentity(existingPid, existing?.process_identity);
+        if (identity.status === "owner_mismatch") {
+            throw new Error(`Run state process identity does not match the live pid: ${String(existing?.run ?? stateDir)}. Refusing to prepare the state directory while pid ${existingPid} is alive.`);
+        }
+        if (identity.status === "unsupported_proof") {
+            throw new Error(`Run state process identity proof is unavailable: ${String(existing?.run ?? stateDir)}. Refusing to prepare the state directory while pid ${existingPid} is alive.`);
+        }
+        if (identity.valid) {
+            throw new Error(`Run state already has an active owned process: ${String(existing?.run ?? stateDir)}. Stop it before restarting.`);
+        }
     }
     for (const file of [
         "events.jsonl",

package/dist/lib/runs-status.d.ts

@@ -3,6 +3,6 @@
  * Owns status derivation from run state files plus bounded log/event tails.
  */
 export type RunJsonReader = (path: string) => Record<string, unknown> | undefined;
-export declare function buildRunStatus(stateDir: string, runOrDir: string, meta: Record<string, unknown>, readJson: RunJsonReader, runnerPath: string, runnerIdentityGraceMs: number): Record<string, unknown>;
+export declare function buildRunStatus(stateDir: string, runOrDir: string, meta: Record<string, unknown>, readJson: RunJsonReader, _runnerPath: string, runnerIdentityGraceMs: number): Record<string, unknown>;
 export declare function tailFile(path: string, lines: number): string;
 export declare function tailLines(path: string, lines: number): string[];