@mnemom/mnemom 0.17.34-next.2 → 0.17.34-next.4

package/dist/vendor/shared/durable-contract/states.js

@@ -51,7 +51,8 @@ export const SUSPENDED_REASONS = [
 ];
 /** breakglass is P0a-B; it stays in the enum so the CHECK never needs widening. */
 export const PAUSED_REASONS = ["owner", "agent_contained", "breakglass"];
-export const FAILED_REASONS = ["transcript_lost"];
+/** S1 amendment 59: runner_failed is a pool job's terminal failure, after its retries (doors.ts). */
+export const FAILED_REASONS = ["transcript_lost", "runner_failed"];
 export const KILLED_REASONS = ["agent_killed"];
 /**
  * The closed state_reason enum per state. `null` in a list means NULL is allowed there and what it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.34-next.2",
+  "version": "0.17.34-next.4",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {

package/dist/lib/durable/first-turn.d.ts

@@ -1,50 +0,0 @@
-/**
- * Lock after the first turn (ruling dogfood B5). A launch that locks a NEW Claude Code session
- * (`durable = always`, or ask answered yes, with no transcript yet) cannot lock before claude has
- * run: the daemon's seat resumes the session's transcript, and there is none until the first turn
- * writes it (host/transcript.ts ensureTranscript answers lost, the session fails transcript_lost).
- *
- * So the launcher spawns claude attended and watches the transcript. Once the first turn has
- * completed it locks, under the running-session handover (C02-R26: freeze, commit, the seat's
- * hello, then the original is killed and the parent attaches to the seat). Never before. A lock
- * refusal at that point leaves the attended session running and prints the refusal with its fix
- * line.
- *
- * No I/O here: lib/durable/live.ts wires the transcript reads, the lock and the clock.
- */
-import type { LockOutcome, TranscriptDirs } from "../../commands/durable-lock.js";
-import { DurableRefusal } from "./refusal.js";
-/** How often the launcher re-reads the transcript while it waits for the first turn. */
-export declare const FIRST_TURN_POLL_MS = 1000;
-/**
- * Whether a Claude Code transcript (JSONL) holds a completed turn: an assistant entry whose
- * stop_reason ends the turn (end_turn, max_tokens, stop_sequence, refusal), or the engine's own
- * turn-end record (system turn_duration or stop_hook_summary). Unparseable lines (a line still
- * being written) are skipped.
- */
-export declare function turnCompleted(jsonl: string): boolean;
-/**
- * Reads `<projects>/<dir>/<cc>.jsonl` from the first project dir that holds it; null while none
- * does, when it cannot be read (it is read again on the next poll), or with no CC session id.
- */
-export declare function transcriptReader(projects: string, dirs: TranscriptDirs, cc: string | null | undefined, read: (path: string) => string): () => string | null;
-export interface FirstTurnLockDeps {
-    /** The session name (the fix line of a lock that could not be sent). */
-    name: string;
-    /** The session's transcript text, or null while Claude Code has written none. */
-    readTranscript(): string | null;
-    /** The attended claude is still running. */
-    childAlive(): boolean;
-    /** The lock of the row under the running-session handover (lockResolvedRow). */
-    lock(): Promise<LockOutcome>;
-    /** Print a lock refusal and its fix line (the session stays attended). */
-    printRefusal(r: DurableRefusal): void;
-    sleep(ms: number): Promise<void>;
-}
-export type FirstTurnLock = "locked" | "refused" | "ended";
-/**
- * Wait for the first completed turn, then lock. "ended": claude exited first, nothing was locked.
- * "locked": the handover took the session (the parent's exit path attaches to the seat).
- * "refused": the refusal was printed and the attended session goes on.
- */
-export declare function lockAfterFirstTurn(d: FirstTurnLockDeps, pollMs?: number): Promise<FirstTurnLock>;

package/dist/lib/durable/first-turn.js

@@ -1,102 +0,0 @@
-/**
- * Lock after the first turn (ruling dogfood B5). A launch that locks a NEW Claude Code session
- * (`durable = always`, or ask answered yes, with no transcript yet) cannot lock before claude has
- * run: the daemon's seat resumes the session's transcript, and there is none until the first turn
- * writes it (host/transcript.ts ensureTranscript answers lost, the session fails transcript_lost).
- *
- * So the launcher spawns claude attended and watches the transcript. Once the first turn has
- * completed it locks, under the running-session handover (C02-R26: freeze, commit, the seat's
- * hello, then the original is killed and the parent attaches to the seat). Never before. A lock
- * refusal at that point leaves the attended session running and prints the refusal with its fix
- * line.
- *
- * No I/O here: lib/durable/live.ts wires the transcript reads, the lock and the clock.
- */
-import { join } from "node:path";
-import { DurableRefusal } from "./refusal.js";
-/** How often the launcher re-reads the transcript while it waits for the first turn. */
-export const FIRST_TURN_POLL_MS = 1000;
-/** An assistant stop that ends the turn: anything but a tool call or a paused turn. */
-const TURN_CONTINUES = new Set(["tool_use", "pause_turn"]);
-/**
- * Whether a Claude Code transcript (JSONL) holds a completed turn: an assistant entry whose
- * stop_reason ends the turn (end_turn, max_tokens, stop_sequence, refusal), or the engine's own
- * turn-end record (system turn_duration or stop_hook_summary). Unparseable lines (a line still
- * being written) are skipped.
- */
-export function turnCompleted(jsonl) {
-    for (const line of jsonl.split("\n")) {
-        let e;
-        try {
-            e = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (e === null || typeof e !== "object")
-            continue;
-        const r = e;
-        if (r.type === "system" && (r.subtype === "turn_duration" || r.subtype === "stop_hook_summary"))
-            return true;
-        if (r.type !== "assistant" || r.message === null || typeof r.message !== "object")
-            continue;
-        const stop = r.message.stop_reason;
-        if (typeof stop === "string" && !TURN_CONTINUES.has(stop))
-            return true;
-    }
-    return false;
-}
-/**
- * Reads `<projects>/<dir>/<cc>.jsonl` from the first project dir that holds it; null while none
- * does, when it cannot be read (it is read again on the next poll), or with no CC session id.
- */
-export function transcriptReader(projects, dirs, cc, read) {
-    return () => {
-        if (!cc)
-            return null;
-        const found = dirs(cc)?.[0];
-        if (found === undefined)
-            return null;
-        try {
-            return read(join(projects, found, `${cc}.jsonl`));
-        }
-        catch {
-            return null;
-        }
-    };
-}
-/**
- * Wait for the first completed turn, then lock. "ended": claude exited first, nothing was locked.
- * "locked": the handover took the session (the parent's exit path attaches to the seat).
- * "refused": the refusal was printed and the attended session goes on.
- */
-export async function lockAfterFirstTurn(d, pollMs = FIRST_TURN_POLL_MS) {
-    for (;;) {
-        if (!d.childAlive())
-            return "ended";
-        const t = d.readTranscript();
-        if (t !== null && turnCompleted(t))
-            break;
-        await d.sleep(pollMs);
-    }
-    let o;
-    try {
-        o = await d.lock();
-    }
-    catch (e) {
-        o = {
-            ok: false,
-            refusal: e instanceof DurableRefusal
-                ? e
-                : new DurableRefusal({
-                    code: "session_registry_unavailable",
-                    message: `mnemom agent: the lock after the first turn failed (${e instanceof Error ? e.message : String(e)}); the session stays attended`,
-                    fix: `\`mnemom agent lock ${d.name}\``,
-                }),
-        };
-    }
-    if (o.ok)
-        return "locked";
-    d.printRefusal(o.refusal);
-    return "refused";
-}