stitchkit 0.99.0 → 0.100.1

package/dist/{index-8p52kd5p.js → index-c6bxbsnc.js}

@@ -1,3 +1,6 @@
+import {
+  loadDarwinBinding
+} from "./index-zjjyynm3.js";
 import {
   isRecord
 } from "./index-hffjpmq9.js";
@@ -6,6 +9,7 @@ import {
 import { constants } from "node:fs";
 import { lstat, open, unlink } from "node:fs/promises";
 import { hostname } from "node:os";
+import { z as z2 } from "zod";
 
 // src/internal/process-identity.ts
 import { execFile } from "node:child_process";
@@ -47,9 +51,9 @@ async function machineIdentity(declared) {
   detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
   return detectedIdentity;
 }
-async function probeLiveness(pid) {
+async function probeLiveness(pid, reach = (target) => process.kill(target, 0)) {
   try {
-    process.kill(pid, 0);
+    reach(pid);
   } catch (error) {
     return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
   }
@@ -73,7 +77,96 @@ async function isZombieProcess(pid, seam = {}) {
   }
 }
 
+// src/internal/process-instance.ts
+import { readFile as readFile2, readlink } from "node:fs/promises";
+import { platform as platform2 } from "node:os";
+import { z } from "zod";
+var ProcessInstanceSchema = z.object({
+  platform: z.enum(["linux", "darwin"]),
+  bootId: z.string().min(1),
+  namespace: z.string().min(1),
+  startId: z.string().regex(/^\d+$/)
+}).strict();
+function linuxProcessStart(stat, pid) {
+  if (!stat.startsWith(`${pid} (`))
+    return null;
+  const end = stat.lastIndexOf(")");
+  if (end < 0)
+    return null;
+  const start = stat.slice(end + 1).trim().split(/\s+/)[19];
+  return start !== undefined && /^\d+$/.test(start) ? start : null;
+}
+async function readProcessInstance(pid, procRoot = "/proc") {
+  try {
+    if (platform2() === "darwin") {
+      const result = ProcessInstanceSchema.safeParse(loadDarwinBinding().processIdentity(pid));
+      return result.success ? result.data : null;
+    }
+    if (platform2() !== "linux")
+      return null;
+    const [bootId, namespace, ownStatus, timeNamespace, ownStat, stat] = await Promise.all([
+      readFile2(`${procRoot}/sys/kernel/random/boot_id`, "utf8"),
+      readlink(`${procRoot}/self/ns/pid`),
+      readFile2(`${procRoot}/self/status`, "utf8"),
+      readlink(`${procRoot}/self/ns/time`).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+          return "";
+        throw error;
+      }),
+      readFile2(`${procRoot}/self/stat`, "utf8"),
+      readFile2(`${procRoot}/${pid}/stat`, "utf8")
+    ]);
+    const namespacePids = ownStatus.match(/^NStgid:[ \t]*(.*)$/m)?.[1]?.trim().split(/\s+/);
+    if (namespacePids?.length !== 1 || namespacePids[0] !== String(process.pid) || linuxProcessStart(ownStat, process.pid) === null)
+      return null;
+    const startId = linuxProcessStart(stat, pid);
+    if (startId === null || !bootId.trim())
+      return null;
+    return {
+      platform: "linux",
+      bootId: bootId.trim(),
+      namespace: `${namespace};${timeNamespace}`,
+      startId
+    };
+  } catch {
+    return null;
+  }
+}
+async function probeProcessOwner(pid, recorded, probes = { read: readProcessInstance, liveness: probeLiveness }) {
+  if (recorded === undefined)
+    return { liveness: await probes.liveness(pid), identity: "legacy" };
+  const unavailable = {
+    liveness: "not-probed",
+    identity: "unavailable"
+  };
+  if (recorded === null)
+    return unavailable;
+  const current = await probes.read(process.pid);
+  if (!current || recorded.platform !== current.platform)
+    return unavailable;
+  if (recorded.bootId !== current.bootId)
+    return { liveness: "gone", identity: "different-boot" };
+  if (recorded.namespace !== current.namespace)
+    return unavailable;
+  const liveness = await probes.liveness(pid);
+  if (liveness === "gone")
+    return { liveness, identity: "pid-gone" };
+  const observed = await probes.read(pid);
+  if (!observed || observed.bootId !== current.bootId || observed.namespace !== current.namespace)
+    return unavailable;
+  if (recorded.startId !== observed.startId)
+    return { liveness: "gone", identity: "reused-pid" };
+  return { liveness: "alive", identity: "matched" };
+}
+
 // src/internal/exclusive-lock.ts
+var ExclusiveLockOwnerSchema = z2.object({
+  pid: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  host: z2.string().min(1),
+  acquiredAt: z2.string(),
+  machine: z2.string().min(1).optional().catch(undefined),
+  process: ProcessInstanceSchema.nullable().optional().catch(null)
+});
 function isCode(error, code) {
   return isRecord(error) && error.code === code;
 }
@@ -84,17 +177,8 @@ function readOwner(text) {
   } catch {
     return;
   }
-  if (!isRecord(parsed))
-    return;
-  const { pid, host, acquiredAt, machine } = parsed;
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
-    return;
-  if (typeof host !== "string" || host.length === 0)
-    return;
-  if (typeof acquiredAt !== "string")
-    return;
-  const identified = typeof machine === "string" && machine.length > 0 ? { machine } : {};
-  return { pid, host, acquiredAt, ...identified };
+  const owner = ExclusiveLockOwnerSchema.safeParse(parsed);
+  return owner.success ? owner.data : undefined;
 }
 function attribute(owner, identity) {
   if (identity !== null && owner.machine !== undefined) {
@@ -108,7 +192,7 @@ async function diagnose(owner, declaredIdentity) {
   const attribution = attribute(owner, await machineIdentity(declaredIdentity));
   if (attribution !== "this-machine")
     return { attribution, liveness: "not-probed", owner };
-  return { attribution, liveness: await probeLiveness(owner.pid), owner };
+  return { attribution, ...await probeProcessOwner(owner.pid, owner.process), owner };
 }
 async function readLockFile(path) {
   let handle;
@@ -140,9 +224,11 @@ async function unlinkIfSame(path, ino) {
 }
 async function createOwned(path, options, reclaimed) {
   const identity = await machineIdentity(options.machineIdentity);
+  const instance = await readProcessInstance(process.pid);
   const handle = await open(path, "wx", options.mode);
   const owner = {
     pid: process.pid,
+    process: instance,
     host: hostname(),
     acquiredAt: new Date().toISOString(),
     ...identity !== null && { machine: identity }

package/dist/{index-gxrt5h6v.js → index-cyktc4bp.js}

@@ -17,6 +17,9 @@ import { z } from "zod";
 var AgentStoreEventKindSchema = z.enum([
   "runtime/baseline",
   "runtime/transition",
+  "invocation/started",
+  "invocation/finished",
+  "provider/payload",
   "provider/request",
   "provider/response",
   "provider/message",

package/dist/{index-1m2thnq0.js → index-eaysmdtq.js}

@@ -10,7 +10,7 @@ import {
   AgentStoredRunSchema,
   appendEventIn,
   createAgentRuntimeStore
-} from "./index-wsm5w4ee.js";
+} from "./index-vqr7f7v8.js";
 import {
   AgentRecoverableDescriptorSchema,
   AgentRecoverablePageSchema,
@@ -18,7 +18,7 @@ import {
   AgentStoreEventPageSchema,
   AppendAgentStoreEventSchema,
   canonicalAgentJson
-} from "./index-gxrt5h6v.js";
+} from "./index-cyktc4bp.js";
 import {
   AgentMessageSchema,
   AgentRunSchema
@@ -528,6 +528,15 @@ var sqliteEvents = {
       items,
       ...hasMore && lastEvent ? { nextSeq: lastEvent.seq + 1 } : {}
     });
+  },
+  async find(transaction, input) {
+    const row = transaction.prepare(`
+        SELECT event_id, conversation_id, seq, schema_version, kind, occurred_at,
+          ignorable, payload
+        FROM stitchkit_agent_runtime_events
+        WHERE event_id = ? AND conversation_id = ?
+      `).get(input.eventId, input.conversationId);
+    return row === null || row === undefined ? undefined : parseEventRow(row);
   }
 };
 var sqliteArchive = {