@theokit/agents 7.6.0 → 8.1.0

package/dist/session.d.ts

@@ -0,0 +1,238 @@
+import { TheokitAgentError } from '@theokit/sdk/errors';
+
+/**
+ * M71 — the session LIFECYCLE vocabulary: list, delete, protect, fork.
+ *
+ * ## Why this module exists, and what it deliberately is not
+ *
+ * The store is fully supplied — 29 pass-throughs under `/persistence` cover paths, atomic writes,
+ * locks and artifact classification. What had no home was the vocabulary ABOVE them: listing,
+ * deleting with a live-session guard, forking, going back before a turn.
+ *
+ * The named risk was that absorbing lifecycle reads as owning the store (G2). The separation is
+ * real and this module is where it is drawn: **owning the vocabulary is not owning the store.**
+ * Nothing here writes a transcript. Every file operation is either a delete of something the caller
+ * named, or a delegation to an SDK primitive. The knowledge added is which files are protected and
+ * what "delete a session" means — decisions, not storage.
+ *
+ * ## The asymmetry that made the gap a trap
+ *
+ * `Agent.delete` clears the REGISTRY ENTRY and never touches the transcript on disk. A consumer had
+ * to discover that by measuring. {@link deleteSession} is the answer: it returns
+ * `{ registryRemoved, transcriptRemoved }` so the two are impossible to confuse, and a caller that
+ * wanted both and got one can see it.
+ */
+/** Raised when a lifecycle operation is refused because the session is live. */
+declare class SessionInUseError extends TheokitAgentError {
+    readonly sessionId: string;
+    /** Why it is protected — a writer lease, the resumable pointer, or being the most recent. */
+    readonly reason: string;
+    readonly name = "SessionInUseError";
+    constructor(sessionId: string, 
+    /** Why it is protected — a writer lease, the resumable pointer, or being the most recent. */
+    reason: string);
+}
+/** One session as the lifecycle vocabulary sees it. */
+interface SessionSummary {
+    readonly id: string;
+    /** Absolute path of the transcript file. */
+    readonly transcript: string;
+    /** Last modification, for recency ordering. */
+    readonly modifiedAt: Date;
+}
+/**
+ * Sessions with a transcript under `cwd`'s project directory, most recent first.
+ *
+ * Uses `classifySessionArtifact` rather than matching file names here: the SDK owns what a file in a
+ * project directory IS, and a second matcher would answer differently the day the layout changes —
+ * silently, on a path whose purpose is deleting things.
+ */
+declare function listSessions(cwd: string, root?: string): SessionSummary[];
+/**
+ * Transcripts that must NOT be collected: the resumable pointer's target, the most recent session,
+ * and anything holding a writer lease.
+ *
+ * Three reasons, deliberately not collapsed into a boolean. A caller reporting "skipped 4 sessions"
+ * is far less useful than one reporting why each was skipped, and retention policy is exactly where
+ * an operator asks that question.
+ */
+declare function protectedTranscripts(cwd: string, root?: string): Map<string, string>;
+/** What `deleteSession` did, per store. */
+interface DeleteSessionResult {
+    /** Whether a registry entry was removed. */
+    readonly registryRemoved: boolean;
+    /** Whether the transcript file was removed. */
+    readonly transcriptRemoved: boolean;
+}
+interface DeleteSessionOptions {
+    readonly cwd: string;
+    readonly root?: string;
+    /** Delete even when protected. The refusal is the default because the damage is unrecoverable. */
+    readonly force?: boolean;
+    /** Remove the registry entry too. Injected (DIP) — the registry is the runtime's, not ours. */
+    readonly removeFromRegistry?: (sessionId: string) => boolean;
+}
+/**
+ * Delete a session, refusing by default when it is protected.
+ *
+ * The two stores are reported separately because they genuinely are separate — `Agent.delete`
+ * touches only the registry, and a caller that assumed otherwise would leave the transcript behind
+ * believing it gone. Returning one boolean would rebuild that confusion inside this function.
+ *
+ * @throws {SessionInUseError} when the session is protected and `force` is not set.
+ */
+declare function deleteSession(sessionId: string, options: DeleteSessionOptions): DeleteSessionResult;
+/**
+ * Fork `srcId` into `newId`, keeping everything BEFORE the `nth` user turn.
+ *
+ * Delegates the copy to the SDK's `forkTranscript` — the truncation rule is the SDK's knowledge and
+ * re-deriving it here would give two answers to "where does a turn begin".
+ *
+ * `nth` is 1-based, matching how a person counts turns out loud. A 0-based index here would be a
+ * silent off-by-one on a destructive-feeling operation.
+ */
+declare function forkBeforeUserTurn(srcId: string, newId: string, nth: number, options: {
+    readonly cwd: string;
+    readonly root?: string;
+}): {
+    readonly transcript: string;
+    readonly recordIndex: number;
+};
+
+/** Where the pointer for `cwd` lives. */
+declare function sessionPointerPath(cwd: string, root?: string): string;
+/**
+ * The session id to resume for `cwd`, or a freshly minted one when there is nothing to resume.
+ *
+ * Never rejects. A missing, empty or unreadable pointer all mean the same thing to the caller —
+ * "start a new session" — and distinguishing them would only give the caller three ways to write
+ * the same branch.
+ *
+ * @param mintId how to create an id when there is nothing to resume. Injected (DIP) so the caller
+ * owns id shape and the tests are deterministic — a `crypto.randomUUID()` baked in here would make
+ * every assertion about the fresh path unwritable.
+ */
+declare function loadOrCreateSessionId(cwd: string, mintId: () => string, root?: string): {
+    readonly sessionId: string;
+    readonly resumed: boolean;
+};
+/**
+ * Point `cwd` at `sessionId`, atomically.
+ *
+ * Delegates to `atomicWriteText`, so a reader never observes a half-written pointer.
+ *
+ * The first draft reached for `atomicWriteTempTarget` instead, which was a misreading worth
+ * recording: that function does not GENERATE a temp name, it RECOGNISES one and answers which final
+ * file it belongs to. It is the collector's question ("is this scratch, and whose?"), not the
+ * writer's. Its return type — `string | undefined` — is what said so, and the typechecker refused
+ * the misuse before it could ship.
+ *
+ * Returns `{ persisted }` instead of throwing (see the module docblock). The failure is reported,
+ * not hidden.
+ *
+ * ASYNC because `atomicWriteText` is. The first draft called it synchronously and returned
+ * `{ persisted: true }` before the bytes landed — so the function reported a success that had not
+ * happened yet, and a read immediately after found nothing. The tests caught it; a caller would
+ * have caught it as an intermittently missing `--continue`.
+ */
+declare function persistSessionId(cwd: string, sessionId: string, root?: string): Promise<{
+    readonly persisted: boolean;
+}>;
+
+/** Absolute path of the project directory for `cwd`, under the transcript root. */
+declare function projectDirFor(cwd: string, root?: string): string;
+/**
+ * Record that `cwd` is the project behind its encoded directory.
+ *
+ * Idempotent and best-effort by design: this is an index, and a machine that cannot write it should
+ * still be able to run an agent. A throw here would turn a missing optimisation into a failed run.
+ */
+declare function recordProjectDir(cwd: string, root?: string): void;
+/**
+ * The cwd behind an encoded project directory name, or `undefined` when this layer never saw it.
+ *
+ * `undefined` is NOT "the project is gone". It is "no sidecar here", which a project created before
+ * this index existed also produces. A caller that treated the two as the same would delete live
+ * projects — which is precisely why the distinction is stated rather than left to the reader.
+ */
+declare function resolveProjectDir(encodedName: string, root?: string): string | undefined;
+/**
+ * Whether `encodedName` is the encoding of `cwd`.
+ *
+ * The verification that makes the index trustworthy rather than merely convenient: a sidecar can be
+ * stale (the directory was renamed) and re-encoding is the cheap way to notice. It is also the whole
+ * of the `classifyProject` oracle the milestone offered as the alternative — kept as a companion to
+ * the index rather than a replacement, because it can only confirm a cwd the caller already has.
+ */
+declare function projectDirMatches(encodedName: string, cwd: string): boolean;
+
+/** Raised when a retention knob is below its floor. Refusing beats clamping — see invariant 1. */
+declare class GCFloorError extends TheokitAgentError {
+    readonly field: 'keepLast' | 'maxAgeDays';
+    readonly received: number;
+    readonly name = "GCFloorError";
+    constructor(field: 'keepLast' | 'maxAgeDays', received: number);
+}
+/** A transcript the policy would collect. */
+interface GCCandidate {
+    readonly id: string;
+    readonly transcript: string;
+    readonly modifiedAt: Date;
+}
+/** A transcript the policy keeps, and why. */
+interface GCKept {
+    readonly id: string;
+    /** Human-readable protection reason — recency, policy, lease, or unreadable age. */
+    readonly reason: string;
+}
+interface TranscriptGCOptions {
+    readonly cwd: string;
+    /** Newest N sessions always survive. Floor: 1 — a project with none has nothing to `--continue`. */
+    readonly keepLast: number;
+    /** Only sessions older than this may be collected. Floor: 1. */
+    readonly maxAgeDays: number;
+    readonly root?: string;
+    /** Injected clock (DIP) — a live `Date.now()` makes every age assertion depend on run speed. */
+    readonly now?: number;
+}
+interface TranscriptGCPlan {
+    readonly cwd: string;
+    readonly root: string;
+    readonly candidates: readonly GCCandidate[];
+    readonly kept: readonly GCKept[];
+}
+/**
+ * Decide what a retention policy would collect, without touching anything.
+ *
+ * Both conditions must hold for a transcript to be a candidate: beyond `keepLast` in recency order
+ * AND older than `maxAgeDays`. Age alone would delete a project's whole recent history the moment it
+ * exceeded the count; count alone would delete yesterday's work on a busy project.
+ *
+ * @throws {GCFloorError} when a knob is below its floor (invariant 1).
+ */
+declare function planTranscriptGC(options: TranscriptGCOptions): TranscriptGCPlan;
+/** What one candidate's removal did, or why it did not. */
+interface GCError {
+    readonly id: string;
+    readonly message: string;
+}
+interface RunTranscriptGCResult {
+    readonly dryRun: boolean;
+    /** Ids that were (or, in a dry run, would be) removed. */
+    readonly removed: readonly string[];
+    /** One entry per candidate that failed — the rest still ran. */
+    readonly errors: readonly GCError[];
+}
+/**
+ * Execute a plan. `apply: false` reports what would happen and changes nothing.
+ *
+ * Errors accumulate PER CANDIDATE (fail-open): one undeletable file must not leave the rest of the
+ * disk uncollected, and the operator must still learn which one failed. `ENOENT` counts as success —
+ * absent is the desired end state, and reporting it as failure would make the second run of an
+ * interrupted GC look broken.
+ */
+declare function runTranscriptGC(plan: TranscriptGCPlan, options: {
+    readonly apply: boolean;
+}): RunTranscriptGCResult;
+
+export { type DeleteSessionOptions, type DeleteSessionResult, type GCCandidate, type GCError, GCFloorError, type GCKept, type RunTranscriptGCResult, SessionInUseError, type SessionSummary, type TranscriptGCOptions, type TranscriptGCPlan, deleteSession, forkBeforeUserTurn, listSessions, loadOrCreateSessionId, persistSessionId, planTranscriptGC, projectDirFor, projectDirMatches, protectedTranscripts, recordProjectDir, resolveProjectDir, runTranscriptGC, sessionPointerPath };

package/dist/session.js

@@ -0,0 +1,338 @@
+import {
+  __name
+} from "./chunk-Z4QWC7IK.js";
+
+// src/session/session-lifecycle.ts
+import { readFileSync as readFileSync3, readdirSync, rmSync, statSync } from "fs";
+import { join as join3 } from "path";
+import { TheokitAgentError } from "@theokit/sdk/errors";
+import { classifySessionArtifact, forkTranscript, loadJsonl, sessionHasWriter, transcriptPath, transcriptRoot as transcriptRoot3 } from "@theokit/sdk/persistence";
+
+// src/session/project-index.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { encodeProjectDir, transcriptRoot } from "@theokit/sdk/persistence";
+var CWD_SIDECAR = "cwd";
+function projectDirFor(cwd, root = transcriptRoot()) {
+  return join(root, "projects", encodeProjectDir(cwd));
+}
+__name(projectDirFor, "projectDirFor");
+function recordProjectDir(cwd, root = transcriptRoot()) {
+  const sidecar = join(projectDirFor(cwd, root), CWD_SIDECAR);
+  try {
+    mkdirSync(dirname(sidecar), {
+      recursive: true
+    });
+    writeFileSync(sidecar, `${cwd}
+`, "utf8");
+  } catch {
+  }
+}
+__name(recordProjectDir, "recordProjectDir");
+function resolveProjectDir(encodedName, root = transcriptRoot()) {
+  try {
+    const raw = readFileSync(join(root, "projects", encodedName, CWD_SIDECAR), "utf8");
+    const cwd = raw.trim();
+    return cwd.length > 0 ? cwd : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(resolveProjectDir, "resolveProjectDir");
+function projectDirMatches(encodedName, cwd) {
+  return encodeProjectDir(cwd) === encodedName;
+}
+__name(projectDirMatches, "projectDirMatches");
+
+// src/session/session-pointer.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { dirname as dirname2 } from "path";
+import { atomicWriteText, transcriptRoot as transcriptRoot2 } from "@theokit/sdk/persistence";
+var POINTER = "last-session";
+function sessionPointerPath(cwd, root = transcriptRoot2()) {
+  return join2(projectDirFor(cwd, root), POINTER);
+}
+__name(sessionPointerPath, "sessionPointerPath");
+function loadOrCreateSessionId(cwd, mintId, root = transcriptRoot2()) {
+  try {
+    const existing = readFileSync2(sessionPointerPath(cwd, root), "utf8").trim();
+    if (existing.length > 0) return {
+      sessionId: existing,
+      resumed: true
+    };
+  } catch {
+  }
+  return {
+    sessionId: mintId(),
+    resumed: false
+  };
+}
+__name(loadOrCreateSessionId, "loadOrCreateSessionId");
+async function persistSessionId(cwd, sessionId, root = transcriptRoot2()) {
+  const target = sessionPointerPath(cwd, root);
+  try {
+    mkdirSync2(dirname2(target), {
+      recursive: true
+    });
+    await atomicWriteText(target, `${sessionId}
+`);
+    return {
+      persisted: true
+    };
+  } catch {
+    return {
+      persisted: false
+    };
+  }
+}
+__name(persistSessionId, "persistSessionId");
+
+// src/session/session-lifecycle.ts
+var SessionInUseError = class extends TheokitAgentError {
+  static {
+    __name(this, "SessionInUseError");
+  }
+  sessionId;
+  reason;
+  name = "SessionInUseError";
+  constructor(sessionId, reason) {
+    super(`session "${sessionId}" is protected (${reason}). Deleting it would discard state something is still using. Stop the run, or pass { force: true } to delete anyway.`), this.sessionId = sessionId, this.reason = reason;
+  }
+};
+function listSessions(cwd, root = transcriptRoot3()) {
+  const dir = projectDirFor(cwd, root);
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const entry of entries) {
+    const path = join3(dir, entry);
+    let isDirectory;
+    let modifiedAt;
+    try {
+      const stats = statSync(path);
+      isDirectory = stats.isDirectory();
+      modifiedAt = stats.mtime;
+    } catch {
+      continue;
+    }
+    const kind = classifySessionArtifact(entry, isDirectory);
+    if (kind !== "transcript") continue;
+    found.push({
+      id: entry.replace(/\.jsonl$/, ""),
+      transcript: path,
+      modifiedAt
+    });
+  }
+  return found.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+}
+__name(listSessions, "listSessions");
+function protectedTranscripts(cwd, root = transcriptRoot3()) {
+  const protectedBy = /* @__PURE__ */ new Map();
+  const sessions = listSessions(cwd, root);
+  const pointer = readPointer(cwd, root);
+  if (pointer !== void 0) protectedBy.set(pointer, "resumable session pointer");
+  if (sessions.length > 0 && !protectedBy.has(sessions[0].id)) {
+    protectedBy.set(sessions[0].id, "most recent session");
+  }
+  for (const session of sessions) {
+    const hasWriter = sessionHasWriter(session.transcript);
+    if (hasWriter) protectedBy.set(session.id, "active writer lease");
+  }
+  return protectedBy;
+}
+__name(protectedTranscripts, "protectedTranscripts");
+function readPointer(cwd, root) {
+  try {
+    const id = readFileSync3(sessionPointerPath(cwd, root), "utf8").trim();
+    return id.length > 0 ? id : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(readPointer, "readPointer");
+function deleteSession(sessionId, options) {
+  const root = options.root ?? transcriptRoot3();
+  if (options.force !== true) {
+    const reason = protectedTranscripts(options.cwd, root).get(sessionId);
+    if (reason !== void 0) throw new SessionInUseError(sessionId, reason);
+  }
+  let transcriptRemoved = false;
+  try {
+    rmSync(transcriptPath(root, options.cwd, sessionId));
+    transcriptRemoved = true;
+  } catch {
+  }
+  return {
+    registryRemoved: options.removeFromRegistry?.(sessionId) ?? false,
+    transcriptRemoved
+  };
+}
+__name(deleteSession, "deleteSession");
+function forkBeforeUserTurn(srcId, newId, nth, options) {
+  if (!Number.isInteger(nth) || nth < 1) {
+    throw new TheokitAgentError(`forkBeforeUserTurn: \`nth\` counts user turns from 1, received ${String(nth)}.`);
+  }
+  const root = options.root ?? transcriptRoot3();
+  const src = transcriptPath(root, options.cwd, srcId);
+  const dst = transcriptPath(root, options.cwd, newId);
+  const recordIndex = recordIndexOfUserTurn(src, nth);
+  if (recordIndex === void 0) {
+    throw new TheokitAgentError(`forkBeforeUserTurn: session "${srcId}" has fewer than ${String(nth)} user turns.`);
+  }
+  forkTranscript(src, dst, {
+    beforeRecordIndex: recordIndex,
+    liveSessionPaths: [
+      ...protectedTranscripts(options.cwd, root).keys()
+    ].map((id) => transcriptPath(root, options.cwd, id))
+  });
+  return {
+    transcript: dst,
+    recordIndex
+  };
+}
+__name(forkBeforeUserTurn, "forkBeforeUserTurn");
+function recordIndexOfUserTurn(src, nth) {
+  const records = loadJsonl(src);
+  let seen = 0;
+  for (const [index, record] of records.entries()) {
+    if (record.role !== "user") continue;
+    seen += 1;
+    if (seen === nth) return index;
+  }
+  return void 0;
+}
+__name(recordIndexOfUserTurn, "recordIndexOfUserTurn");
+
+// src/session/gc/transcript-gc.ts
+import { rmSync as rmSync2 } from "fs";
+import { TheokitAgentError as TheokitAgentError2 } from "@theokit/sdk/errors";
+import { transcriptPath as transcriptPath2, transcriptRoot as transcriptRoot4 } from "@theokit/sdk/persistence";
+var FLOOR = {
+  keepLast: 1,
+  maxAgeDays: 1
+};
+var GCFloorError = class extends TheokitAgentError2 {
+  static {
+    __name(this, "GCFloorError");
+  }
+  field;
+  received;
+  name = "GCFloorError";
+  constructor(field, received) {
+    super(`transcript GC: \`${field}\` must be at least ${String(FLOOR[field])}, received ${String(received)}. This is refused rather than clamped: a policy silently replaced by a different one is a policy nobody reviewed.`), this.field = field, this.received = received;
+  }
+};
+function planTranscriptGC(options) {
+  if (!Number.isFinite(options.keepLast) || options.keepLast < FLOOR.keepLast) {
+    throw new GCFloorError("keepLast", options.keepLast);
+  }
+  if (!Number.isFinite(options.maxAgeDays) || options.maxAgeDays < FLOOR.maxAgeDays) {
+    throw new GCFloorError("maxAgeDays", options.maxAgeDays);
+  }
+  const root = options.root ?? transcriptRoot4();
+  const now = options.now ?? Date.now();
+  const cutoff = now - options.maxAgeDays * 864e5;
+  const sessions = listSessions(options.cwd, root);
+  const protectedBy = protectedTranscripts(options.cwd, root);
+  const candidates = [];
+  const kept = [];
+  for (const [index, session] of sessions.entries()) {
+    const protection = protectedBy.get(session.id);
+    if (protection !== void 0) {
+      kept.push({
+        id: session.id,
+        reason: protection
+      });
+      continue;
+    }
+    if (index < options.keepLast) {
+      kept.push({
+        id: session.id,
+        reason: `within the newest ${String(options.keepLast)}`
+      });
+      continue;
+    }
+    const age = session.modifiedAt.getTime();
+    if (Number.isNaN(age)) {
+      kept.push({
+        id: session.id,
+        reason: "modification time unreadable \u2014 age cannot be shown"
+      });
+      continue;
+    }
+    if (age >= cutoff) {
+      kept.push({
+        id: session.id,
+        reason: `younger than ${String(options.maxAgeDays)} days`
+      });
+      continue;
+    }
+    candidates.push({
+      id: session.id,
+      transcript: session.transcript,
+      modifiedAt: session.modifiedAt
+    });
+  }
+  return {
+    cwd: options.cwd,
+    root,
+    candidates,
+    kept
+  };
+}
+__name(planTranscriptGC, "planTranscriptGC");
+function runTranscriptGC(plan, options) {
+  const removed = [];
+  const errors = [];
+  const protectedNow = options.apply ? protectedTranscripts(plan.cwd, plan.root) : /* @__PURE__ */ new Map();
+  for (const candidate of plan.candidates) {
+    if (protectedNow.has(candidate.id)) continue;
+    if (!options.apply) {
+      removed.push(candidate.id);
+      continue;
+    }
+    try {
+      rmSync2(transcriptPath2(plan.root, plan.cwd, candidate.id));
+      removed.push(candidate.id);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        removed.push(candidate.id);
+        continue;
+      }
+      errors.push({
+        id: candidate.id,
+        message: error.message
+      });
+    }
+  }
+  return {
+    dryRun: !options.apply,
+    removed,
+    errors
+  };
+}
+__name(runTranscriptGC, "runTranscriptGC");
+export {
+  GCFloorError,
+  SessionInUseError,
+  deleteSession,
+  forkBeforeUserTurn,
+  listSessions,
+  loadOrCreateSessionId,
+  persistSessionId,
+  planTranscriptGC,
+  projectDirFor,
+  projectDirMatches,
+  protectedTranscripts,
+  recordProjectDir,
+  resolveProjectDir,
+  runTranscriptGC,
+  sessionPointerPath
+};
+//# sourceMappingURL=session.js.map

package/dist/session.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/session/session-lifecycle.ts","../src/session/project-index.ts","../src/session/session-pointer.ts","../src/session/gc/transcript-gc.ts"],"mappings":"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","names":["readFileSync","readdirSync","rmSync","statSync","join","TheokitAgentError","classifySessionArtifact","forkTranscript","loadJsonl","sessionHasWriter","transcriptPath","transcriptRoot","mkdirSync","readFileSync","writeFileSync","dirname","join","encodeProjectDir","transcriptRoot","CWD_SIDECAR","projectDirFor","cwd","root","transcriptRoot","join","encodeProjectDir","recordProjectDir","sidecar","mkdirSync","dirname","recursive","writeFileSync","resolveProjectDir","encodedName","raw","readFileSync","trim","length","undefined","projectDirMatches","readFileSync","mkdirSync","join","dirname","atomicWriteText","transcriptRoot","POINTER","sessionPointerPath","cwd","root","transcriptRoot","join","projectDirFor","loadOrCreateSessionId","mintId","existing","readFileSync","trim","length","sessionId","resumed","persistSessionId","target","mkdirSync","dirname","recursive","atomicWriteText","persisted","SessionInUseError","TheokitAgentError","name","sessionId","reason","listSessions","cwd","root","transcriptRoot","dir","projectDirFor","entries","readdirSync","found","entry","path","join","isDirectory","modifiedAt","stats","statSync","mtime","kind","classifySessionArtifact","push","id","replace","transcript","sort","a","b","getTime","protectedTranscripts","protectedBy","Map","sessions","pointer","readPointer","undefined","set","length","has","session","hasWriter","sessionHasWriter","readFileSync","sessionPointerPath","trim","deleteSession","options","force","get","transcriptRemoved","rmSync","transcriptPath","registryRemoved","removeFromRegistry","forkBeforeUserTurn","srcId","newId","nth","Number","isInteger","String","src","dst","recordIndex","recordIndexOfUserTurn","forkTranscript","beforeRecordIndex","liveSessionPaths","keys","map","records","loadJsonl","seen","index","record","role","rmSync","TheokitAgentError","transcriptPath","transcriptRoot","FLOOR","keepLast","maxAgeDays","GCFloorError","TheokitAgentError","name","field","received","String","planTranscriptGC","options","Number","isFinite","root","transcriptRoot","now","Date","cutoff","sessions","listSessions","cwd","protectedBy","protectedTranscripts","candidates","kept","index","session","entries","protection","get","id","undefined","push","reason","age","modifiedAt","getTime","isNaN","transcript","runTranscriptGC","plan","removed","errors","protectedNow","apply","Map","candidate","has","rmSync","transcriptPath","error","code","message","dryRun"]}