stitchkit 0.104.1 → 0.105.0

package/dist/index-9tqbxv5p.js

@@ -0,0 +1,44 @@
+import {
+  MAX_TIMER_MS
+} from "./index-eemvahkc.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
+
+// src/internal/deadline.ts
+async function withDeadline(value, timeoutMs) {
+  if (!(value instanceof Promise))
+    return { settled: true, value };
+  let timer;
+  const expiry = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ settled: false }), timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      value.then((settledValue) => ({
+        settled: true,
+        value: settledValue
+      })),
+      expiry
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+async function withSignalDeadline(timeoutMs, caller, makeReason, body) {
+  assertPositiveSafeInteger("Deadline timeoutMs", timeoutMs, RangeError);
+  if (timeoutMs > MAX_TIMER_MS)
+    throw new RangeError("Deadline timeoutMs exceeds the timer range");
+  caller?.throwIfAborted();
+  const deadline = new AbortController;
+  const timer = setTimeout(() => deadline.abort(makeReason()), timeoutMs);
+  const signal = caller ? AbortSignal.any([caller, deadline.signal]) : deadline.signal;
+  try {
+    return await body(signal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export { withDeadline, withSignalDeadline };

package/dist/{index-5csmzesf.js → index-azx12jgv.js}

@@ -87,8 +87,9 @@ var ProcessInstanceObservationSchema = z.discriminatedUnion("state", [
   z.object({ state: z.literal("observed"), instance: ProcessInstanceSchema2 }),
   z.object({ state: z.literal("unavailable"), cause: z.unknown() })
 ]);
+var MAX_PID = 2 ** 31 - 1;
 async function observeProcessInstance2(pid) {
-  z.number().int().positive().max(2147483647).parse(pid);
+  z.number().int().positive().max(MAX_PID).parse(pid);
   return observeProcessInstanceAt(pid, "/proc");
 }
 function linuxProcessStart(stat, pid) {
@@ -158,7 +159,7 @@ var ProcessOwnerEvidenceSchema = z.object({
   cause: z.unknown().optional()
 });
 async function probeProcessOwner2(pid, recorded) {
-  z.number().int().positive().max(2147483647).parse(pid);
+  z.number().int().positive().max(MAX_PID).parse(pid);
   if (recorded != null)
     ProcessInstanceSchema2.parse(recorded);
   return probeProcessOwnerWith(pid, recorded, {
@@ -203,7 +204,7 @@ async function probeProcessOwnerWith(pid, recorded, probes = { read: readProcess
   if (observation.state === "unavailable")
     return unavailable(observation.cause);
   const observed = observation.instance;
-  if (!observed || observed.bootId !== current.bootId || observed.namespace !== current.namespace)
+  if (observed.bootId !== current.bootId || observed.namespace !== current.namespace)
     return unavailable(new Error("Observed boot or namespace changed during probe"));
   if (recorded.startId !== observed.startId)
     return { liveness: "gone", identity: "reused-pid" };

package/dist/{index-mbnnw3f2.js → index-b0kddvzw.js}

@@ -1,23 +1,33 @@
 // src/internal/abort-race.ts
-function raceAbort(operation, signal) {
+function raceAbort(operation, signal, disposeLate) {
+  const dispose = (value) => {
+    try {
+      disposeLate?.(value);
+    } catch {}
+  };
   if (signal.aborted) {
-    operation.catch(() => {
+    operation.then(dispose, () => {
       return;
     });
     return Promise.reject(signal.reason);
   }
   return new Promise((resolve, reject) => {
+    let released = false;
     const abort = () => {
-      signal.removeEventListener("abort", abort);
+      released = true;
       reject(signal.reason);
     };
     signal.addEventListener("abort", abort, { once: true });
     operation.then((value) => {
       signal.removeEventListener("abort", abort);
-      resolve(value);
+      if (released)
+        dispose(value);
+      else
+        resolve(value);
     }, (error) => {
       signal.removeEventListener("abort", abort);
-      reject(error);
+      if (!released)
+        reject(error);
     });
   });
 }

package/dist/{index-n5yqxd3d.js → index-b0w7rbpt.js}

@@ -46,6 +46,22 @@ var AgentControlRequestSchema2 = z.discriminatedUnion("operation", [
     metadata: z.unknown().optional()
   })
 ]);
+var AgentControlErrorCodeSchema2 = z.enum([
+  "ATTACH_CANCELLED",
+  "ATTACH_IN_PROGRESS",
+  "ATTACHMENT_CAPACITY",
+  "CONNECTION_CLOSED",
+  "CONTROL_REQUEST_FAILED",
+  "EVENT_OVERFLOW",
+  "FORBIDDEN",
+  "LEASE_CONFLICT",
+  "LEASE_REQUIRED",
+  "NOT_ATTACHED",
+  "REQUEST_CANCELLED",
+  "REQUEST_CAPACITY",
+  "REQUEST_REJECTED",
+  "RESYNC_EXHAUSTED"
+]);
 var AgentControlResponseIdentitySchema = z.object({
   schemaVersion: z.literal(1),
   requestId: z.string().min(1)
@@ -58,7 +74,7 @@ var AgentControlResponseSchema2 = z.discriminatedUnion("outcome", [
   }).strict(),
   AgentControlResponseIdentitySchema.extend({
     outcome: z.literal("error"),
-    error: z.object({ code: z.string().min(1), message: z.string().min(1) }).strict()
+    error: z.object({ code: AgentControlErrorCodeSchema2, message: z.string().min(1) }).strict()
   }).strict()
 ]);
 var AgentControlDeliverySchema2 = z.discriminatedUnion("type", [
@@ -72,6 +88,11 @@ var AgentControlDeliverySchema2 = z.discriminatedUnion("type", [
     type: z.literal("resync-required"),
     conversationId: z.string().min(1),
     reason: z.literal("overflow")
+  }).strict(),
+  z.object({
+    schemaVersion: z.literal(1),
+    type: z.literal("access-denied"),
+    conversationId: z.string().min(1)
   }).strict()
 ]);
 var AgentMultiSessionCursorSchema2 = z.object({
@@ -195,4 +216,4 @@ function reduceAgentControlEvent2(view, rawEvent) {
   };
 }
 
-export { AgentControlRequestSchema2, AgentControlResponseSchema2, AgentControlDeliverySchema2, AgentMultiSessionCursorSchema2, advanceAgentMultiSessionCursor2, createAgentControlView2, reduceAgentControlSnapshot2, reduceAgentControlEvent2 };
+export { AgentControlRequestSchema2, AgentControlErrorCodeSchema2, AgentControlResponseSchema2, AgentControlDeliverySchema2, AgentMultiSessionCursorSchema2, advanceAgentMultiSessionCursor2, createAgentControlView2, reduceAgentControlSnapshot2, reduceAgentControlEvent2 };

package/dist/index-b56nnscm.js

@@ -0,0 +1,132 @@
+// src/internal/atomic-publication.ts
+import { closeSync, fsyncSync, linkSync, openSync, renameSync, unlinkSync } from "node:fs";
+import { link, open, rename, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// src/internal/close-after.ts
+async function closeAfter(handle, run) {
+  let result;
+  try {
+    result = await run();
+  } catch (error) {
+    await handle.close().catch(() => {
+      return;
+    });
+    throw error;
+  }
+  await handle.close();
+  return result;
+}
+function closeAfterSync(close, run) {
+  let result;
+  try {
+    result = run();
+  } catch (error) {
+    try {
+      close();
+    } catch {}
+    throw error;
+  }
+  close();
+  return result;
+}
+
+// src/internal/atomic-publication.ts
+class AtomicFilePublicationError2 extends Error {
+  phase;
+  published = true;
+  constructor(phase, cause) {
+    super(`File published but ${phase} failed`, { cause });
+    this.phase = phase;
+    this.name = "AtomicFilePublicationError";
+  }
+}
+var native = { rename, link, unlink, open };
+var nativeSync = {
+  rename: renameSync,
+  link: linkSync,
+  unlink: unlinkSync,
+  open(path, flags) {
+    const descriptor = openSync(path, flags);
+    return { sync: () => fsyncSync(descriptor), close: () => closeSync(descriptor) };
+  }
+};
+function assertDirectoryDurability() {
+  if (process.platform === "win32")
+    throw new Error("Directory durability is unsupported on Windows");
+}
+async function syncDirectory(path, io = native) {
+  assertDirectoryDurability();
+  const directory = await io.open(path, "r");
+  await closeAfter(directory, () => directory.sync());
+}
+async function publishAtomicFile(staged, target, { replace, durability }, io = native) {
+  const directorySync = durability === "directory";
+  if (directorySync)
+    assertDirectoryDurability();
+  const directory = directorySync ? await io.open(dirname(target), "r") : undefined;
+  const publish = async () => {
+    if (replace)
+      await io.rename(staged, target);
+    else {
+      await io.link(staged, target);
+      try {
+        await io.unlink(staged);
+      } catch (error) {
+        throw new AtomicFilePublicationError2("cleanup", error);
+      }
+    }
+    try {
+      await directory?.sync();
+    } catch (error) {
+      throw new AtomicFilePublicationError2("directory-sync", error);
+    }
+  };
+  if (directory === undefined)
+    return publish();
+  await closeAfter({
+    close: async () => {
+      try {
+        await directory.close();
+      } catch (error) {
+        throw new AtomicFilePublicationError2("directory-close", error);
+      }
+    }
+  }, publish);
+}
+function publishAtomicFileSync(staged, target, { replace, durability }, io = nativeSync) {
+  const directorySync = durability === "directory";
+  if (directorySync)
+    assertDirectoryDurability();
+  const directory = directorySync ? io.open(dirname(target), "r") : undefined;
+  const publish = () => {
+    if (replace)
+      io.rename(staged, target);
+    else {
+      io.link(staged, target);
+      try {
+        io.unlink(staged);
+      } catch (error) {
+        throw new AtomicFilePublicationError2("cleanup", error);
+      }
+    }
+    try {
+      directory?.sync();
+    } catch (error) {
+      throw new AtomicFilePublicationError2("directory-sync", error);
+    }
+  };
+  if (directory === undefined) {
+    publish();
+    return;
+  }
+  closeAfterSync(() => {
+    try {
+      directory.close();
+    } catch (error) {
+      throw new AtomicFilePublicationError2("directory-close", error);
+    }
+  }, publish);
+}
+
+export { closeAfter, closeAfterSync, AtomicFilePublicationError2, assertDirectoryDurability, syncDirectory, publishAtomicFile, publishAtomicFileSync };

package/dist/{index-0ndk4555.js → index-c0hffcmj.js}

@@ -5,7 +5,7 @@ import {
   AgentRecoverableDescriptorSchema2,
   AgentRecoverablePageSchema2,
   canonicalAgentJson2
-} from "./index-r5hsgkz5.js";
+} from "./index-0gs4ymfj.js";
 import {
   AgentMessageSchema2,
   AgentRunSchema2
@@ -18,7 +18,7 @@ import {
   AgentHistoryMutationSchema2,
   appendEventIn,
   createAgentRuntimeStore2
-} from "./index-ssmd41kh.js";
+} from "./index-d2h99n7d.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/{index-pptyv13k.js → index-c17xcx4k.js}

@@ -1,9 +1,12 @@
 import {
   raceAbort
-} from "./index-mbnnw3f2.js";
+} from "./index-b0kddvzw.js";
 import {
   isJsonData
-} from "./index-fm1c1a08.js";
+} from "./index-m6w6jtda.js";
+import {
+  MAX_TIMER_MS
+} from "./index-eemvahkc.js";
 
 // src/durability/contract.ts
 import { z } from "zod";
@@ -296,8 +299,8 @@ async function reconcile(context, name, handlers, timeoutMs, outerSignal) {
 }
 async function executeEffect(context, name, handlers, options) {
   const timeoutMs = options?.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
-    throw new TypeError(`reconcileTimeoutMs must be a positive finite number at most 2147483647, got ${timeoutMs}`);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_MS) {
+    throw new TypeError(`reconcileTimeoutMs must be a positive finite number at most ${MAX_TIMER_MS}, got ${timeoutMs}`);
   }
   const key = effectKey(context.conversationId, context.runId, name);
   const recorded = (await context.readLedger()).effects.get(key);
@@ -326,7 +329,7 @@ async function executeEffect(context, name, handlers, options) {
 var systemClock = {
   now: () => Date.now(),
   schedule(callback, delayMs) {
-    const timer = setTimeout(callback, Math.min(delayMs, 2147483647));
+    const timer = setTimeout(callback, Math.min(delayMs, MAX_TIMER_MS));
     timer.unref();
     return { cancel: () => clearTimeout(timer) };
   }
@@ -617,4 +620,37 @@ function createLocalStepDurability2(options) {
   };
 }
 
-export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2 };
+// src/tools/agent-tool-error.ts
+var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
+
+class AgentToolError2 extends Error {
+  output;
+  constructor(output, cause) {
+    let message = "Tool execution failed";
+    try {
+      message = JSON.stringify(output);
+    } catch {}
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "AgentToolError";
+    this.output = output;
+    Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
+  }
+}
+function isAgentToolError2(value) {
+  return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
+}
+
+// src/tools/durability-context.ts
+var contexts = new WeakMap;
+function createToolDurabilityContext(factory) {
+  const context = {};
+  contexts.set(context, factory);
+  return context;
+}
+function resolveToolDurability(context, callId, signal) {
+  if (typeof context !== "object" || context === null)
+    return;
+  return contexts.get(context)?.(callId, signal);
+}
+
+export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2, AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };

package/dist/{index-g2j7pnak.js → index-cmzvhhtd.js}

@@ -1,6 +1,6 @@
 import {
   AppError2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   contractMethodFields
 } from "./index-1bx1xv1k.js";
@@ -68,7 +68,10 @@ function contractOnlyService(contract) {
 }
 function stubHandler(label) {
   return () => {
-    throw new AppError2("NOT_IMPLEMENTED", `[stitchkit] ${label} is declared by its contract and has no handler`, 501);
+    throw new AppError2("NOT_IMPLEMENTED", {
+      message: `[stitchkit] ${label} is declared by its contract and has no handler`,
+      status: 501
+    });
   };
 }
 function bindContract(contract, handlers, options) {

package/dist/index-cq59agna.js

@@ -0,0 +1,51 @@
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
+
+// src/internal/atomic-staging.ts
+import { randomBytes } from "node:crypto";
+import { lstat, readdir, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var PREFIX = ".stitchkit-";
+var SUFFIX = ".tmp";
+var RANDOM_BYTES = 12;
+var literal = (text) => text.replaceAll(".", "\\.");
+var NAME = new RegExp(`^${literal(PREFIX)}[0-9a-f]{${RANDOM_BYTES * 2}}${literal(SUFFIX)}$`);
+function stagingName() {
+  return `${PREFIX}${randomBytes(RANDOM_BYTES).toString("hex")}${SUFFIX}`;
+}
+function stagingPath(target) {
+  return join(dirname(target), stagingName());
+}
+function isAtomicStagingName2(name) {
+  return NAME.test(name);
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function sweepAtomicStaging2(options) {
+  const { directory, olderThanMs, signal } = options;
+  assertPositiveSafeInteger("olderThanMs", olderThanMs, RangeError);
+  signal?.throwIfAborted();
+  const cutoff = Date.now() - olderThanMs;
+  const removed = [];
+  for (const name of await readdir(directory)) {
+    signal?.throwIfAborted();
+    if (!isAtomicStagingName2(name))
+      continue;
+    const path = join(directory, name);
+    try {
+      const info = await lstat(path);
+      if (!info.isFile() || info.mtimeMs > cutoff)
+        continue;
+      await unlink(path);
+      removed.push(name);
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+    }
+  }
+  return removed;
+}
+
+export { stagingName, stagingPath, isAtomicStagingName2, sweepAtomicStaging2 };

package/dist/{index-ssmd41kh.js → index-d2h99n7d.js}

@@ -27,7 +27,7 @@ import {
   encodeAgentConversationArchive2,
   decodeAgentConversationArchive2,
   assistantStatus
-} from "./index-r5hsgkz5.js";
+} from "./index-0gs4ymfj.js";
 
 // src/agent-runtime/purge.ts
 import { z } from "zod";

package/dist/{index-z94wht4y.js → index-dky0dcmf.js}

@@ -43,20 +43,47 @@ function createDiagnosticJournalReadResultSchema2(eventSchema) {
     z2.object({ type: z2.literal("anomaly"), anomaly: DiagnosticJournalAnomalySchema2 }).strict().readonly()
   ]);
 }
+var DiagnosticJournalStartupRefusalReasonSchema2 = z2.enum([
+  "torn-without-retention-slot",
+  "not-a-regular-file",
+  "unreadable"
+]);
+var DIAGNOSTIC_JOURNAL_LISTED_QUARANTINE_LIMIT = 32;
+var QuarantinedFileSchema = z2.object({
+  file: z2.string(),
+  quarantinedAs: z2.string(),
+  reason: DiagnosticJournalStartupRefusalReasonSchema2.optional(),
+  code: z2.string().optional()
+}).strict().readonly();
 var DiagnosticJournalRecoveryStatusSchema2 = z2.object({
   filesChecked: ByteCountSchema,
   anomalies: ByteCountSchema,
   skippedBytes: ByteCountSchema,
   firstAnomaly: DiagnosticJournalAnomalySchema2.optional(),
-  lastAnomaly: DiagnosticJournalAnomalySchema2.optional()
+  lastAnomaly: DiagnosticJournalAnomalySchema2.optional(),
+  quarantined: z2.array(QuarantinedFileSchema).max(DIAGNOSTIC_JOURNAL_LISTED_QUARANTINE_LIMIT).readonly().optional(),
+  quarantinedUnlisted: z2.number().int().positive().optional()
 }).strict().readonly();
+var REFUSAL_MESSAGES = {
+  "torn-without-retention-slot": "Diagnostic journal tail recovery requires maxFiles >= 2; no data was removed",
+  "not-a-regular-file": "Diagnostic journal generations must be regular files",
+  unreadable: "Diagnostic journal could not read a retained file"
+};
 
 class DiagnosticJournalRecoveryError2 extends Error {
+  reason;
+  file;
   recovery;
-  constructor(recovery) {
-    super("Diagnostic journal tail recovery requires maxFiles >= 2; no data was removed");
-    this.recovery = recovery;
+  quarantineFailed;
+  constructor(options) {
+    const quarantineFailed = options.quarantineFailed ?? false;
+    super(`${REFUSAL_MESSAGES[options.reason]}: ${options.file}${quarantineFailed ? " (moving it aside failed)" : ""}`, options.cause === undefined ? undefined : { cause: options.cause });
     this.name = "DiagnosticJournalRecoveryError";
+    this.reason = options.reason;
+    this.file = options.file;
+    if (options.recovery)
+      this.recovery = options.recovery;
+    this.quarantineFailed = quarantineFailed;
   }
 }
 
@@ -72,6 +99,8 @@ var DiagnosticJournalLimitsSchema2 = z3.object({
   maxFiles: PositiveSafeIntegerSchema
 }).strict().readonly();
 var DiagnosticJournalLockPolicySchema2 = z3.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStartupScanSchema2 = z3.enum(["tails", "full"]);
+var DiagnosticJournalStartupRefusalPolicySchema2 = z3.enum(["quarantine", "fail"]);
 var DiagnosticJournalStateSchema2 = z3.enum(["open", "draining", "closed", "failed"]);
 var DiagnosticJournalRefusalReasonSchema2 = z3.enum([
   "closed",
@@ -153,4 +182,4 @@ function readDiagnosticJournalLockDiagnosis2(error) {
   return isRecord(diagnosis) ? diagnosis : undefined;
 }
 
-export { DiagnosticJournalFrameSchema2, DiagnosticJournalAnomalySchema2, createDiagnosticJournalReadResultSchema2, DiagnosticJournalRecoveryStatusSchema2, DiagnosticJournalRecoveryError2, DiagnosticJournalLimitsSchema2, DiagnosticJournalLockPolicySchema2, DiagnosticJournalStateSchema2, DiagnosticJournalRefusalReasonSchema2, DiagnosticJournalFailurePhaseSchema2, DiagnosticJournalStatusSchema2, DiagnosticJournalSubmitResultSchema2, DiagnosticJournalWaitResultSchema2, DiagnosticJournalCloseResultSchema2, parseDiagnosticJournalMode, readDiagnosticJournalLockDiagnosis2 };
+export { DiagnosticJournalFrameSchema2, DiagnosticJournalAnomalySchema2, createDiagnosticJournalReadResultSchema2, DiagnosticJournalStartupRefusalReasonSchema2, DIAGNOSTIC_JOURNAL_LISTED_QUARANTINE_LIMIT, DiagnosticJournalRecoveryStatusSchema2, DiagnosticJournalRecoveryError2, DiagnosticJournalLimitsSchema2, DiagnosticJournalLockPolicySchema2, DiagnosticJournalStartupScanSchema2, DiagnosticJournalStartupRefusalPolicySchema2, DiagnosticJournalStateSchema2, DiagnosticJournalRefusalReasonSchema2, DiagnosticJournalFailurePhaseSchema2, DiagnosticJournalStatusSchema2, DiagnosticJournalSubmitResultSchema2, DiagnosticJournalWaitResultSchema2, DiagnosticJournalCloseResultSchema2, parseDiagnosticJournalMode, readDiagnosticJournalLockDiagnosis2 };