@ornexus/neocortex 4.59.1

package/packages/client/dist/yoloop/shared-yoloop-types.d.ts

@@ -0,0 +1,172 @@
+/**
+ * P117.07: Inlined byte-identical types from `@neocortex/shared/types/yoloop-persistence`
+ *          + `@neocortex/shared/yoloop/recovery-types` (RECOVERY_HISTORY_CAP).
+ *
+ * Same regression class as P117.01 (checkpoint inline). Mirrors P92.01 server
+ * SSoT-Shadow precedent — server `shared-types.ts` does the same for tier-config.
+ *
+ * Live regression: client tarball is published standalone via `@ornexus/neocortex`
+ * and does NOT include `@neocortex/shared` as a runtime dependency (workspace
+ * package, excluded from tarball per `.npmignore` + `tsconfig.build.json`). Any
+ * non-erased import of `@neocortex/shared` in `packages/client/dist/yoloop/**`
+ * causes runtime `ERR_MODULE_NOT_FOUND` on globally installed `@ornexus/neocortex`,
+ * silently disabling P101.06/P101.07 yoloop client state persistence (warning on
+ * every CLI invocation, fail-soft per design but feature effectively off).
+ *
+ * Sync responsibility: `yoloop-shared-sync.test.ts` (client-side drift test) +
+ * `shared-types-sync.test.ts` (server-side cross-package sanity, P92.03 baseline).
+ *
+ * Defense-in-depth: `validate-pre-publish.js` ships `validateClientNoSharedImport()`
+ * (P117.01 expanded by P117.07 to cover yoloop dist) — match = exit 1 (publish blocked).
+ *
+ * DO NOT EDIT WITHOUT also editing `packages/shared/src/types/yoloop-persistence.ts`
+ * + `packages/shared/src/yoloop/recovery-types.ts`.
+ */
+/** Mode under which yoloop was invoked. Mirrors server-internal `YoloopSessionMode`. */
+export type YoloopSessionMode = 'directory' | 'epic-file' | 'epic-id';
+export type YoloopLockOwnerKind = 'client' | 'server';
+export type YoloopLockOwnerPidState = 'live' | 'stale' | 'unknown';
+export type YoloopLockLeaseState = 'active' | 'expired' | 'unknown';
+/** Lock file payload. Mirrors server-internal `LockMetadata` (v1.1 schema). */
+export interface YoloopPersistedLock {
+    readonly pid: number;
+    readonly hostname: string;
+    /**
+     * Additive ownership marker. Missing means legacy/server-owned semantics:
+     * remote host locks are honored conservatively.
+     */
+    readonly ownerKind?: YoloopLockOwnerKind;
+    /**
+     * Request-scoped liveness classification produced by the client before
+     * echoing the snapshot. It is optional and may be omitted from persisted
+     * lock files.
+     */
+    readonly ownerPidState?: YoloopLockOwnerPidState;
+    /**
+     * Public-safe lease/session marker. Opaque; clients must not render local
+     * paths, hostnames, raw PID command lines, or other private machine details
+     * from it. Missing fields mean legacy v1.1 lock semantics.
+     */
+    readonly leaseId?: string;
+    readonly leaseState?: YoloopLockLeaseState;
+    readonly leaseAcquiredAt?: string;
+    readonly leaseDurationMs?: number;
+    readonly leaseExpiresAt?: string;
+    readonly startedAt: string;
+    readonly sessionId: string;
+    readonly mode: YoloopSessionMode;
+    readonly inputPath: string;
+    readonly epicQueue: readonly string[];
+    readonly currentEpicIndex: number;
+    readonly currentEpicId: string;
+    readonly ttlExpiresAt: string;
+    /** Backward-compat v1.0 mirror of `currentEpicId`. */
+    readonly epicId?: string;
+}
+/** Per-session block inside the state file. Mirrors server-internal `YoloopSession`. */
+export interface YoloopPersistedSession {
+    readonly mode: YoloopSessionMode;
+    readonly inputPath: string;
+    readonly epicQueue: readonly string[];
+    readonly currentEpicIndex: number;
+    readonly iterationsThisRun: number;
+    readonly startedAt: string;
+    readonly warnings: readonly string[];
+    /** P96.05 AC1: storyId -> strike count within THIS session. */
+    readonly failedStories?: Readonly<Record<string, number>>;
+    /** P96.05 AC8: storyId -> ISO timestamp of last failure (5min cool-down gate). */
+    readonly lastFailureAt?: Readonly<Record<string, string>>;
+    /** P96.05 AC2: storyIds marked `status='blocked'` in state.json this session. */
+    readonly blockedStories?: readonly string[];
+    /** P96.05 AC5: storyIds skipped due to `*yolo` timeout. */
+    readonly skippedStories?: readonly string[];
+}
+/**
+ * Forward-declared opaque reference to `YoloopRecoveryAttempt` (canonical lives
+ * in `@neocortex/shared/yoloop/recovery-types`). Structural mirror to avoid
+ * circular import. Drift enforced by `shared-types-sync.test.ts` (P104.06 block).
+ */
+export interface YoloopRecoveryAttemptRef {
+    readonly attempted_at: string;
+    readonly story_id: string;
+    readonly failure_category: string;
+    readonly recovery_trigger: string;
+    readonly recovery_step_id_tokenized: string;
+    readonly outcome: 'pending' | 'succeeded' | 'failed';
+    readonly finished_at: string | null;
+}
+/**
+ * Persistent counters block (everything except the lock).
+ * Mirrors server-internal `YoloopRuntimeState` minus lock-related fields.
+ */
+export interface YoloopPersistedCounters {
+    readonly version: '1.0' | '1.1';
+    readonly lastResetAt: string;
+    readonly storiesRunToday: number;
+    readonly iterationsToday: number;
+    readonly iterationsTodayDate: string;
+    readonly tokensUsedToday: number;
+    readonly lastRunAt: string | null;
+    readonly coolDownUntil: string | null;
+    readonly totalRunsAllTime: number;
+    readonly totalStoriesAllTime: number;
+    readonly currentSession: YoloopPersistedSession | null;
+    /**
+     * P104.06: FIFO bounded audit trail of self-healing recovery attempts.
+     * Optional for backward compat (clients pre-P104.06 omit the field; readers
+     * default to []). Cap enforced via `RECOVERY_HISTORY_CAP` below.
+     */
+    readonly recovery_history?: readonly YoloopRecoveryAttemptRef[];
+}
+/**
+ * Full yoloop state snapshot that the client echoes to the server on each
+ * invoke. `lock` is null when no run is in flight.
+ */
+export interface YoloopPersistedState {
+    readonly lock: YoloopPersistedLock | null;
+    readonly state: YoloopPersistedCounters;
+}
+/**
+ * Typed mutation operations the server returns for the client to apply.
+ * Clients apply operations in order, atomically. If any operation fails the
+ * client SHOULD NOT apply subsequent ones.
+ */
+export type YoloopStateOperation = {
+    readonly type: 'acquire_lock';
+    readonly lock: YoloopPersistedLock;
+} | {
+    readonly type: 'release_lock';
+} | {
+    readonly type: 'write_state';
+    readonly state: YoloopPersistedCounters;
+} | {
+    readonly type: 'advance_epic';
+    readonly nextEpicIndex: number;
+    readonly nextEpicId: string;
+} | {
+    readonly type: 'no_op';
+} | {
+    readonly type: 'recovery_attempted';
+    readonly attempt: YoloopRecoveryAttemptRef;
+} | {
+    readonly type: 'recovery_resolved';
+    readonly attempt_id: string;
+    readonly outcome: 'succeeded' | 'failed';
+    readonly evidence?: string;
+};
+/**
+ * Server -> client update contract. Client applies `operations` in order to
+ * its local yoloop state store.
+ */
+export interface YoloopStateUpdate {
+    readonly operations: ReadonlyArray<YoloopStateOperation>;
+    readonly lock?: YoloopPersistedLock | null;
+    readonly state?: YoloopPersistedCounters;
+}
+/**
+ * P104.06 -- FIFO cap for `state.recovery_history[]` in
+ * `.neocortex/yoloop-state.json`. When the array exceeds this size, the
+ * client drops oldest entries. Bound is heuristic: ~50 attempts × ~300
+ * bytes/entry = ~15 KB worst case in state.json (negligible).
+ */
+export declare const RECOVERY_HISTORY_CAP = 50;

package/packages/client/dist/yoloop/shared-yoloop-types.js

@@ -0,0 +1 @@
+const R=50;export{R as RECOVERY_HISTORY_CAP};

package/packages/client/dist/yoloop/yoloop-client-state-store.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Epic P101.06 -- YoloopClientStateStore.
+ *
+ * Client-side counterpart of the (soon-to-be-deleted) server YoloopStateStore.
+ * Owns `.neocortex/yoloop.lock` and `.neocortex/yoloop-state.json` in the
+ * user's local project workspace.
+ *
+ * The client is the ONLY filesystem writer for yoloop state after P101
+ * lands. The server is pure: it reads state echoed by the client via
+ * `stateSnapshot.yoloop` and returns `metadata.yoloopStateUpdate` with an
+ * operation log the client applies here.
+ *
+ * Atomicity guarantees (P96.03):
+ *   - acquireLock uses fs.open(... 'wx') -- POSIX exclusive create
+ *   - writeState uses tmp + rename (POSIX atomic rename)
+ *
+ * Fail-open philosophy (P61.04 / P66.01):
+ *   - chmod / ACL failure -> warn log, NEVER blocks operation
+ *   - release on missing lock is idempotent (no-op)
+ *   - readAll returns defaults on any I/O or parse error
+ *
+ * Cross-platform: Unix chmod + Windows icacls via existing
+ * setSecureFilePermissions helper from secure-config.ts.
+ */
+import type { YoloopPersistedCounters, YoloopPersistedState, YoloopRecoveryAttemptRef, YoloopStateUpdate } from './shared-yoloop-types.js';
+/** Minimal Pino-compatible logger subset. */
+export interface ClientYoloopLogger {
+    warn(payload: object, msg?: string): void;
+    info(payload: object, msg?: string): void;
+    error(payload: object, msg?: string): void;
+}
+/** Build default counters for a fresh project (no state file present). */
+export declare function createDefaultCounters(nowIso: string): YoloopPersistedCounters;
+/** Build default state envelope (no lock, default counters). */
+export declare function createDefaultState(nowIso: string): YoloopPersistedState;
+export declare class YoloopClientStateStore {
+    private readonly stateDir;
+    private readonly statePath;
+    private readonly lockPath;
+    private readonly logger;
+    constructor(projectRoot: string, logger?: ClientYoloopLogger);
+    /**
+     * Read lock + state in a single call. Used by invoke.ts pre-request hook
+     * to populate `stateSnapshot.yoloop` for the server. Handles ENOENT
+     * gracefully by returning default state.
+     */
+    readAll(nowIso?: string): Promise<YoloopPersistedState>;
+    /**
+     * Apply server-provided operations in order. Called by invoke.ts
+     * post-response hook. Operations are applied atomically per-op; if one
+     * fails, subsequent ops are NOT applied and the caller (invoke.ts)
+     * decides whether to log-and-continue or abort.
+     *
+     * Contract: partial application is safe because each operation is a
+     * single atomic filesystem mutation. Next invoke's readAll() reconciles.
+     */
+    applyUpdate(update: YoloopStateUpdate, nowIso?: string): Promise<void>;
+    private applyOperation;
+    /**
+     * Append a new recovery attempt to `state.recovery_history[]`. FIFO cap
+     * via `capRecoveryHistory`. Idempotent against retry storms: duplicate
+     * (story_id + attempted_at) entries are skipped with a warn log.
+     */
+    private appendRecoveryAttempt;
+    /**
+     * Resolve a pending recovery attempt by tokenized step id. Updates
+     * `outcome` and stamps `finished_at`. If the attempt was already evicted
+     * by the FIFO cap or never existed, emits a warn log (`recovery_resolve_orphan`)
+     * but does not throw -- bound state cap is a deliberate trade-off.
+     */
+    private resolveRecoveryAttempt;
+    /**
+     * Atomically acquire the yoloop lock. On EEXIST, performs PID liveness
+     * check (same-host) and retries once if orphan detected. Cross-host
+     * locks are honored (cannot signal across hosts).
+     *
+     * The server's `acquire_lock` operation provides the lock payload; we
+     * overwrite the `pid` and `hostname` fields with OUR values (the client
+     * is the authoritative writer of pid/hostname; server can't know them).
+     */
+    private acquireLock;
+    /** Release the lock. Idempotent (ENOENT swallowed). */
+    private releaseLock;
+    /** Read lock file. Returns null on ENOENT / parse error. */
+    private readLock;
+    /** Read state file; returns defaults on any I/O or parse error. */
+    private readState;
+    /** Atomic state write: temp + rename. */
+    private writeState;
+    /**
+     * Advance to next epic: read-modify-write on currentSession.currentEpicIndex.
+     * Fail-open if no active session (logs warn; subsequent *yoloop will
+     * emit a fresh acquire_lock).
+     */
+    private advanceEpic;
+    private ensureDir;
+    /**
+     * Fire-and-forget chmod/ACL. Uses sync helpers from secure-config.ts
+     * which are fail-open by contract (never throw).
+     */
+    private trySetFilePerms;
+    private trySetDirPerms;
+    /**
+     * Normalize a lock before echoing it to the server. The local client can
+     * check PID liveness for client-owned same-host locks; the server cannot.
+     */
+    private prepareLockForSnapshot;
+    /**
+     * If the existing lock is held by a dead PID on the same host, delete
+     * it and return true (caller retries acquisition). Otherwise return
+     * false (honor the lock).
+     */
+    private maybeRecoverOrphanLock;
+    private deleteLockBestEffort;
+    private isSameClientSessionLock;
+    /** Remove `yoloop-state.json.tmp.*` orphans from crashed writes. */
+    private cleanupOrphanTempFiles;
+}
+/**
+ * Enforce FIFO bound on `recovery_history[]`. Returns a new array of length
+ * <= `RECOVERY_HISTORY_CAP`, preserving the most recent entries (drops from
+ * head). Pure: input is not mutated.
+ */
+export declare function capRecoveryHistory(history: readonly YoloopRecoveryAttemptRef[]): readonly YoloopRecoveryAttemptRef[];

package/packages/client/dist/yoloop/yoloop-client-state-store.js

@@ -0,0 +1 @@
+import{promises as a}from"node:fs";import{join as p,dirname as g}from"node:path";import{hostname as h}from"node:os";import{setSecureFilePermissions as k,setSecureDirPermissions as m}from"../config/secure-config.js";import{RECOVERY_HISTORY_CAP as y}from"./shared-yoloop-types.js";const S=".neocortex",_="yoloop-state.json",A="yoloop.lock",E=360*60*1e3,D={warn:()=>{},info:()=>{},error:()=>{}};function u(i){const t=i.slice(0,10);return{version:"1.1",lastResetAt:i,storiesRunToday:0,iterationsToday:0,iterationsTodayDate:t,tokensUsedToday:0,lastRunAt:null,coolDownUntil:null,totalRunsAllTime:0,totalStoriesAllTime:0,currentSession:null}}function q(i){return{lock:null,state:u(i)}}class b{stateDir;statePath;lockPath;logger;constructor(t,e=D){this.stateDir=p(t,S),this.statePath=p(this.stateDir,_),this.lockPath=p(this.stateDir,A),this.logger=e}async readAll(t){const e=t??new Date().toISOString();await this.cleanupOrphanTempFiles();const[r,o]=await Promise.all([this.readLock(),this.readState(e)]);return{lock:await this.prepareLockForSnapshot(r,e),state:o}}async applyUpdate(t,e){const r=e??new Date().toISOString();await this.ensureDir();for(const o of t.operations)await this.applyOperation(o,r)}async applyOperation(t,e){switch(t.type){case"acquire_lock":await this.acquireLock(t.lock,e);return;case"release_lock":await this.releaseLock();return;case"write_state":await this.writeState(t.state);return;case"advance_epic":await this.advanceEpic(t.nextEpicIndex,t.nextEpicId,e);return;case"no_op":this.logger.info({event:"yoloop_noop"},"yoloop server sent no-op");return;case"recovery_attempted":await this.appendRecoveryAttempt(t.attempt,e);return;case"recovery_resolved":await this.resolveRecoveryAttempt(t.attempt_id,t.outcome,e);return;default:{const r=t;this.logger.warn({event:"yoloop_unknown_op",op:r},"unknown yoloop operation; skipping");return}}}async appendRecoveryAttempt(t,e){const r=await this.readState(e),o=r.recovery_history??[];if(o.some(l=>l.attempted_at===t.attempted_at&&l.story_id===t.story_id)){this.logger.warn({event:"recovery_attempted_duplicate",story_id:t.story_id},"duplicate recovery_attempted op; skipping");return}const n=w([...o,t]),c={...r,recovery_history:n};await this.writeState(c),this.logger.info({event:"recovery_attempted_persisted",story_id:t.story_id,history_size:n.length},"recovery attempt persisted")}async resolveRecoveryAttempt(t,e,r){const o=await this.readState(r),s=o.recovery_history??[],n=s.findIndex(v=>v.recovery_step_id_tokenized===t);if(n===-1){this.logger.warn({event:"recovery_resolve_orphan",attempt_id:t},"recovery_resolved op had no matching attempt; skipping");return}const c=s[n];if(c.outcome===e&&c.finished_at){this.logger.info({event:"recovery_resolved_duplicate",attempt_id:t,outcome:e},"duplicate recovery_resolved op; skipping");return}const l=s.slice();l[n]={...c,outcome:e,finished_at:r};const d={...o,recovery_history:l};await this.writeState(d),this.logger.info({event:"recovery_resolved_persisted",attempt_id:t,outcome:e},"recovery attempt resolved")}async acquireLock(t,e){const r={...t,pid:process.pid,hostname:h(),ownerKind:"client",startedAt:t.startedAt||e,leaseId:t.leaseId??P(t.sessionId,e),leaseState:"active",leaseAcquiredAt:t.leaseAcquiredAt??e,leaseDurationMs:t.leaseDurationMs??E,leaseExpiresAt:t.leaseExpiresAt??t.ttlExpiresAt},o=JSON.stringify(r,null,2);try{const s=await a.open(this.lockPath,"wx");try{await s.writeFile(o,"utf8")}finally{await s.close()}this.trySetFilePerms(this.lockPath),this.logger.info({event:"yoloop_lock_acquired",pid:r.pid,sessionId:r.sessionId},"yoloop lock acquired");return}catch(s){const n=s;if(n.code!=="EEXIST")throw this.logger.error({event:"yoloop_lock_acquire_error",err:n.message},"failed to acquire yoloop lock"),s;const c=await this.readLock();if(c&&this.isSameClientSessionLock(c,r)){this.logger.info({event:"yoloop_lock_acquire_duplicate",sessionId:r.sessionId},"duplicate acquire_lock for current yoloop session; treating as no-op");return}if(!await this.maybeRecoverOrphanLock(e))throw this.logger.warn({event:"yoloop_lock_held"},"yoloop lock held by another live process"),s;const d=await a.open(this.lockPath,"wx");try{await d.writeFile(o,"utf8")}finally{await d.close()}this.trySetFilePerms(this.lockPath),this.logger.info({event:"yoloop_lock_acquired_after_recovery",pid:r.pid},"yoloop lock acquired after orphan recovery")}}async releaseLock(){try{await a.unlink(this.lockPath),this.logger.info({event:"yoloop_lock_released"},"yoloop lock released")}catch(t){const e=t;if(e.code==="ENOENT"){this.logger.info({event:"yoloop_lock_release_noop"},"yoloop lock release noop (file absent)");return}this.logger.warn({event:"yoloop_lock_release_error",err:e.message},"unexpected error releasing yoloop lock")}}async readLock(){try{const t=await a.readFile(this.lockPath,"utf8"),e=JSON.parse(t),r=e.currentEpicId??e.epicId??"";return{pid:e.pid??0,hostname:e.hostname??"",...e.ownerKind?{ownerKind:e.ownerKind}:{},...e.ownerPidState?{ownerPidState:e.ownerPidState}:{},...typeof e.leaseId=="string"?{leaseId:e.leaseId}:{},...e.leaseState?{leaseState:e.leaseState}:{},...typeof e.leaseAcquiredAt=="string"?{leaseAcquiredAt:e.leaseAcquiredAt}:{},...typeof e.leaseDurationMs=="number"?{leaseDurationMs:e.leaseDurationMs}:{},...typeof e.leaseExpiresAt=="string"?{leaseExpiresAt:e.leaseExpiresAt}:{},startedAt:e.startedAt??"",sessionId:e.sessionId??"",mode:e.mode??"epic-id",inputPath:e.inputPath??"",epicQueue:e.epicQueue??(r?[r]:[]),currentEpicIndex:e.currentEpicIndex??0,currentEpicId:r,ttlExpiresAt:e.ttlExpiresAt??"",epicId:e.epicId??r}}catch{return null}}async readState(t){try{const e=await a.readFile(this.statePath,"utf8"),r=JSON.parse(e);return L(r,t)}catch(e){const r=e;return r.code!=="ENOENT"&&this.logger.warn({event:"yoloop_state_read_error",err:r.message},"yoloop state file unreadable; using defaults"),u(t)}}async writeState(t){const e=`${this.statePath}.tmp.${process.pid}.${Date.now()}`,r=JSON.stringify(t,null,2);try{await a.writeFile(e,r,"utf8"),this.trySetFilePerms(e),await a.rename(e,this.statePath)}catch(o){const s=o;this.logger.error({event:"yoloop_state_write_error",err:s.message},"failed to write yoloop state");try{await a.unlink(e)}catch{}throw o}}async advanceEpic(t,e,r){const o=await this.readState(r);if(!o.currentSession){this.logger.warn({event:"yoloop_advance_no_session",nextEpicId:e},"advance_epic with no active session; skipping");return}const s={...o,currentSession:{...o.currentSession,currentEpicIndex:t}};await this.writeState(s),this.logger.info({event:"yoloop_epic_advance",nextEpicId:e,nextIndex:t},"yoloop advanced to next epic")}async ensureDir(){try{await a.mkdir(this.stateDir,{recursive:!0}),this.trySetDirPerms(this.stateDir)}catch(t){const e=t;throw this.logger.error({event:"yoloop_mkdir_error",err:e.message,path:this.stateDir},"failed to ensure .neocortex/ directory"),t}}trySetFilePerms(t){try{k(t)}catch{}}trySetDirPerms(t){try{m(t)}catch{}}async prepareLockForSnapshot(t,e){if(!t)return null;if(t.ownerKind!=="client")return t;const r=f(t,e),o={...t,leaseState:r};if(r==="expired")return await this.deleteLockBestEffort(),this.logger.warn({event:"yoloop_client_lock_recovered",reason:"lease_expired"},"expired client-owned yoloop lock lease recovered before snapshot echo"),null;if(!o.pid||o.pid<=0)return await this.deleteLockBestEffort(),this.logger.warn({event:"yoloop_client_lock_recovered",reason:"invalid_pid"},"invalid PID in client-owned yoloop lock; recovered"),null;if(o.hostname&&o.hostname!==h())return{...o,ownerPidState:"unknown"};try{return process.kill(o.pid,0),{...o,ownerPidState:"live"}}catch{return await this.deleteLockBestEffort(),this.logger.warn({event:"yoloop_client_lock_recovered",reason:"dead_pid"},"stale client-owned yoloop lock recovered before snapshot echo"),null}}async maybeRecoverOrphanLock(t){const e=await this.readLock();if(!e)return!0;if(f(e,t)==="expired")return await this.deleteLockBestEffort(),this.logger.warn({event:"yoloop_orphan_lock_recovered",reason:"lease_expired"},"expired yoloop lock lease recovered"),!0;if(!e.pid||e.pid<=0)return await this.deleteLockBestEffort(),this.logger.warn({event:"yoloop_orphan_lock_recovered",reason:"invalid_pid"},"invalid PID in lock file; recovered"),!0;if(e.hostname&&e.hostname!==h())return this.logger.warn({event:"yoloop_lock_remote_host",ownerKind:e.ownerKind??"server",ownerPidState:"unknown"},"lock held by a remote host; honoring"),!1;try{return process.kill(e.pid,0),!1}catch{return await this.deleteLockBestEffort(),this.logger.warn({event:"yoloop_orphan_lock_recovered",reason:"dead_pid"},"orphan yoloop lock recovered"),!0}}async deleteLockBestEffort(){try{await a.unlink(this.lockPath)}catch{}}isSameClientSessionLock(t,e){return t.ownerKind==="client"&&t.sessionId===e.sessionId&&t.pid===process.pid&&t.hostname===h()}async cleanupOrphanTempFiles(){try{const t=g(this.statePath),e=await a.readdir(t),r=`${_}.tmp.`,o=e.filter(s=>s.startsWith(r));for(const s of o)try{await a.unlink(p(t,s))}catch{}}catch{}}}function P(i,t){return`lease-${x(`${i}:${t}`)}`}function x(i){let t=2166136261;for(let e=0;e<i.length;e+=1)t^=i.charCodeAt(e),t=Math.imul(t,16777619)>>>0;return t.toString(36).padStart(7,"0")}function f(i,t){const e=i.leaseExpiresAt??i.ttlExpiresAt,r=Date.parse(e),o=Date.parse(t);return!Number.isFinite(r)||!Number.isFinite(o)?"unknown":r<=o?"expired":"active"}function L(i,t){const e=u(t);return{version:"1.1",lastResetAt:i.lastResetAt??e.lastResetAt,storiesRunToday:i.storiesRunToday??0,iterationsToday:i.iterationsToday??0,iterationsTodayDate:i.iterationsTodayDate??e.iterationsTodayDate,tokensUsedToday:i.tokensUsedToday??0,lastRunAt:i.lastRunAt??null,coolDownUntil:i.coolDownUntil??null,totalRunsAllTime:i.totalRunsAllTime??0,totalStoriesAllTime:i.totalStoriesAllTime??0,currentSession:i.currentSession??null,recovery_history:Array.isArray(i.recovery_history)?w(i.recovery_history):[]}}function w(i){return i.length<=y?i:i.slice(i.length-y)}export{b as YoloopClientStateStore,w as capRecoveryHistory,u as createDefaultCounters,q as createDefaultState};