@workflow/world-local 5.0.0-beta.22 → 5.0.0-beta.24

package/dist/storage/helpers.d.ts

@@ -2,6 +2,43 @@
  * Hash a hook token to produce a filesystem-safe constraint filename.
  */
 export declare function hashToken(token: string): string;
+/**
+ * Path of the exclusive-create lock file that commits a hook's disposal.
+ * The `hook_disposed` handler writes this lock BEFORE deleting the token
+ * claim and hook entity (and before appending the event to the log), so
+ * its existence is the earliest durable evidence that the hook can never
+ * be live again.
+ */
+export declare function hookDisposeLockPath(basedir: string, hookId: string, tag?: string): string;
+/**
+ * Whether a hook's disposal has been committed (its dispose lock exists).
+ * Mirrors event visibility for tagged worlds: an untagged lock is visible
+ * to every tag, a tagged lock only to its own tag.
+ */
+export declare function isHookDisposalCommitted(basedir: string, hookId: string, tag?: string): Promise<boolean>;
+/**
+ * Path of the exclusive-create claim file that reserves a hook token.
+ */
+export declare function hookTokenClaimPath(basedir: string, token: string): string;
+/**
+ * Release (delete) a token claim only if it still points at the releasing
+ * hook's own `(runId, hookId)`.
+ *
+ * Both in-flight releasers — the `hook_disposed` handler and the
+ * terminal-run `deleteAllHooksForRun` cleanup — read the hook entity and
+ * then delete the claim file. Deleting unconditionally is unsafe across
+ * processes: a releaser that stalls between those two operations can
+ * outlive a force-release of its stale claim (see
+ * `isHookTokenClaimReleasable`) and then delete the NEXT claimant's live
+ * claim, transiently breaking token uniqueness. Re-reading the claim and
+ * matching its identity here shrinks that window from "a stall of any
+ * length" to the adjacent read/delete file ops.
+ *
+ * A claim that is missing, unreadable, or owned by someone else is left
+ * alone — if it is genuinely stale debris, the claimant-side force-release
+ * path reaps it.
+ */
+export declare function releaseHookTokenClaimIfOwnedBy(basedir: string, token: string, runId: string, hookId: string): Promise<void>;
 /**
  * Compute the path of the recovery-marker sidecar for a specific
  * `(token, runId, hookId)` triple. Identity is encoded in the

package/dist/storage/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,4BAAwC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC5B,UAAU,MAAM,MAChB,UAAU,MAAM,KAAG,IAAI,GAAG,IAyB1B,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,MAAM,CAGR;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAclB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,4BAAwC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC5B,UAAU,MAAM,MAChB,UAAU,MAAM,KAAG,IAAI,GAAG,IAyB1B,CAAC"}

package/dist/storage/helpers.js

@@ -1,13 +1,84 @@
 import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { monotonicFactory } from 'ulid';
-import { stripTag, ulidToDate } from '../fs.js';
+import { resolveWithinBase, stripTag, ulidToDate } from '../fs.js';
 /**
  * Hash a hook token to produce a filesystem-safe constraint filename.
  */
 export function hashToken(token) {
     return createHash('sha256').update(token).digest('hex');
 }
+/**
+ * Path of the exclusive-create lock file that commits a hook's disposal.
+ * The `hook_disposed` handler writes this lock BEFORE deleting the token
+ * claim and hook entity (and before appending the event to the log), so
+ * its existence is the earliest durable evidence that the hook can never
+ * be live again.
+ */
+export function hookDisposeLockPath(basedir, hookId, tag) {
+    const name = tag ? `${hookId}.disposed.${tag}` : `${hookId}.disposed`;
+    return resolveWithinBase(basedir, '.locks', 'hooks', name);
+}
+/**
+ * Whether a hook's disposal has been committed (its dispose lock exists).
+ * Mirrors event visibility for tagged worlds: an untagged lock is visible
+ * to every tag, a tagged lock only to its own tag.
+ */
+export async function isHookDisposalCommitted(basedir, hookId, tag) {
+    const candidates = [hookDisposeLockPath(basedir, hookId)];
+    if (tag) {
+        candidates.push(hookDisposeLockPath(basedir, hookId, tag));
+    }
+    for (const lockPath of candidates) {
+        try {
+            await fs.access(lockPath);
+            return true;
+        }
+        catch {
+            // lock not present at this path
+        }
+    }
+    return false;
+}
+/**
+ * Path of the exclusive-create claim file that reserves a hook token.
+ */
+export function hookTokenClaimPath(basedir, token) {
+    return path.join(basedir, 'hooks', 'tokens', `${hashToken(token)}.json`);
+}
+/**
+ * Release (delete) a token claim only if it still points at the releasing
+ * hook's own `(runId, hookId)`.
+ *
+ * Both in-flight releasers — the `hook_disposed` handler and the
+ * terminal-run `deleteAllHooksForRun` cleanup — read the hook entity and
+ * then delete the claim file. Deleting unconditionally is unsafe across
+ * processes: a releaser that stalls between those two operations can
+ * outlive a force-release of its stale claim (see
+ * `isHookTokenClaimReleasable`) and then delete the NEXT claimant's live
+ * claim, transiently breaking token uniqueness. Re-reading the claim and
+ * matching its identity here shrinks that window from "a stall of any
+ * length" to the adjacent read/delete file ops.
+ *
+ * A claim that is missing, unreadable, or owned by someone else is left
+ * alone — if it is genuinely stale debris, the claimant-side force-release
+ * path reaps it.
+ */
+export async function releaseHookTokenClaimIfOwnedBy(basedir, token, runId, hookId) {
+    const claimPath = hookTokenClaimPath(basedir, token);
+    let claim;
+    try {
+        claim = JSON.parse(await fs.readFile(claimPath, 'utf8'));
+    }
+    catch {
+        return;
+    }
+    if (claim.runId !== runId || claim.hookId !== hookId) {
+        return;
+    }
+    await fs.unlink(claimPath).catch(() => { });
+}
 /**
  * Compute the path of the recovery-marker sidecar for a specific
  * `(token, runId, hookId)` triple. Identity is encoded in the
@@ -63,4 +134,4 @@ export const getObjectCreatedAt = (idPrefix) => (filename) => {
     const ulid = id.replace(replaceRegex, '');
     return ulidToDate(ulid);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\nimport { monotonicFactory } from 'ulid';\nimport { resolveWithinBase, stripTag, ulidToDate } from '../fs.js';\n\n/**\n * Hash a hook token to produce a filesystem-safe constraint filename.\n */\nexport function hashToken(token: string): string {\n  return createHash('sha256').update(token).digest('hex');\n}\n\n/**\n * Path of the exclusive-create lock file that commits a hook's disposal.\n * The `hook_disposed` handler writes this lock BEFORE deleting the token\n * claim and hook entity (and before appending the event to the log), so\n * its existence is the earliest durable evidence that the hook can never\n * be live again.\n */\nexport function hookDisposeLockPath(\n  basedir: string,\n  hookId: string,\n  tag?: string\n): string {\n  const name = tag ? `${hookId}.disposed.${tag}` : `${hookId}.disposed`;\n  return resolveWithinBase(basedir, '.locks', 'hooks', name);\n}\n\n/**\n * Whether a hook's disposal has been committed (its dispose lock exists).\n * Mirrors event visibility for tagged worlds: an untagged lock is visible\n * to every tag, a tagged lock only to its own tag.\n */\nexport async function isHookDisposalCommitted(\n  basedir: string,\n  hookId: string,\n  tag?: string\n): Promise<boolean> {\n  const candidates = [hookDisposeLockPath(basedir, hookId)];\n  if (tag) {\n    candidates.push(hookDisposeLockPath(basedir, hookId, tag));\n  }\n  for (const lockPath of candidates) {\n    try {\n      await fs.access(lockPath);\n      return true;\n    } catch {\n      // lock not present at this path\n    }\n  }\n  return false;\n}\n\n/**\n * Path of the exclusive-create claim file that reserves a hook token.\n */\nexport function hookTokenClaimPath(basedir: string, token: string): string {\n  return path.join(basedir, 'hooks', 'tokens', `${hashToken(token)}.json`);\n}\n\n/**\n * Release (delete) a token claim only if it still points at the releasing\n * hook's own `(runId, hookId)`.\n *\n * Both in-flight releasers — the `hook_disposed` handler and the\n * terminal-run `deleteAllHooksForRun` cleanup — read the hook entity and\n * then delete the claim file. Deleting unconditionally is unsafe across\n * processes: a releaser that stalls between those two operations can\n * outlive a force-release of its stale claim (see\n * `isHookTokenClaimReleasable`) and then delete the NEXT claimant's live\n * claim, transiently breaking token uniqueness. Re-reading the claim and\n * matching its identity here shrinks that window from \"a stall of any\n * length\" to the adjacent read/delete file ops.\n *\n * A claim that is missing, unreadable, or owned by someone else is left\n * alone — if it is genuinely stale debris, the claimant-side force-release\n * path reaps it.\n */\nexport async function releaseHookTokenClaimIfOwnedBy(\n  basedir: string,\n  token: string,\n  runId: string,\n  hookId: string\n): Promise<void> {\n  const claimPath = hookTokenClaimPath(basedir, token);\n  let claim: { runId?: unknown; hookId?: unknown };\n  try {\n    claim = JSON.parse(await fs.readFile(claimPath, 'utf8'));\n  } catch {\n    return;\n  }\n  if (claim.runId !== runId || claim.hookId !== hookId) {\n    return;\n  }\n  await fs.unlink(claimPath).catch(() => {});\n}\n\n/**\n * Compute the path of the recovery-marker sidecar for a specific\n * `(token, runId, hookId)` triple. Identity is encoded in the\n * filename hash so different token lifetimes (e.g. the same token\n * reused by a later run after the first run was deleted) never\n * contend on a single sidecar — without per-lifetime identity, a\n * stale marker surviving prior-run cleanup could \"leak\" its\n * eventId into the new lifetime's recovery and cause divergent\n * publication.\n *\n * See `events-storage.ts` for the full recovery-marker rationale.\n */\nexport function hookRecoveryMarkerPath(\n  basedir: string,\n  token: string,\n  runId: string,\n  hookId: string\n): string {\n  // Distinct from `hashToken(token)` so a token's claim file and\n  // its recovery marker live at different paths AND a different\n  // lifetime's recovery marker never collides with this one.\n  const key = createHash('sha256')\n    .update(`${token}\\x00${runId}\\x00${hookId}`)\n    .digest('hex');\n  return path.join(basedir, 'hooks', 'tokens', `${key}.recovery.json`);\n}\n\n/**\n * Create a monotonic ULID factory that ensures ULIDs are always increasing\n * even when generated within the same millisecond.\n */\nexport const monotonicUlid = monotonicFactory(() => Math.random());\n\n/**\n * Creates a function to extract createdAt date from a filename based on ULID.\n * Used for efficient pagination without reading file contents.\n *\n * @param idPrefix - The prefix to strip from filenames (e.g., 'wrun', 'evnt', 'step')\n * @returns A function that extracts Date from filename, or null if not extractable\n */\nexport const getObjectCreatedAt =\n  (idPrefix: string) =>\n  (filename: string): Date | null => {\n    // Strip tag suffix before ULID extraction\n    // e.g., \"wrun_ABC.vitest-0.json\" → \"wrun_ABC.json\"\n    const cleanName = stripTag(filename.replace(/\\.json$/, '')) + '.json';\n\n    const replaceRegex = new RegExp(`^${idPrefix}_`, 'g');\n    const dashIndex = cleanName.indexOf('-');\n\n    if (dashIndex === -1) {\n      // No dash - extract ULID from the filename (e.g., wrun_ULID.json, evnt_ULID.json)\n      const ulid = cleanName.replace(/\\.json$/, '').replace(replaceRegex, '');\n      return ulidToDate(ulid);\n    }\n\n    // For composite keys like {runId}-{stepId}, extract from the appropriate part\n    if (idPrefix === 'step') {\n      // Steps use sequential IDs (step_0, step_1, etc.) - no timestamp in filename.\n      // Return null to skip filename-based optimization and defer to JSON-based filtering.\n      return null;\n    }\n\n    // For events: wrun_ULID-evnt_ULID.json - extract from the eventId part\n    const id = cleanName.substring(dashIndex + 1).replace(/\\.json$/, '');\n    const ulid = id.replace(replaceRegex, '');\n    return ulidToDate(ulid);\n  };\n"]}

package/dist/storage/hooks-storage.d.ts

@@ -1,4 +1,5 @@
-import type { Storage } from '@workflow/world';
+import type { Hook, Storage } from '@workflow/world';
+export declare function rebuildLiveHookByTokenFromEventLog(basedir: string, token: string, tag?: string): Promise<Hook | null>;
 /**
  * Creates a hooks storage implementation using the filesystem.
  * Implements the Storage['hooks'] interface with hook CRUD operations.

package/dist/storage/hooks-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAKV,OAAO,EACR,MAAM,iBAAiB,CAAC;AAczB;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAiFlB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA0Bf"}
+{"version":3,"file":"hooks-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,IAAI,EAIJ,OAAO,EACR,MAAM,iBAAiB,CAAC;AA6LzB,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAOtB;AAeD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CA+FlB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA8Bf"}

package/dist/storage/hooks-storage.js

@@ -1,10 +1,121 @@
 import path from 'node:path';
 import { HookNotFoundError } from '@workflow/errors';
-import { HookSchema } from '@workflow/world';
+import { EventSchema, HookSchema, isTerminalRunEventType, isTerminalWorkflowRunStatus, WorkflowRunSchema, } from '@workflow/world';
+import { z } from 'zod';
 import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
-import { assertSafeEntityId, deleteJSON, listJSONFiles, paginatedFileSystemQuery, readJSON, readJSONWithFallback, } from '../fs.js';
+import { assertSafeEntityId, deleteJSON, hasTag, isUntagged, jsonReplacer, listJSONFiles, paginatedFileSystemQuery, readJSON, readJSONWithFallback, taggedPath, writeExclusive, } from '../fs.js';
 import { filterHookData } from './filters.js';
-import { hashToken, hookRecoveryMarkerPath } from './helpers.js';
+import { hashToken, hookRecoveryMarkerPath, isHookDisposalCommitted, releaseHookTokenClaimIfOwnedBy, } from './helpers.js';
+function isVisibleToTag(fileId, tag) {
+    return tag ? isUntagged(fileId) || hasTag(fileId, tag) : isUntagged(fileId);
+}
+function getHookCreatedToken(event) {
+    if (event.eventType !== 'hook_created')
+        return undefined;
+    const token = event.eventData.token;
+    return typeof token === 'string' ? token : undefined;
+}
+function hookFromCreatedEvent(event) {
+    const { token, metadata, isWebhook, isSystem } = event.eventData;
+    return {
+        runId: event.runId,
+        hookId: event.correlationId,
+        token,
+        metadata,
+        ownerId: 'local-owner',
+        projectId: 'local-project',
+        environment: 'local',
+        createdAt: event.createdAt,
+        specVersion: event.specVersion,
+        isWebhook: isWebhook ?? true,
+        isSystem: isSystem ?? false,
+    };
+}
+function isMatchingHookCreatedEvent(event, matches) {
+    return (event.eventType === 'hook_created' &&
+        typeof event.correlationId === 'string' &&
+        matches(event));
+}
+function closesLiveHook(event, liveEvent) {
+    if (event.runId !== liveEvent.runId)
+        return false;
+    return ((event.eventType === 'hook_disposed' &&
+        event.correlationId === liveEvent.correlationId) ||
+        isTerminalRunEventType(event.eventType));
+}
+async function readEventForHookScan(filePath) {
+    try {
+        return await readJSON(filePath, EventSchema);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error instanceof z.ZodError) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function isTerminalRunCache(basedir, runId, tag) {
+    const run = await readJSONWithFallback(basedir, 'runs', runId, WorkflowRunSchema, tag);
+    return run ? isTerminalWorkflowRunStatus(run.status) : false;
+}
+async function findLiveHookCreatedEvent(basedir, matches, tag) {
+    const eventsDir = path.join(basedir, 'events');
+    const events = [];
+    for (const fileId of await listJSONFiles(eventsDir)) {
+        if (!isVisibleToTag(fileId, tag))
+            continue;
+        const event = await readEventForHookScan(path.join(eventsDir, `${fileId}.json`));
+        if (event)
+            events.push(event);
+    }
+    events.sort((a, b) => {
+        const byTime = a.createdAt.getTime() - b.createdAt.getTime();
+        return byTime === 0 ? a.eventId.localeCompare(b.eventId) : byTime;
+    });
+    let liveEvent = null;
+    for (const event of events) {
+        if (isMatchingHookCreatedEvent(event, matches)) {
+            liveEvent = event;
+            continue;
+        }
+        if (liveEvent && closesLiveHook(event, liveEvent)) {
+            liveEvent = null;
+        }
+    }
+    if (liveEvent && (await isTerminalRunCache(basedir, liveEvent.runId, tag))) {
+        return null;
+    }
+    // A committed disposal (dispose lock on disk) closes the hook even when
+    // its `hook_disposed` event has not landed in the log yet — the disposer
+    // writes the lock, releases the token claim and hook entity, and only
+    // then appends the event. Rebuilding the caches from the log in that
+    // window would resurrect a claim for a hook that is being torn down.
+    if (liveEvent &&
+        (await isHookDisposalCommitted(basedir, liveEvent.correlationId, tag))) {
+        return null;
+    }
+    return liveEvent;
+}
+async function restoreHookCachesFromEvent(basedir, event, tag) {
+    const hook = hookFromCreatedEvent(event);
+    const claimPath = path.join(basedir, 'hooks', 'tokens', `${hashToken(hook.token)}.json`);
+    await writeExclusive(claimPath, JSON.stringify({
+        token: hook.token,
+        hookId: hook.hookId,
+        runId: hook.runId,
+        eventId: event.eventId,
+    }));
+    await writeExclusive(taggedPath(basedir, 'hooks', hook.hookId, tag), JSON.stringify(hook, jsonReplacer, 2));
+    return hook;
+}
+export async function rebuildLiveHookByTokenFromEventLog(basedir, token, tag) {
+    const event = await findLiveHookCreatedEvent(basedir, (candidate) => getHookCreatedToken(candidate) === token, tag);
+    return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;
+}
+async function rebuildLiveHookByIdFromEventLog(basedir, hookId, tag) {
+    const event = await findLiveHookCreatedEvent(basedir, (candidate) => candidate.correlationId === hookId, tag);
+    return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;
+}
 /**
  * Creates a hooks storage implementation using the filesystem.
  * Implements the Storage['hooks'] interface with hook CRUD operations.
@@ -27,13 +138,19 @@ export function createHooksStorage(basedir, tag) {
         assertSafeEntityId('hookId', hookId);
         const hook = await readJSONWithFallback(basedir, 'hooks', hookId, HookSchema, tag);
         if (!hook) {
-            throw new HookNotFoundError(hookId);
+            const rebuilt = await rebuildLiveHookByIdFromEventLog(basedir, hookId, tag);
+            if (!rebuilt) {
+                throw new HookNotFoundError(hookId);
+            }
+            const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
+            return filterHookData({ ...rebuilt, isWebhook: rebuilt.isWebhook ?? true }, resolveData);
         }
         const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
         return filterHookData({ ...hook, isWebhook: hook.isWebhook ?? true }, resolveData);
     }
     async function getByToken(token) {
-        const hook = await findHookByToken(token);
+        const hook = (await findHookByToken(token)) ??
+            (await rebuildLiveHookByTokenFromEventLog(basedir, token, tag));
         if (!hook) {
             throw new HookNotFoundError(token);
         }
@@ -83,17 +200,20 @@ export async function deleteAllHooksForRun(basedir, runId) {
         const hookPath = path.join(hooksDir, `${file}.json`);
         const hook = await readJSON(hookPath, HookSchema);
         if (hook && hook.runId === runId) {
-            // Delete the token constraint file to free up the token, and
-            // delete the recovery marker (if any) for disk hygiene. The
+            // Release the token claim to free up the token — but only if it
+            // still points at this hook: a claimant may have force-released
+            // the terminal run's stale claim already (see
+            // `isHookTokenClaimReleasable`) and hold a fresh claim of its
+            // own, which an unconditional delete would destroy. Also delete
+            // the recovery marker (if any) for disk hygiene. The
             // marker's filename hash includes `(token, runId, hookId)` so
             // a leaked marker can never corrupt a different lifetime — but
             // cleaning it up here keeps the tokens/ directory from
             // accumulating recovered-hook sidecars over time.
-            const constraintPath = path.join(hooksDir, 'tokens', `${hashToken(hook.token)}.json`);
-            await deleteJSON(constraintPath);
+            await releaseHookTokenClaimIfOwnedBy(basedir, hook.token, hook.runId, hook.hookId);
             await deleteJSON(hookRecoveryMarkerPath(basedir, hook.token, hook.runId, hook.hookId));
             await deleteJSON(hookPath);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks-storage.js","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { HookNotFoundError } from '@workflow/errors';\nimport type {\n  GetHookParams,\n  Hook,\n  ListHooksParams,\n  PaginatedResponse,\n  Storage,\n} from '@workflow/world';\nimport { HookSchema } from '@workflow/world';\nimport { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';\nimport {\n  assertSafeEntityId,\n  deleteJSON,\n  listJSONFiles,\n  paginatedFileSystemQuery,\n  readJSON,\n  readJSONWithFallback,\n} from '../fs.js';\nimport { filterHookData } from './filters.js';\nimport { hashToken, hookRecoveryMarkerPath } from './helpers.js';\n\n/**\n * Creates a hooks storage implementation using the filesystem.\n * Implements the Storage['hooks'] interface with hook CRUD operations.\n */\nexport function createHooksStorage(\n  basedir: string,\n  tag?: string\n): Storage['hooks'] {\n  // Helper function to find a hook by token (shared between getByToken)\n  async function findHookByToken(token: string): Promise<Hook | null> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const files = await listJSONFiles(hooksDir);\n\n    for (const file of files) {\n      const hookPath = path.join(hooksDir, `${file}.json`);\n      const hook = await readJSON(hookPath, HookSchema);\n      if (hook && hook.token === token) {\n        return { ...hook, isWebhook: hook.isWebhook ?? true };\n      }\n    }\n\n    return null;\n  }\n\n  async function get(hookId: string, params?: GetHookParams): Promise<Hook> {\n    assertSafeEntityId('hookId', hookId);\n    const hook = await readJSONWithFallback(\n      basedir,\n      'hooks',\n      hookId,\n      HookSchema,\n      tag\n    );\n    if (!hook) {\n      throw new HookNotFoundError(hookId);\n    }\n    const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n    return filterHookData(\n      { ...hook, isWebhook: hook.isWebhook ?? true },\n      resolveData\n    );\n  }\n\n  async function getByToken(token: string): Promise<Hook> {\n    const hook = await findHookByToken(token);\n    if (!hook) {\n      throw new HookNotFoundError(token);\n    }\n    return hook;\n  }\n\n  async function list(\n    params: ListHooksParams\n  ): Promise<PaginatedResponse<Hook>> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n\n    const result = await paginatedFileSystemQuery({\n      directory: hooksDir,\n      schema: HookSchema,\n      sortOrder: params.pagination?.sortOrder ?? 'asc',\n      limit: params.pagination?.limit,\n      cursor: params.pagination?.cursor,\n      filePrefix: undefined, // Hooks don't have ULIDs, so we can't optimize by filename\n      filter: (hook) => {\n        // Filter by runId if provided\n        if (params.runId && hook.runId !== params.runId) {\n          return false;\n        }\n        return true;\n      },\n      getCreatedAt: () => {\n        // Hook files don't have ULID timestamps in filename, so return null\n        // to skip the filename-based optimization and defer to JSON-based\n        // cursor filtering which uses the actual createdAt from the file.\n        return null;\n      },\n      getId: (hook) => hook.hookId,\n    });\n\n    // Transform the data after pagination\n    return {\n      ...result,\n      data: result.data.map((hook) => filterHookData(hook, resolveData)),\n    };\n  }\n\n  return { get, getByToken, list };\n}\n\n/**\n * Helper function to delete all hooks associated with a workflow run.\n * Called when a run reaches a terminal state.\n */\nexport async function deleteAllHooksForRun(\n  basedir: string,\n  runId: string\n): Promise<void> {\n  const hooksDir = path.join(basedir, 'hooks');\n  const files = await listJSONFiles(hooksDir);\n\n  for (const file of files) {\n    const hookPath = path.join(hooksDir, `${file}.json`);\n    const hook = await readJSON(hookPath, HookSchema);\n    if (hook && hook.runId === runId) {\n      // Delete the token constraint file to free up the token, and\n      // delete the recovery marker (if any) for disk hygiene. The\n      // marker's filename hash includes `(token, runId, hookId)` so\n      // a leaked marker can never corrupt a different lifetime — but\n      // cleaning it up here keeps the tokens/ directory from\n      // accumulating recovered-hook sidecars over time.\n      const constraintPath = path.join(\n        hooksDir,\n        'tokens',\n        `${hashToken(hook.token)}.json`\n      );\n      await deleteJSON(constraintPath);\n      await deleteJSON(\n        hookRecoveryMarkerPath(basedir, hook.token, hook.runId, hook.hookId)\n      );\n      await deleteJSON(hookPath);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks-storage.js","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { HookNotFoundError } from '@workflow/errors';\nimport type {\n  Event,\n  GetHookParams,\n  Hook,\n  HookCreatedEvent,\n  ListHooksParams,\n  PaginatedResponse,\n  Storage,\n} from '@workflow/world';\nimport {\n  EventSchema,\n  HookSchema,\n  isTerminalRunEventType,\n  isTerminalWorkflowRunStatus,\n  WorkflowRunSchema,\n} from '@workflow/world';\nimport { z } from 'zod';\nimport { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';\nimport {\n  assertSafeEntityId,\n  deleteJSON,\n  hasTag,\n  isUntagged,\n  jsonReplacer,\n  listJSONFiles,\n  paginatedFileSystemQuery,\n  readJSON,\n  readJSONWithFallback,\n  taggedPath,\n  writeExclusive,\n} from '../fs.js';\nimport { filterHookData } from './filters.js';\nimport {\n  hashToken,\n  hookRecoveryMarkerPath,\n  isHookDisposalCommitted,\n  releaseHookTokenClaimIfOwnedBy,\n} from './helpers.js';\n\nfunction isVisibleToTag(fileId: string, tag: string | undefined): boolean {\n  return tag ? isUntagged(fileId) || hasTag(fileId, tag) : isUntagged(fileId);\n}\n\nfunction getHookCreatedToken(event: Event): string | undefined {\n  if (event.eventType !== 'hook_created') return undefined;\n  const token = (event.eventData as { token?: unknown }).token;\n  return typeof token === 'string' ? token : undefined;\n}\n\nfunction hookFromCreatedEvent(event: Event & HookCreatedEvent): Hook {\n  const { token, metadata, isWebhook, isSystem } = event.eventData;\n  return {\n    runId: event.runId,\n    hookId: event.correlationId,\n    token,\n    metadata,\n    ownerId: 'local-owner',\n    projectId: 'local-project',\n    environment: 'local',\n    createdAt: event.createdAt,\n    specVersion: event.specVersion,\n    isWebhook: isWebhook ?? true,\n    isSystem: isSystem ?? false,\n  };\n}\n\nfunction isMatchingHookCreatedEvent(\n  event: Event,\n  matches: (event: Event) => boolean\n): event is Event & HookCreatedEvent {\n  return (\n    event.eventType === 'hook_created' &&\n    typeof event.correlationId === 'string' &&\n    matches(event)\n  );\n}\n\nfunction closesLiveHook(\n  event: Event,\n  liveEvent: Event & HookCreatedEvent\n): boolean {\n  if (event.runId !== liveEvent.runId) return false;\n  return (\n    (event.eventType === 'hook_disposed' &&\n      event.correlationId === liveEvent.correlationId) ||\n    isTerminalRunEventType(event.eventType)\n  );\n}\n\nasync function readEventForHookScan(filePath: string): Promise<Event | null> {\n  try {\n    return await readJSON(filePath, EventSchema);\n  } catch (error) {\n    if (error instanceof SyntaxError || error instanceof z.ZodError) {\n      return null;\n    }\n    throw error;\n  }\n}\n\nasync function isTerminalRunCache(\n  basedir: string,\n  runId: string,\n  tag?: string\n): Promise<boolean> {\n  const run = await readJSONWithFallback(\n    basedir,\n    'runs',\n    runId,\n    WorkflowRunSchema,\n    tag\n  );\n  return run ? isTerminalWorkflowRunStatus(run.status) : false;\n}\n\nasync function findLiveHookCreatedEvent(\n  basedir: string,\n  matches: (event: Event) => boolean,\n  tag?: string\n): Promise<(Event & HookCreatedEvent) | null> {\n  const eventsDir = path.join(basedir, 'events');\n  const events: Event[] = [];\n\n  for (const fileId of await listJSONFiles(eventsDir)) {\n    if (!isVisibleToTag(fileId, tag)) continue;\n    const event = await readEventForHookScan(\n      path.join(eventsDir, `${fileId}.json`)\n    );\n    if (event) events.push(event);\n  }\n\n  events.sort((a, b) => {\n    const byTime = a.createdAt.getTime() - b.createdAt.getTime();\n    return byTime === 0 ? a.eventId.localeCompare(b.eventId) : byTime;\n  });\n\n  let liveEvent: (Event & HookCreatedEvent) | null = null;\n  for (const event of events) {\n    if (isMatchingHookCreatedEvent(event, matches)) {\n      liveEvent = event;\n      continue;\n    }\n\n    if (liveEvent && closesLiveHook(event, liveEvent)) {\n      liveEvent = null;\n    }\n  }\n\n  if (liveEvent && (await isTerminalRunCache(basedir, liveEvent.runId, tag))) {\n    return null;\n  }\n\n  // A committed disposal (dispose lock on disk) closes the hook even when\n  // its `hook_disposed` event has not landed in the log yet — the disposer\n  // writes the lock, releases the token claim and hook entity, and only\n  // then appends the event. Rebuilding the caches from the log in that\n  // window would resurrect a claim for a hook that is being torn down.\n  if (\n    liveEvent &&\n    (await isHookDisposalCommitted(basedir, liveEvent.correlationId, tag))\n  ) {\n    return null;\n  }\n\n  return liveEvent;\n}\n\nasync function restoreHookCachesFromEvent(\n  basedir: string,\n  event: Event & HookCreatedEvent,\n  tag?: string\n): Promise<Hook> {\n  const hook = hookFromCreatedEvent(event);\n\n  const claimPath = path.join(\n    basedir,\n    'hooks',\n    'tokens',\n    `${hashToken(hook.token)}.json`\n  );\n  await writeExclusive(\n    claimPath,\n    JSON.stringify({\n      token: hook.token,\n      hookId: hook.hookId,\n      runId: hook.runId,\n      eventId: event.eventId,\n    })\n  );\n  await writeExclusive(\n    taggedPath(basedir, 'hooks', hook.hookId, tag),\n    JSON.stringify(hook, jsonReplacer, 2)\n  );\n\n  return hook;\n}\n\nexport async function rebuildLiveHookByTokenFromEventLog(\n  basedir: string,\n  token: string,\n  tag?: string\n): Promise<Hook | null> {\n  const event = await findLiveHookCreatedEvent(\n    basedir,\n    (candidate) => getHookCreatedToken(candidate) === token,\n    tag\n  );\n  return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;\n}\n\nasync function rebuildLiveHookByIdFromEventLog(\n  basedir: string,\n  hookId: string,\n  tag?: string\n): Promise<Hook | null> {\n  const event = await findLiveHookCreatedEvent(\n    basedir,\n    (candidate) => candidate.correlationId === hookId,\n    tag\n  );\n  return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;\n}\n\n/**\n * Creates a hooks storage implementation using the filesystem.\n * Implements the Storage['hooks'] interface with hook CRUD operations.\n */\nexport function createHooksStorage(\n  basedir: string,\n  tag?: string\n): Storage['hooks'] {\n  // Helper function to find a hook by token (shared between getByToken)\n  async function findHookByToken(token: string): Promise<Hook | null> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const files = await listJSONFiles(hooksDir);\n\n    for (const file of files) {\n      const hookPath = path.join(hooksDir, `${file}.json`);\n      const hook = await readJSON(hookPath, HookSchema);\n      if (hook && hook.token === token) {\n        return { ...hook, isWebhook: hook.isWebhook ?? true };\n      }\n    }\n\n    return null;\n  }\n\n  async function get(hookId: string, params?: GetHookParams): Promise<Hook> {\n    assertSafeEntityId('hookId', hookId);\n    const hook = await readJSONWithFallback(\n      basedir,\n      'hooks',\n      hookId,\n      HookSchema,\n      tag\n    );\n    if (!hook) {\n      const rebuilt = await rebuildLiveHookByIdFromEventLog(\n        basedir,\n        hookId,\n        tag\n      );\n      if (!rebuilt) {\n        throw new HookNotFoundError(hookId);\n      }\n      const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n      return filterHookData(\n        { ...rebuilt, isWebhook: rebuilt.isWebhook ?? true },\n        resolveData\n      );\n    }\n    const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n    return filterHookData(\n      { ...hook, isWebhook: hook.isWebhook ?? true },\n      resolveData\n    );\n  }\n\n  async function getByToken(token: string): Promise<Hook> {\n    const hook =\n      (await findHookByToken(token)) ??\n      (await rebuildLiveHookByTokenFromEventLog(basedir, token, tag));\n    if (!hook) {\n      throw new HookNotFoundError(token);\n    }\n    return hook;\n  }\n\n  async function list(\n    params: ListHooksParams\n  ): Promise<PaginatedResponse<Hook>> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n\n    const result = await paginatedFileSystemQuery({\n      directory: hooksDir,\n      schema: HookSchema,\n      sortOrder: params.pagination?.sortOrder ?? 'asc',\n      limit: params.pagination?.limit,\n      cursor: params.pagination?.cursor,\n      filePrefix: undefined, // Hooks don't have ULIDs, so we can't optimize by filename\n      filter: (hook) => {\n        // Filter by runId if provided\n        if (params.runId && hook.runId !== params.runId) {\n          return false;\n        }\n        return true;\n      },\n      getCreatedAt: () => {\n        // Hook files don't have ULID timestamps in filename, so return null\n        // to skip the filename-based optimization and defer to JSON-based\n        // cursor filtering which uses the actual createdAt from the file.\n        return null;\n      },\n      getId: (hook) => hook.hookId,\n    });\n\n    // Transform the data after pagination\n    return {\n      ...result,\n      data: result.data.map((hook) => filterHookData(hook, resolveData)),\n    };\n  }\n\n  return { get, getByToken, list };\n}\n\n/**\n * Helper function to delete all hooks associated with a workflow run.\n * Called when a run reaches a terminal state.\n */\nexport async function deleteAllHooksForRun(\n  basedir: string,\n  runId: string\n): Promise<void> {\n  const hooksDir = path.join(basedir, 'hooks');\n  const files = await listJSONFiles(hooksDir);\n\n  for (const file of files) {\n    const hookPath = path.join(hooksDir, `${file}.json`);\n    const hook = await readJSON(hookPath, HookSchema);\n    if (hook && hook.runId === runId) {\n      // Release the token claim to free up the token — but only if it\n      // still points at this hook: a claimant may have force-released\n      // the terminal run's stale claim already (see\n      // `isHookTokenClaimReleasable`) and hold a fresh claim of its\n      // own, which an unconditional delete would destroy. Also delete\n      // the recovery marker (if any) for disk hygiene. The\n      // marker's filename hash includes `(token, runId, hookId)` so\n      // a leaked marker can never corrupt a different lifetime — but\n      // cleaning it up here keeps the tokens/ directory from\n      // accumulating recovered-hook sidecars over time.\n      await releaseHookTokenClaimIfOwnedBy(\n        basedir,\n        hook.token,\n        hook.runId,\n        hook.hookId\n      );\n      await deleteJSON(\n        hookRecoveryMarkerPath(basedir, hook.token, hook.runId, hook.hookId)\n      );\n      await deleteJSON(hookPath);\n    }\n  }\n}\n"]}

package/dist/storage/index.d.ts

@@ -7,6 +7,7 @@ import { type LocalRunsStorage } from './runs-storage.js';
  */
 export type LocalStorage = Omit<Storage, 'runs'> & {
     runs: LocalRunsStorage;
+    clearCache(): void;
 };
 /**
  * Creates a complete storage implementation using the filesystem.

package/dist/storage/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI/C,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG7E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE9E;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,YAAY,CAezE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI/C,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG7E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG;IACjD,IAAI,EAAE,gBAAgB,CAAC;IACvB,UAAU,IAAI,IAAI,CAAC;CACpB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,YAAY,CAgBzE"}

package/dist/storage/index.js

@@ -25,6 +25,7 @@ export function createStorage(basedir, tag) {
         steps: instrumentObject('world.steps', steps),
         events: instrumentObject('world.events', events),
         hooks: instrumentObject('world.hooks', hooks),
+        clearCache: () => events.clearCache(),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/streamer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamer.d.ts","sourceRoot":"","sources":["../src/streamer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAsBzB;;;;;;GAMG;AACH,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAQD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,uBAG1C;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM;;;EAKlD;AA4DD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,QAAQ,CAwjBtE"}
+{"version":3,"file":"streamer.d.ts","sourceRoot":"","sources":["../src/streamer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAsBzB;;;;;;GAMG;AACH,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAQD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,uBAG1C;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM;;;EAKlD;AA0ED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,QAAQ,CAgkBtE"}