@stringsync/splates 0.0.45 → 0.0.47

package/index-xmfmy729.js

@@ -1,249 +0,0 @@
-import {
-  LEGACY_DIR
-} from "./index-k73tsw5g.js";
-import {
-  splatesHome
-} from "./index-43pq33n4.js";
-
-// heavy.ts
-import { HeavyJobs } from "webappwiz/system";
-
-// slots.ts
-import { FileLock } from "webappwiz/system";
-import { Duration, sleep } from "webappwiz/time";
-import { z } from "zod";
-var SERVER_PID = "server.pid";
-var SLOT = "SPLATES_SLOT";
-var MACHINE_HOME = "SPLATES_MACHINE_HOME";
-var STOP_WAIT = Duration.secs(5);
-var FORMAT = 1;
-
-class Slots {
-  path;
-  deps;
-  constructor(path, deps) {
-    this.path = path;
-    this.deps = deps;
-  }
-  static ofMachine({ fs, ps, log }) {
-    const home = ps.env(MACHINE_HOME) ?? splatesHome(ps);
-    return new Slots(`${home}/slots.json`, {
-      fs,
-      ps,
-      lock: new FileLock(`${home}/slots.lock`, { fs, ps, log })
-    });
-  }
-  async owns(tree) {
-    const { fs } = this.deps;
-    return await fs.exists(tree) && !await fs.exists(`${tree}/.git/splates`) && !await fs.exists(`${tree}/.git/${LEGACY_DIR}`);
-  }
-  async claim(tree) {
-    const { fs, lock, pool = SLOT_POOL } = this.deps;
-    await fs.mkdir(this.path.slice(0, this.path.lastIndexOf("/")));
-    await lock.acquire();
-    try {
-      const claims = await this.read();
-      const held = pool.find(({ word }) => claims[word] === tree);
-      if (held !== undefined) {
-        return held;
-      }
-      const holders = [];
-      for (const slot of pool) {
-        const holder = claims[slot.word];
-        if (holder !== undefined && await this.owns(holder)) {
-          holders.push(`  ${slot.word}: ${holder}`);
-          continue;
-        }
-        const pid = await this.server(slot);
-        if (pid !== null) {
-          holders.push(`  ${slot.word}: pid ${pid}${holder === undefined ? "" : `, run from ${holder}`}`);
-          continue;
-        }
-        await this.write({ ...claims, [slot.word]: tree });
-        return slot;
-      }
-      throw new Error([
-        "every dev slot is held:",
-        ...holders,
-        "each is another task's: `splates slots prune` frees those no task owns any more, and stops their servers; never stop another task's server or edit its claim"
-      ].join(`
-`));
-    } finally {
-      await lock.release();
-    }
-  }
-  home(slot) {
-    return `${this.path.slice(0, this.path.lastIndexOf("/"))}/slots/${slot.word}`;
-  }
-  async server(slot) {
-    const { fs, ps } = this.deps;
-    const file = `${this.home(slot)}/${SERVER_PID}`;
-    if (!await fs.exists(file)) {
-      return null;
-    }
-    const pid = Number.parseInt((await fs.read(file)).trim(), 10);
-    if (!Number.isInteger(pid) || pid === ps.pid || !ps.alive(pid)) {
-      return null;
-    }
-    const running = (await ps.processes()).find((each) => each.pid === pid);
-    if (running !== undefined && !/\bdev\b/.test(running.command)) {
-      return null;
-    }
-    return pid;
-  }
-  async list() {
-    const { pool = SLOT_POOL } = this.deps;
-    const claims = await this.read();
-    const held = [];
-    for (const slot of pool) {
-      const tree = claims[slot.word];
-      if (tree !== undefined && await this.owns(tree)) {
-        held.push({ slot, tree });
-      }
-    }
-    return held;
-  }
-  async status() {
-    const { pool = SLOT_POOL } = this.deps;
-    const claims = await this.read();
-    const held = [];
-    for (const slot of pool) {
-      const tree = claims[slot.word];
-      if (tree !== undefined) {
-        held.push({
-          slot,
-          tree,
-          pid: await this.server(slot),
-          orphaned: !await this.owns(tree)
-        });
-      }
-    }
-    return held;
-  }
-  async stop(slot) {
-    const { ps } = this.deps;
-    const pid = await this.server(slot);
-    if (pid === null) {
-      return null;
-    }
-    await ps.spawnCapture(["kill", String(pid)]);
-    const deadline = Date.now() + STOP_WAIT.ms;
-    while (ps.alive(pid)) {
-      if (Date.now() >= deadline) {
-        await ps.spawnCapture(["kill", "-KILL", String(pid)]);
-        break;
-      }
-      await sleep(Duration.ms(100));
-    }
-    return pid;
-  }
-  async release(tree) {
-    const { lock, pool = SLOT_POOL } = this.deps;
-    if (!Object.values(await this.read()).includes(tree)) {
-      return null;
-    }
-    await lock.acquire();
-    try {
-      const claims = await this.read();
-      const slot = pool.find(({ word }) => claims[word] === tree);
-      if (slot === undefined) {
-        return null;
-      }
-      const stopped = await this.stop(slot);
-      const { [slot.word]: _, ...rest } = claims;
-      await this.write(rest);
-      return { slot, stopped };
-    } finally {
-      await lock.release();
-    }
-  }
-  async prune() {
-    const { lock } = this.deps;
-    if (!await this.deps.fs.exists(this.path)) {
-      return [];
-    }
-    await lock.acquire();
-    try {
-      const orphans = (await this.status()).filter(({ orphaned }) => orphaned);
-      const claims = await this.read();
-      for (const orphan of orphans) {
-        await this.stop(orphan.slot);
-        delete claims[orphan.slot.word];
-      }
-      if (orphans.length > 0) {
-        await this.write(claims);
-      }
-      return orphans;
-    } finally {
-      await lock.release();
-    }
-  }
-  async read() {
-    const raw = await this.deps.fs.read(this.path).catch(() => null);
-    if (raw === null) {
-      return {};
-    }
-    const parsed = Claims.safeParse(JSON.parse(raw));
-    if (!parsed.success || parsed.data.format > FORMAT) {
-      throw new Error(`${this.path} is not slots this splates reads: remove it to start over`);
-    }
-    return parsed.data.claims;
-  }
-  async write(claims) {
-    const tmp = `${this.path}.${crypto.randomUUID()}.tmp`;
-    await this.deps.fs.write(tmp, `${JSON.stringify({ format: FORMAT, claims }, null, "\t")}
-`);
-    await this.deps.fs.rename(tmp, this.path);
-  }
-}
-var SLOT_POOL = [
-  { word: "cat", emoji: "\uD83D\uDE38" },
-  { word: "bee", emoji: "\uD83D\uDC1D" },
-  { word: "dog", emoji: "\uD83D\uDC36" },
-  { word: "fox", emoji: "\uD83E\uDD8A" },
-  { word: "owl", emoji: "\uD83E\uDD89" },
-  { word: "pig", emoji: "\uD83D\uDC37" },
-  { word: "lion", emoji: "\uD83E\uDD81" },
-  { word: "wolf", emoji: "\uD83D\uDC3A" },
-  { word: "bear", emoji: "\uD83D\uDC3B" },
-  { word: "frog", emoji: "\uD83D\uDC38" },
-  { word: "duck", emoji: "\uD83E\uDD86" },
-  { word: "crab", emoji: "\uD83E\uDD80" }
-];
-function freedLine({
-  slot,
-  stopped
-}) {
-  return `${slot.word} ${slot.emoji} given back${stopped === null ? "" : `, its server (pid ${stopped}) stopped`}`;
-}
-function slotOf(word) {
-  return SLOT_POOL.find((each) => each.word === word) ?? null;
-}
-var Claims = z.object({
-  format: z.number(),
-  claims: z.record(z.string(), z.string())
-});
-
-// heavy.ts
-var HEAVY_JOBS_DEFAULT2 = 2;
-var HEAVY_JOBS2 = "SPLATES_HEAVY_JOBS";
-var HEAVY_HELD2 = "SPLATES_HEAVY";
-function heavyJobsOfMachine2({
-  fs,
-  ps,
-  log
-}) {
-  return HeavyJobs.under(ps.env(MACHINE_HOME) ?? splatesHome(ps), {
-    fs,
-    ps,
-    log,
-    cap: capOf2(ps.env(HEAVY_JOBS2)),
-    held: HEAVY_HELD2
-  });
-}
-function capOf2(value) {
-  const cap = Number(value);
-  return Number.isInteger(cap) && cap > 0 ? cap : HEAVY_JOBS_DEFAULT2;
-}
-
-export { SERVER_PID, SLOT, MACHINE_HOME, Slots, SLOT_POOL, freedLine, slotOf, HEAVY_JOBS_DEFAULT2, HEAVY_JOBS2, HEAVY_HELD2, heavyJobsOfMachine2, capOf2 };

package/init.d.ts

@@ -1,28 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs, Ps } from "webappwiz/system";
-import type { Git } from "./git.js";
-import type { Projects } from "./projects.js";
-/**
- * Makes this repository a splates project: `repository` has set up its records
- * by now, when it had none, so what is left is installing the skill that
- * teaches its agents to work through splates, through `bunx skills add` from
- * this release's tag, and joining the registry, which
- * lets one `splates server` serve it beside every other. Run again, or in a
- * project already under way, it changes nothing that is already so.
- */
-export declare function init({ git, projects, fs, ps, log, }: {
-    git: Git;
-    projects: Projects;
-    fs: Fs;
-    ps: Ps;
-    log: Logger;
-}): Promise<void>;
-/**
- * Takes this repository off the registry, so `splates server` no longer offers it:
- * its records stay, and `splates init` brings it back.
- */
-export declare function forget({ git, projects, log, }: {
-    git: Git;
-    projects: Projects;
-    log: Logger;
-}): Promise<void>;

package/journal.d.ts

@@ -1,57 +0,0 @@
-import { type Fs, type Ps } from "webappwiz/system";
-import { type Action, type Event, type Facts, type FactsOf } from "./events.js";
-/** How long a log file is kept once it fills, so a live conversation can still show the events in it. */
-export declare const LOG_KEPT_MS: number;
-/** What a `Journal` is stored through; the real filesystem and process by default. */
-export interface JournalOptions {
-    fs?: Fs;
-    ps?: Ps;
-}
-/**
- * What has been done in this repo, oldest first. Events outlive their tasks:
- * `merge` and `remove` take the record with them, so this is the only thing
- * that remembers a task existed at all.
- *
- * Each event is appended, never rewritten, so two agents writing at once both
- * keep theirs. Once the file holds `capacity` events it is moved into the
- * `log` directory beside it, under a name that sorts by when, and a fresh one
- * starts; moved files go once they are `LOG_KEPT_MS` old.
- */
-export declare class Journal {
-    private readonly path;
-    private readonly capacity;
-    private readonly fs;
-    private readonly ps;
-    private readonly archive;
-    constructor(path: string, capacity: number, opts?: JournalOptions);
-    record<A extends Action, T>(action: A, task: string | null, run: () => Promise<T>, ...[facts]: FactsOf<A, T>): Promise<T>;
-    /**
-     * Logs a wait as it begins, then `record`s how it ended with `began`
-     * naming that first event, so the page can count it down while it runs.
-     */
-    waiting<A extends "wait" | "todo wait" | "creds wait", T>(action: A, task: string | null, facts: Omit<Facts[A], "began">, run: () => Promise<T>): Promise<T>;
-    tail(count: number): Promise<Event[]>;
-    /**
-     * The events in the log and in the file moved aside last: every event
-     * written since a reader last looked, so long as it looks before the log
-     * fills twice over.
-     */
-    recent(): Promise<Event[]>;
-    private append;
-    /**
-     * Moves the full file aside. Two writers rotating at once is harmless: the
-     * second either finds nothing to move or moves the few events written since,
-     * under a name of its own.
-     */
-    private rotate;
-    /** The moved files, oldest first. */
-    private archived;
-    /**
-     * The events in `path` that carry every fact their action records now:
-     * one that went through before its action recorded them is left out,
-     * since a reader trusts an event's facts as its type gives them.
-     */
-    private read;
-    /** Every event in `path`, whatever facts it carries. */
-    private parsed;
-}

package/landed.d.ts

@@ -1,14 +0,0 @@
-import { type Baseline } from "./baselines.js";
-import type { Outcome } from "./outcomes.js";
-/** How a merged task went, beside how its project's tasks went the week before. */
-export interface Landed {
-    outcome: Outcome;
-    /** Its project's tasks over the week to its merge, itself among them; null for none. */
-    baseline: Baseline | null;
-}
-/**
- * The last merge of `task` in `project`, held against the week up to it, so
- * the comparison reads the same however long after it is asked. Null when it
- * never merged there.
- */
-export declare function landed(outcomes: Outcome[], project: string, task: string): Landed | null;

package/lane-todos.d.ts

@@ -1,44 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import type { LaneRecord } from "./lanes.js";
-import type { TodoState } from "./todo.js";
-/** A todo in a lane, as a lane's orchestrator hears of it. */
-export interface LaneTodo {
-    id: number;
-    /** Its lane, by number and name, the name kept for once the lane ends. */
-    lane: {
-        id: number;
-        name: string;
-    };
-    /** Whether a task has taken it. */
-    taken: boolean;
-}
-/** What became of a todo in a lane since it was last seen. */
-export interface LaneTodoChange {
-    todo: number;
-    lane: {
-        id: number;
-        name: string;
-    };
-    /** `done` once it left the list, merged or removed; `open` once its task let it go. */
-    change: "done" | "open";
-}
-/** The todos in a lane, out of every todo and the lanes on the board. */
-export declare function laneTodos(todos: TodoState[], lanes: LaneRecord[]): LaneTodo[];
-/**
- * What became of each todo in `before` by `now`: done for one gone from the
- * list, open for one taken then and not now. One that moved lanes, or came
- * into one, is neither.
- */
-export declare function laneChanges(before: LaneTodo[], now: LaneTodo[], all: TodoState[]): LaneTodoChange[];
-/**
- * The lane todos as last seen, kept on disk, so what changed while `splates
- * dev` was down is told once it is back.
- */
-export declare class SeenLaneTodos {
-    private readonly fs;
-    private readonly path;
-    constructor(fs: Fs, path: string);
-    /** What was last seen, or null before anything was. */
-    read(): Promise<LaneTodo[] | null>;
-    write(seen: LaneTodo[]): Promise<void>;
-}

package/lanes-from-tags.d.ts

@@ -1,17 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import { type Fs, type Ps } from "webappwiz/system";
-/** Where the repository at `dir` keeps its todos, and what to do it with. */
-export interface LanesFromTagsOptions {
-    /** The root of a repository, or of one of its worktrees. */
-    dir: string;
-    log?: Logger;
-    fs?: Fs;
-    ps?: Ps;
-}
-/**
- * Moves the todos of the repository at `dir` that still have tags, from
- * before splates kept lanes instead, into a lane a tag, and says where each
- * went; splates refuses to read them until then. Says nothing when `dir` is
- * no repository, keeps no todos, or none has tags.
- */
-export declare function lanesFromTags(opts: LanesFromTagsOptions): Promise<void>;

package/lanes.d.ts

@@ -1,96 +0,0 @@
-import type { TodoState } from "./todo.js";
-/**
- * What blocks which todos, and the lanes they run in, worked out from the
- * todos alone. Nothing here reads or writes the disk, so the CLI and the
- * `splates server` page draw the same lanes from the same list.
- */
-/** A todo that has to merge first, and where it stands now. */
-export interface Blocker {
-    id: number;
-    subject: string;
-    /** The lane it is in, or null when it is in none. */
-    lane: number | null;
-    /** The task working on it, or null while nobody has it. */
-    takenBy: string | null;
-}
-/**
- * A lane as stored: its number, never handed out again once it is gone, and
- * what it is called. Lanes are kept in the order the board shows them.
- */
-export interface LaneRecord {
-    id: number;
-    name: string;
-}
-/** A queue of todos that build on each other, worked top first. */
-export interface LaneState {
-    id: number;
-    name: string;
-    todos: TodoState[];
-    /** The tasks at work on its todos now, top first: who is on the lane. */
-    agents: string[];
-    /** The first todo no task has taken: what the lane's orchestrator hands out next. */
-    next: TodoState | null;
-    /**
-     * Todos in other lanes, or in none, blocking `next` that have
-     * yet to merge: what the lane is waiting on before it can go on.
-     */
-    blockers: Blocker[];
-    /** `next` can be taken now: nothing blocking it is left but in this lane's hands. */
-    ready: boolean;
-}
-/**
- * Every lane, in the order `records` keeps them, each with its todos in list
- * order. A lane some todo is in but `records` lacks, as one written before
- * lanes had names, comes last, called by its number.
- */
-export declare function lanes(todos: TodoState[], records: LaneRecord[]): LaneState[];
-/** `records`, and after them a record for each lane a todo is in that they lack. */
-export declare function named(todos: TodoState[], records: LaneRecord[]): LaneRecord[];
-/** The lane `record` stands for, empty when no todo is in it. */
-export declare function lane(todos: TodoState[], { id, name }: LaneRecord): LaneState;
-/** What blocks `todo` and has yet to merge, in list order. */
-export declare function blockersOf(todos: TodoState[], todo: TodoState): Blocker[];
-/** The todos `id` blocks, in list order. */
-export declare function followers(todos: TodoState[], id: number): TodoState[];
-/** Nothing blocking it is still open, and nobody has it: free to start. */
-export declare function isReady(todo: TodoState): boolean;
-/**
- * The todos that would form a loop if `blocker` blocked `id`, as the chain
- * from `id` round to itself in merge order, or null when there is none. A
- * loop is `id` already blocking `blocker`, however far down.
- */
-export declare function cycle(todos: TodoState[], id: number, blocker: number): number[] | null;
-/**
- * `todos` in list order, but with each one below every todo in its own lane
- * that blocks it: a todo that would come too soon is moved down to just
- * below the last of them, and everything else keeps its place.
- */
-export declare function settle(todos: TodoState[]): TodoState[];
-/**
- * The first pair in `todos`, in list order, where a todo sits above one in
- * its own lane that blocks it; null when the lanes all keep to their
- * links.
- */
-export declare function misordered(todos: TodoState[]): {
-    todo: TodoState;
-    blockedBy: TodoState;
-} | null;
-/** A blocking todo, and the lane it is in by name: `#177 in Licensing`. */
-export declare function blockerLabel({ id, lane }: {
-    id: number;
-    lane: number | null;
-}, records: LaneRecord[]): string;
-/**
- * A name for a lane holding `todos`, none of `taken`: its first todo's
- * subject, numbered past any lane already called that. The user renames it
- * to what the run adds up to.
- */
-export declare function aptName(todos: TodoState[], taken: string[]): string;
-/**
- * The todos a markdown text mentions as `#N`, once each, in the order
- * mentioned. Code spans and blocks are left out, where `#3` means something
- * else, as is `#N` inside a word or a link like `page#2`.
- */
-export declare function mentioned(text: string): number[];
-/** `#` and a number, standing on its own. */
-export declare const MENTION: RegExp;

package/legacy-names.d.ts

@@ -1,70 +0,0 @@
-import type { Logger } from "webappwiz/log";
-import type { Fs, Ps } from "webappwiz/system";
-/** splates's old name, as its command, its skill and its directories went by. */
-export declare const LEGACY = "arbor";
-/** The old name of a `SPLATES_*` variable or cred, or null for any other. */
-export declare function legacyName(name: string): string | null;
-/** The `SPLATES_*` name of an `ARBOR_*` variable or cred, or null for any other. */
-export declare function renamed(old: string): string | null;
-/** A task's notes file in a worktree made before the rename. */
-export declare const LEGACY_PLAN_FILE = "ARBOR.md";
-/** The state directory under `.git`, and the home directory's, before the rename. */
-export declare const LEGACY_DIR = "arbor";
-/** Says once per process, on stderr, that an old name was used. */
-declare class Warnings {
-    #private;
-    once(name: string, instead: string): void;
-}
-export declare const legacyWarnings: Warnings;
-/**
- * `next`, or `old` while only the old directory is there: until `splates server`
- * has moved it, every command reads records where arbor left them.
- */
-export declare function unmigrated(next: string, old: string): string;
-/** What `moveLegacyDir` works with. */
-export interface MoveOptions {
-    fs: Fs;
-    log: Logger;
-    /** Makes `path` a symbolic link to `target`; the real one by default. */
-    link?: (target: string, path: string) => Promise<void>;
-}
-/**
- * Moves arbor's directory `old` to `next` and leaves a link at `old`, so the
- * absolute paths records hold, attachments named in plans, todos and
- * conversations above all, still resolve. Does nothing once moved, or when
- * `next` is already there. Answers whether it moved.
- */
-export declare function moveLegacyDir(old: string, next: string, { fs, log, link }: MoveOptions): Promise<boolean>;
-/** Renames a worktree's `ARBOR.md` to `planFile`, unless it has one already. */
-export declare function movePlan(tree: string, planFile: string, fs: Fs): Promise<void>;
-/**
- * `path` under `.git/splates` when it names a file under `.git/arbor`, as
- * plans, todos and conversations written before the move do.
- */
-export declare function movedPath(path: string): string;
-/** The old name of the file a repo keeps `file`'s settings in, or null. */
-export declare function legacyFile(file: string): string | null;
-/** What `renameLegacyFiles` and `removeLegacySkill` work with. */
-export interface LegacyRepoOptions {
-    /** The repository's main tree. */
-    root: string;
-    fs: Fs;
-    ps: Ps;
-    log: Logger;
-}
-/**
- * Renames `arbor.config.ts` and `arbor.systems.ts` to splates's names, through
- * git when it tracks them so the rename is staged as one, and points their
- * imports of `@webappwiz/arbor` at `@stringsync/splates`. Leaves a file alone when one
- * under the new name is already there.
- */
-export declare function renameLegacyFiles({ root, fs, ps, log, }: LegacyRepoOptions): Promise<void>;
-/**
- * Takes arbor's skill at `path` out of its project, which splates's replaces.
- * Leaves one that links to a copy kept by hand.
- */
-export declare function removeLegacySkill(path: string, { fs, log }: {
-    fs: Fs;
-    log: Logger;
-}): Promise<void>;
-export {};

package/legacy-ps.d.ts

@@ -1,31 +0,0 @@
-import type { Resource } from "webappwiz/disposable";
-import { type Child, type Ps, type SpawnCaptureResult, type SpawnOptions, type SpawnResult, type StartOptions, type TerminalChild, type TerminalOptions } from "webappwiz/system";
-/**
- * A `Ps` that reads each `SPLATES_*` variable under its `ARBOR_*` name too,
- * warning once, and sets both names on every child, so a `wiz` or skill still
- * reading the old ones sees what splates means.
- */
-export declare class LegacyNamesPs implements Ps {
-    private readonly inner;
-    constructor(inner: Ps);
-    get platform(): NodeJS.Platform;
-    get pid(): number;
-    get hostname(): string;
-    get args(): string[];
-    get self(): string[];
-    env(name: string): string | undefined;
-    alive(pid: number): boolean;
-    spawn(argv: string[], opts?: SpawnOptions): Promise<SpawnResult>;
-    spawnCapture(argv: string[], opts?: SpawnOptions): Promise<SpawnCaptureResult>;
-    start(argv: string[], opts?: StartOptions): Child;
-    startOnTerminal(argv: string[], opts: TerminalOptions): TerminalChild;
-    processes(): ReturnType<Ps["processes"]>;
-    listening(): ReturnType<Ps["listening"]>;
-    cwd(): string;
-    cd(path: string): void;
-    exit(code: number): void;
-    on(signal: string, handler: (...args: unknown[]) => void): Resource;
-    once(event: "exit", handler: () => void): Resource;
-}
-/** The machine's processes, under both names. */
-export declare function systemPs(): Ps;

package/limits.d.ts

@@ -1,32 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import { type Limit } from "./conversations.js";
-/**
- * Each agent's plan limits as it last said, from any project, kept under the
- * user's home: a new conversation shows how much of the plan is left before
- * any conversation in its project has said.
- */
-export declare class Limits {
-    /** `~/.splates/limits.json`, or a test's own. */
-    readonly path: string;
-    private readonly deps;
-    /** Read once, then kept: this process is the one writing it. */
-    private known;
-    /** Set when a newer splates wrote the file, which this one leaves alone. */
-    private newer;
-    /** Writes one after another, so none is lost to another. */
-    private writing;
-    constructor(
-    /** `~/.splates/limits.json`, or a test's own. */
-    path: string, deps: {
-        fs: Fs;
-    });
-    /** Every agent's limits, by its id; none for one that never said. */
-    all(): Promise<Record<string, Limit[]>>;
-    /**
-     * Keeps each of `limits` that is newer than what `agent` said of its
-     * window before: a log read back can be older than another project's.
-     */
-    remember(agent: string, limits: Limit[]): Promise<void>;
-    private read;
-    private write;
-}

package/list.d.ts

@@ -1,18 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs } from "webappwiz/system";
-import type { WorktreeService } from "./worktree-service.js";
-export interface ListOptions {
-    /** Print the rows as JSON instead of a table. */
-    json?: boolean;
-    /**
-     * Add each task's Goal and changed files, which is what an agent checks
-     * its own plan against before starting. Off by default: it costs git calls
-     * and a file read per task.
-     */
-    files?: boolean;
-}
-export declare function list({ service, log, fs }: {
-    service: WorktreeService;
-    log: Logger;
-    fs: Fs;
-}, { json, files }?: ListOptions): Promise<void>;