toolroll 0.9.103 → 0.9.105

package/dist/knowledge-cli.d.ts

@@ -1,132 +0,0 @@
-import type { Store } from './store.js';
-export declare const KNOWLEDGE_DESCRIPTORS: readonly [{
-    readonly action: 'search';
-    readonly synopsis: 'find bounded source excerpts and relevant code symbols';
-    readonly mutation: 'none';
-    readonly takesQuery: true;
-    readonly flags: readonly [{
-        readonly name: 'repo';
-        readonly takesValue: true;
-        readonly meaning: 'admitted project checkout root';
-    }, {
-        readonly name: 'base';
-        readonly takesValue: true;
-        readonly meaning: 'exact committed task base; defaults to current HEAD';
-    }, {
-        readonly name: 'json';
-        readonly takesValue: false;
-        readonly meaning: 'versioned structured response';
-    }, {
-        readonly name: 'db';
-        readonly takesValue: true;
-        readonly meaning: 'local Toolroll database';
-    }, {
-        readonly name: 'token-file';
-        readonly takesValue: true;
-        readonly meaning: 'explicit scoped coordinator credential file';
-    }, {
-        readonly name: 'token-env';
-        readonly takesValue: true;
-        readonly meaning: 'environment variable containing a scoped coordinator token';
-    }];
-}, {
-    readonly action: 'impact';
-    readonly synopsis: 'inspect static imports affected by one file or unambiguous symbol';
-    readonly mutation: 'none';
-    readonly takesQuery: true;
-    readonly flags: readonly [{
-        readonly name: 'repo';
-        readonly takesValue: true;
-        readonly meaning: 'admitted project checkout root';
-    }, {
-        readonly name: 'base';
-        readonly takesValue: true;
-        readonly meaning: 'exact committed task base; defaults to current HEAD';
-    }, {
-        readonly name: 'json';
-        readonly takesValue: false;
-        readonly meaning: 'versioned structured response';
-    }, {
-        readonly name: 'db';
-        readonly takesValue: true;
-        readonly meaning: 'local Toolroll database';
-    }, {
-        readonly name: 'token-file';
-        readonly takesValue: true;
-        readonly meaning: 'explicit scoped coordinator credential file';
-    }, {
-        readonly name: 'token-env';
-        readonly takesValue: true;
-        readonly meaning: 'environment variable containing a scoped coordinator token';
-    }];
-}, {
-    readonly action: 'refresh';
-    readonly synopsis: 'refresh the optional local code index; never starts a model or task';
-    readonly mutation: 'identity-idempotent';
-    readonly takesQuery: false;
-    readonly flags: readonly [{
-        readonly name: 'repo';
-        readonly takesValue: true;
-        readonly meaning: 'admitted project checkout root';
-    }, {
-        readonly name: 'base';
-        readonly takesValue: true;
-        readonly meaning: 'exact committed task base; defaults to current HEAD';
-    }, {
-        readonly name: 'json';
-        readonly takesValue: false;
-        readonly meaning: 'versioned structured response';
-    }, {
-        readonly name: 'db';
-        readonly takesValue: true;
-        readonly meaning: 'local Toolroll database';
-    }, {
-        readonly name: 'token-file';
-        readonly takesValue: true;
-        readonly meaning: 'explicit scoped coordinator credential file';
-    }, {
-        readonly name: 'token-env';
-        readonly takesValue: true;
-        readonly meaning: 'environment variable containing a scoped coordinator token';
-    }];
-}, {
-    readonly action: 'apply';
-    readonly synopsis: "carry this project's saved knowledge from before a change forward as a new revision; an approver's --as/--token";
-    readonly mutation: 'identity-idempotent';
-    readonly takesQuery: false;
-    readonly flags: readonly [{
-        readonly name: 'repo';
-        readonly takesValue: true;
-        readonly meaning: 'admitted project checkout root';
-    }, {
-        readonly name: 'as';
-        readonly takesValue: true;
-        readonly meaning: 'approver account name';
-    }, {
-        readonly name: 'token';
-        readonly takesValue: true;
-        readonly meaning: "the approver's password (never a lead token)";
-    }, {
-        readonly name: 'json';
-        readonly takesValue: false;
-        readonly meaning: 'versioned structured response';
-    }, {
-        readonly name: 'db';
-        readonly takesValue: true;
-        readonly meaning: 'local Toolroll database';
-    }];
-    readonly audience: 'operator';
-}];
-/** `knowledge apply`: the caller has verified `actor` as an approver of `repo` (never the lead). */
-export declare function runKnowledgeApply(options: Map<string, string | true>, context: KnowledgeCliContext & {
-    actor: string | null;
-}): number;
-export type KnowledgeCliContext = {
-    store: Store;
-    write: (line: string) => void;
-    json: boolean;
-    now: Date;
-    evidenceRoot?: string;
-    env?: NodeJS.ProcessEnv;
-};
-export declare function runKnowledgeCommand(positional: readonly string[], options: Map<string, string | true>, context: KnowledgeCliContext): Promise<number>;

package/dist/knowledge-ui.d.ts

@@ -1,45 +0,0 @@
-import { type KnowledgeDraft, type KnowledgeSelection, type KnowledgeView } from './project-knowledge.js';
-import { type Html } from './html.js';
-import { type MemoryUse } from './memory-use.js';
-/** A section as a frame (after ReUI's Frame, MIT): its heading on the raised well, its body one paper panel. The
- * cards inside become hairline-divided rows of that panel, never cards in a card. */
-export declare function framedSection(heading: string, body: Html | string, extra?: string): Html;
-export declare const KNOWLEDGE_CSS = ".knowledge{max-width:780px;min-width:0;overflow-wrap:anywhere}.knowledge .card{padding:20px;min-width:0;margin:16px 0}.knowledge h2{margin:0 0 12px}.knowledge form{display:grid;gap:12px;margin:0}.knowledge label{display:grid;gap:6px}.knowledge textarea,.knowledge input,.knowledge select{box-sizing:border-box;width:100%;min-width:0;max-width:100%}.knowledge textarea{resize:vertical;min-height:110px}.knowledge button,.knowledge summary,.knowledge .button-link{min-height:44px}.knowledge button{justify-self:start;white-space:nowrap}.knowledge summary{padding:12px 0;cursor:pointer}.knowledge pre{white-space:pre-wrap;overflow-wrap:anywhere;font:inherit}.knowledge .knowledge-actions{display:flex;gap:12px;flex-wrap:wrap}.knowledge .meta{font-size:.86rem}.knowledge .knowledge-source{display:block}.knowledge details+details{border-top:1px solid var(--so-line)}.memory-stats{display:flex;flex-wrap:wrap;gap:.4rem}.memory-stats span+span::before{content:\"\u00B7\";margin-right:.4rem}.knowledge.frame{margin:0 0 16px}.knowledge.frame>.frame-head h2,.knowledge.frame>summary.frame-head{margin:0;font-size:13px;font-weight:600;line-height:1.4}.knowledge.frame>summary.frame-head{min-height:44px;padding:4px 10px}.knowledge.frame>.frame-panel{min-width:0}.knowledge.frame>.frame-panel>:first-child{margin-top:0}.knowledge.frame>.frame-panel>:last-child{margin-bottom:0}.knowledge .frame-panel>details.card,.knowledge .frame-panel .learning .card{margin:0;padding:0;border:0;border-radius:0;background:none;box-shadow:none}.knowledge .frame-panel>details.card+details.card,.knowledge .frame-panel .learning .card+.card{border-top:1px solid var(--so-line);padding-top:4px}.knowledge.frame>summary.frame-head{justify-content:flex-start}.knowledge form.field-row{grid-template-columns:minmax(0,1fr) auto;align-items:end}.knowledge form.field-row>label,.knowledge form.field-row :is(input,select,button){margin:0}@media(max-width:600px){.knowledge .card{padding:16px}.knowledge h2{font-size:1.1rem}}";
-export declare function knowledgeHtml(view: KnowledgeView, csrf: string, canManage: boolean, draft?: KnowledgeDraft, error?: string, use?: ReadonlyMap<string, MemoryUse>): Html;
-export declare function knowledgeContextHtml(snapshot: KnowledgeSelection | null): Html | '';
-import type { Decision, MemoryHit } from './project-memory.js';
-export declare const MEMORY_INTRO = "What the lead and crew read before they work. Every change keeps its history. Last included is counted in runs.";
-export declare function decisionsHtml(repo: string, decisions: Decision[], csrf: string, canManage: boolean, draft?: {
-    claim?: string;
-    why?: string;
-}, error?: string, use?: ReadonlyMap<string, MemoryUse>, afterwards?: (decision: Decision) => string | null): Html;
-export declare function memorySearchHtml(repo: string, query: string, hits: MemoryHit[] | null): Html;
-import type { MemoryProposal } from './memory-pass.js';
-export declare function proposalsHtml(repo: string, proposals: MemoryProposal[], status: {
-    surface: string;
-    instructionBytes: number;
-    budgetBytes: number;
-    sessions: {
-        total: number;
-        analyzed: number;
-        failed: number;
-    };
-    openGaps: number;
-    pending: number;
-} | null, csrf: string, canManage: boolean, who?: string): Html;
-import type { TidyProposal } from './memory-tidy.js';
-export declare function cleanUpHtml(repo: string, proposals: readonly TidyProposal[], manage: boolean): Html;
-/** On a saved version's page: the references that aren't in current knowledge, each back as a new version. */
-export declare function referenceRestoreHtml(repo: string, revision: number, references: readonly {
-    id: string;
-    title: string;
-}[], manage: boolean): Html | '';
-/** Retired decisions, undoable merges and disabled lessons, each with its way back. */
-export declare function restoreHtml(repo: string, retired: readonly Decision[], merges: readonly {
-    merge: number;
-    successor: number;
-    predecessors: number[];
-}[], lessons: readonly {
-    id: number;
-    observation: string;
-}[], manage: boolean): Html | '';

package/dist/landed-cleanup.d.ts

@@ -1,175 +0,0 @@
-import { type AssignmentSnapshot } from "./assignment.js";
-import type { RemoteMainRead, RemoteMains } from "./remote-main.js";
-import type { Store } from "./store.js";
-import { type Git } from "./teardown-git.js";
-import { type Runner, type WorktreePool } from "./worktree.js";
-/** `storage clean --landed` takes only what has waited at least this long. */
-export declare const BACKLOG_DAYS = 7;
-/** The local branches the one-time pass looks at: Toolroll's build and plan branches, under either name. */
-export declare const BACKLOG_PREFIXES: readonly string[];
-/** The ledger action that closes a teardown. */
-export declare const LANDED_CLEANED_ACTION = "landed work cleaned up";
-/** Reconcile looks at most this many results and finishes at most this many items a pass; the pass by hand has no cap. */
-export declare const AUTO_LOOKS = 20;
-export declare const AUTO_ITEMS = 40;
-export type { Git };
-/** Landed cleanup's git, reads and teardown alike: always the hardened teardown helper (teardown-git.ts). */
-export declare function gitOf(runner?: Runner): Git;
-export type LandedHow = "merged" | "in-main" | "content-in-main";
-/** `trusted`: it may complete a task automatically (a recorded merge, or the recorded remote's main). */
-export type LandedProof = {
-    landed: true;
-    how: LandedHow;
-    reason: string;
-    trusted: boolean;
-} | {
-    landed: false;
-    why: string;
-};
-/** What Toolroll last saw of the result's pull request. */
-export type PullRequestFact = {
-    merged: boolean;
-    headSha: string | null;
-    number: number | null;
-};
-/**
- * Whether this commit's work landed, read from what Toolroll recorded and the local repository. Fails closed: every
- * doubt is "not proven", with the reason in a few words. Only a recorded merge is trusted to complete a task: a build
- * can write the local main.
- */
-export declare function landedProof(git: Git, repo: string, head: string | null, pullRequest?: PullRequestFact | null): Promise<LandedProof>;
-/**
- * The proof automatic completion trusts: a recorded merge of this exact commit, or its work in the main of the
- * project's recorded remote, compared only in the private directory that main was fetched into. `remote` is read only
- * when no recorded merge settles it.
- */
-export declare function remoteLandedProof(remote: () => Promise<RemoteMainRead>, repo: string, head: string | null, pullRequest?: PullRequestFact | null): Promise<LandedProof>;
-export type LandedTarget = {
-    kind: "checkout" | "branch";
-    target: string;
-    expect: string;
-};
-export type LandedKeep = {
-    repo: string;
-    what: string;
-    why: string;
-};
-export type LandedCandidate = {
-    repo: string;
-    taskId: string;
-    rootId: string;
-    runId: number;
-    receipt: string;
-    head: string;
-    finishedAt: string;
-    /** False when it is already complete: only its teardown is left. */
-    completes: boolean;
-    how: LandedHow;
-    reason: string;
-    /** Proven by a recorded merge or the recorded remote's main: only then may it complete. */
-    trusted: boolean;
-    targets: LandedTarget[];
-    keeps: LandedKeep[];
-};
-/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
- * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
-export declare function completionProblem(store: Store, assignment: AssignmentSnapshot, root: string): string | null;
-/**
- * Results in a project whose work landed, with what their teardown would remove and what stays. Reads only.
- * `limit` caps how many results are read against git (reconcile's bound; results read before and unchanged since
- * don't count); `before` takes only results finished before it (the one-time pass's seven days).
- */
-export declare function landedResults(store: Store, git: Git, remotes: RemoteMains, repo: string, root: string, now: Date, options?: {
-    limit?: number;
-    before?: string;
-    memo?: boolean;
-}): Promise<{
-    found: LandedCandidate[];
-    kept: LandedKeep[];
-}>;
-/**
- * Mark a landed result complete (unless it already is) and record its teardown, in one transaction, bound to the
- * exact result read: refused when the result changed since. The completion's ledger entry says why. Returns the
- * teardown's id; a result already taken returns its existing teardown.
- */
-export declare function recordLandedIntent(store: Store, candidate: LandedCandidate, now: Date, root: string, actor?: string): {
-    ok: true;
-    id: number;
-    completed: boolean;
-} | {
-    ok: false;
-    why: string;
-};
-/** A landed branch no task names: its teardown, on its own. */
-export type LandedBranch = {
-    repo: string;
-    branch: string;
-    oid: string;
-    how: LandedHow;
-    reason: string;
-    checkout: string | null;
-};
-export declare function recordBranchIntent(store: Store, branch: LandedBranch, now: Date, actor: string): number;
-export type LandedStep = {
-    kind: "checkout" | "branch";
-    repo: string;
-    target: string;
-    taskId: string | null;
-    outcome: "removed" | "already gone" | "waits" | "kept";
-    why: string | null;
-};
-/**
- * Finish what teardowns intended: pending items, oldest first (checkouts before branches). Each is checked again
- * right before it goes, and recorded right after. Doubt leaves it pending for the next pass; a branch that moved, or
- * a result that has newer work, is kept for good. `limit` caps the items settled (removed, already gone or kept), so
- * items left waiting never crowd out later ones. `only` limits it to these teardowns.
- */
-export declare function finishLanded(store: Store, pool: WorktreePool, git: Git, remotes: RemoteMains, now: () => Date, options?: {
-    repo?: string;
-    limit?: number;
-    only?: ReadonlySet<number>;
-}): Promise<LandedStep[]>;
-/**
- * Reconcile's part: finish teardowns a crash cut short, then find newly landed results (a bounded few), mark them
- * complete and tear them down.
- */
-export declare function reconcileLanded(store: Store, pool: WorktreePool, git: Git, remotes: RemoteMains, repo: string, root: string, now: () => Date): Promise<{
-    completed: string[];
-    steps: LandedStep[];
-}>;
-export type LandedSummary = {
-    completed: number;
-    checkouts: number;
-    branches: number;
-    /** What a teardown still waits on, and why. */
-    waiting: {
-        target: string;
-        why: string | null;
-    }[];
-};
-/** What landed-work teardowns did so far, and what they still wait on (Settings → Storage). Reads only. */
-export declare function landedSummary(store: Store): LandedSummary;
-export type LandedPlan = {
-    at: string;
-    cutoff: string;
-    results: LandedCandidate[];
-    branches: LandedBranch[];
-    kept: LandedKeep[];
-    /** Items an earlier teardown still has to finish. */
-    pending: number;
-};
-/**
- * What `storage clean --landed` would do now, across every project: landed results finished at least a week ago,
- * and branches Toolroll created (toolroll/, toolroll-plan/, standing-orders/) at least a week ago that no task uses
- * and that landed in main. Reads only.
- */
-export declare function landedBacklog(store: Store, git: Git, remotes: RemoteMains, root: string, now: Date, options?: {
-    repos?: readonly string[];
-}): Promise<LandedPlan>;
-/** Act on a preview: record every teardown first, then carry them out. Refuses nothing it previewed silently: what
- * changed since is reported as kept. */
-export declare function cleanLandedBacklog(store: Store, pool: WorktreePool, git: Git, remotes: RemoteMains, root: string, now: () => Date, plan: LandedPlan, actor: string): Promise<{
-    completed: string[];
-    steps: LandedStep[];
-    refused: LandedKeep[];
-}>;

package/dist/laptop-background.d.ts

@@ -1,187 +0,0 @@
-/**
- * Keeping Toolroll running in the background on a laptop (easy-start plan D): `toolroll background on|off|show`,
- * `toolroll stop`, and the `laptop` part of `toolroll status`.
- *
- * The login item itself is laptop-service.ts's definition (com.toolroll.up / toolroll-up.service). This module is
- * the handoff around it:
- *
- * - **on** writes and validates the unit without loading it, stops the foreground `up` this invoker owns (if one runs
- *   for this database) by SIGTERM to its controller and waits until that controller's whole process record is proved
- *   gone by start identity and the port is free, then loads the unit and proves the console live within 30 s. Any
- *   failure boots the unit out, removes it (or puts back the one that was there), starts the foreground `up` again if
- *   it was stopped, and says what failed. An identical unit already loaded is left alone.
- * - **off** stops and removes only our own label.
- * - **stop**: with the service loaded, the supervisor stops it (it comes back at login); otherwise the controller of
- *   the proven console, found through its signed process record, gets SIGTERM — never the console child, which the
- *   controller would only start again.
- *
- * Every outside effect goes through LaptopSeams: tests give a temporary HOME, a scripted launchctl/systemctl, and their
- * own child processes. Without a supervisor seam, a test run (VITEST) refuses to reach the real launchctl or systemctl.
- * Other services (the desktop app's com.toolroll.browser, a watch on this database) are reported, never touched.
- */
-import { type AttachProof } from "./console-instance.js";
-import { type SupervisorRunner } from "./daemon.js";
-import { type LaptopConflict } from "./laptop-service.js";
-import { type ProcessProbe } from "./runner-process.js";
-import type { Runner } from "./runner.js";
-import { type Store } from "./store.js";
-/** Everything outside this process that the background handoff touches. Tests replace all of it. */
-export type LaptopSeams = {
-    platform?: NodeJS.Platform;
-    home?: string;
-    /** launchctl, systemctl, plutil and systemd-analyze. */
-    supervisor?: SupervisorRunner;
-    /** The absolute Node binary and package `dist` folder the unit pins (default: this process's). */
-    node?: string;
-    dist?: string;
-    pathEnv?: string;
-    /** A person at a terminal (stdin and stdout a TTY, no --json, not under a coding agent): only they may confirm. */
-    terminal?: boolean;
-    /** Run by a coding agent (prompt.ts underAgent): a login item is a person's own choice, so `on` refuses. */
-    agent?: boolean;
-    confirm?: (question: string) => Promise<boolean>;
-    /** Prove this database's console live (default: proveLiveConsole at this package's version). */
-    proveConsole?: (databaseFile: string, store: Store) => Promise<AttachProof>;
-    probe?: ProcessProbe;
-    /** A process's parent, or null when it can't be read. */
-    parentOf?: (pid: number) => number | null;
-    signal?: (pid: number, signal: NodeJS.Signals) => void;
-    portFree?: (port: number) => Promise<boolean>;
-    sleep?: (ms: number) => Promise<void>;
-    host?: string;
-    healthTimeoutMs?: number;
-    exitTimeoutMs?: number;
-    /** The build an installed unit would start, from its entry point (default: the version in that package's package.json). */
-    buildAt?: (entry: string) => string | null;
-    /** The foreground `up` this invoker started (the terminal UI's child): its controller's pid, and how to start it again. */
-    foreground?: {
-        controllerPid: number;
-        restart: () => Promise<void>;
-    };
-};
-export type BackgroundState = "on" | "off" | "other-service";
-type Resolved = Required<Omit<LaptopSeams, "foreground" | "node" | "dist" | "pathEnv">> & Pick<LaptopSeams, "foreground" | "pathEnv"> & {
-    node: string;
-    dist: string;
-};
-export type ControllerProof = {
-    /** The `up` process that started the console: the one to stop. */
-    pid: number;
-    started: string;
-    consolePid: number;
-    port: number;
-    url: string;
-    runner: string;
-    /** The registration whose signed record names both, captured now: the exit proof uses exactly it. */
-    holder: {
-        runner: Runner;
-        credentialHash: string;
-    };
-};
-/**
- * The controller of this database's live console, proved from the plane's own records: a live runner on this host
- * whose signed process record names the proven console (pid and start time) and exactly one live `up` process, that
- * `up` still the process the record names (same start time), and the console's parent that `up`. Anything else —
- * no record, a reused pid, a console whose parent is someone else — proves nothing and is refused.
- */
-export declare function findController(store: Store, databaseFile: string, console_: {
-    pid: number;
-    port: number;
-    url: string;
-}, s: Pick<Resolved, "probe" | "parentOf" | "host">): ControllerProof | {
-    why: string;
-};
-export type BackgroundShow = {
-    platform: NodeJS.Platform;
-    label: string | null;
-    unit: string | null;
-    installed: "same" | "different" | "absent";
-    loaded: boolean;
-    running: {
-        url: string;
-        pid: number;
-    } | null;
-    conflicts: LaptopConflict[];
-    port: number;
-};
-export declare function backgroundShow(store: Store, databaseFile: string, requestedPort: number | null, seams?: LaptopSeams): Promise<{
-    ok: true;
-    show: BackgroundShow;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-}>;
-export type BackgroundOn = {
-    ok: true;
-    action: "unchanged" | "installed" | "replaced";
-    label: string;
-    unit: string;
-    url: string;
-    pid: number;
-    stoppedForeground: boolean;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-    rolledBack?: string[];
-};
-/** `requestedPort`: --port, else the running console's, else the port this laptop install saved, else `up`'s default. */
-export declare function backgroundOn(store: Store, databaseFile: string, requestedPort: number | null, seams?: LaptopSeams): Promise<BackgroundOn>;
-export type BackgroundOff = {
-    ok: true;
-    action: "removed" | "already-off";
-    label: string;
-    unit: string;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-export declare function backgroundOff(store: Store, databaseFile: string, seams?: LaptopSeams): Promise<BackgroundOff>;
-export type LaptopStop = {
-    ok: true;
-    action: "service-stopped" | "stopped" | "not-running";
-    pid: number | null;
-    startsAtLogin: boolean;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-export declare function laptopStop(store: Store, databaseFile: string, seams?: LaptopSeams): Promise<LaptopStop>;
-export type LaptopStatus = {
-    running: boolean;
-    url: string | null;
-    pid: number | null;
-    background: BackgroundState;
-};
-/**
- * The `laptop` key of `toolroll status`: whether this database's console is proven live (its address and the console
- * process), and whether a background service runs it — ours ("on"), another service on this database or the desktop
- * app's ("other-service"), or none ("off"). Reads files only; never asks the supervisor.
- */
-export declare function laptopStatus(store: Store, databaseFile: string, seams?: LaptopSeams): Promise<LaptopStatus>;
-/** Whether Toolroll's own login item is installed here (its unit file exists). Reads one path; asks no supervisor. */
-export declare function backgroundInstalled(seams?: LaptopSeams): boolean;
-/**
- * Bare `toolroll` and `toolroll open` with the background service installed but this database's console not running
- * (stopped with `toolroll stop`, or not yet started at this login): start it through its supervisor — never a second
- * `up` beside it — and prove the console it runs live. Our own label only.
- */
-export declare function startInstalledService(store: Store, databaseFile: string, seams?: LaptopSeams): Promise<AttachProof>;
-export type BuilderRestart = {
-    restarted: true;
-} | {
-    restarted: false;
-    reason: "unsupported" | "not-installed" | "not-wanted" | "paused" | "running" | "unproven" | "disabled" | "identity" | "attempts" | "failed";
-    message?: string;
-};
-/**
- * Start our own service again, by Toolroll alone, only when a person's recorded wish is to run, nothing is stopping or
- * updating, the old process is proved gone, what would start is what ran, and it isn't over its attempts. Every other
- * answer leaves the need with one label, "Start the builder". This never enables a disabled label, which is what sets it
- * apart from `startService`: a person's own yes.
- */
-export declare function restartOwnBuilder(store: Store, databaseFile: string, seams?: LaptopSeams, now?: Date): Promise<BuilderRestart>;
-export {};

package/dist/laptop-service.d.ts

@@ -1,111 +0,0 @@
-/**
- * The laptop-mode login item, generated and compared — never installed.
- *
- * Laptop mode keeps one `toolroll up --laptop` console running for the
- * person who is logged in: a launchd LaunchAgent on macOS
- * (~/Library/LaunchAgents/com.toolroll.up.plist), a systemd user unit on
- * Linux (~/.config/systemd/user/toolroll-up.service). This module only
- * computes what that definition would be, whether an installed one matches,
- * and which existing services would conflict with it. Nothing here writes a
- * unit, loads one, or calls launchctl or systemctl; the handoff that does
- * (`toolroll background on`) is laptop-background.ts.
- *
- * The command is pinned with absolute paths, as daemon.ts pins its services:
- * launchd and systemd do not inherit an interactive shell's PATH, so the unit
- * runs the absolute Node binary with the package entry, and the database is
- * the canonical path (realpath of its folder) so a symlinked folder and its
- * target are one database. Values with control characters are refused: a
- * newline would end a systemd line and a NUL cannot appear in either format.
- *
- * Conflicts are reported, never touched: the desktop/browser service
- * (com.toolroll.browser, and com.standing-orders.browser from before the
- * rename) and any `daemon install` watch whose unit points at the same
- * database. Whatever cannot be read counts as a conflict, so the caller asks
- * instead of assuming.
- */
-export declare const LAPTOP_LABEL_DARWIN = "com.toolroll.up";
-export declare const LAPTOP_LABEL_LINUX = "toolroll-up";
-/** The services laptop mode never runs beside on macOS: the desktop app's browser controller, either name. */
-export declare const BROWSER_SERVICE_LABELS: readonly ["com.toolroll.browser", "com.standing-orders.browser"];
-export type LaptopServiceDefinition = {
-    platform: "darwin" | "linux";
-    label: string;
-    /** Where the unit file goes. */
-    path: string;
-    /** The unit file's exact text. */
-    text: string;
-    /** definitionDigest(text): equal digests mean installing again is a no-op. */
-    digest: string;
-    /** The pinned command, argument by argument. */
-    command: string[];
-    /** The canonical database path baked into the command. */
-    db: string;
-    logPath: string;
-};
-/** Seam over the few filesystem reads this module makes; tests pass a temp HOME instead of the real one. */
-export type LaptopServiceFs = {
-    exists: (path: string) => boolean;
-    readFile: (path: string) => string;
-    readdir: (path: string) => string[];
-    realpath: (path: string) => string;
-};
-export declare const nodeFs: LaptopServiceFs;
-/**
- * The database path the unit names: its folder resolved through realpath,
- * its file name kept (the file may not exist yet). A relative, empty or
- * control-character path, or a folder that cannot be resolved, refuses.
- */
-export declare function canonicalDatabasePath(db: string, fs?: Pick<LaptopServiceFs, "realpath">): string | {
-    error: string;
-};
-/**
- * The login item for laptop mode, computed without writing anything. On
- * macOS the text comes from daemon.ts's launchdPlist, so it carries the same
- * KeepAlive/ExitTimeOut contract and the same service digest (which binds the
- * runtime's and package's code, read only). On Linux it is a systemd user
- * unit in daemon.ts's shape, with systemd's `%` and `$` expansion escaped.
- */
-export declare function laptopServiceDefinition(args: {
-    platform: NodeJS.Platform;
-    home: string;
-    /** The absolute Node binary the unit runs. */
-    node: string;
-    /** The absolute package `dist` folder; the unit runs `<dist>/bin.js`. */
-    dist: string;
-    db: string;
-    port: number;
-    /** The executable search path pinned into the unit (daemon.ts's approach); defaults to this process's PATH. */
-    pathEnv?: string;
-    fs?: Pick<LaptopServiceFs, "realpath">;
-}): LaptopServiceDefinition | {
-    error: string;
-};
-/** Whether an installed unit's text is exactly this definition. Null (or undefined) text means no unit is installed. */
-export declare function compareInstalled(existingText: string | null | undefined, definition: Pick<LaptopServiceDefinition, "text" | "digest">): "same" | "different" | "absent";
-export type LaptopConflict = {
-    kind: "browser" | "watch";
-    label: string;
-    path: string;
-    /** Plain words for the person who will be asked. */
-    reason: string;
-};
-/**
- * Existing services laptop mode must not run beside: the browser service on
- * macOS (whatever database it uses — it is a console of its own), and any
- * daemon.ts watch whose unit points at this database, by `--db` or by its
- * `--token-file` sitting in the database's folder (daemon install keeps the
- * runner token beside the database it was installed from). A unit that
- * cannot be read is listed too. Laptop mode's own unit is never a conflict.
- */
-export declare function detectOtherServices(args: {
-    platform: NodeJS.Platform;
-    home: string;
-    db: string;
-    fs?: LaptopServiceFs;
-}): LaptopConflict[] | {
-    error: string;
-};
-/** The command an installed unit runs, argument by argument (a plist's ProgramArguments, a unit's ExecStart). */
-export declare function unitCommand(text: string, platform: "darwin" | "linux"): string[];
-/** The value after `flag` in an installed unit's command, or null. */
-export declare function unitFlag(text: string, platform: "darwin" | "linux", flag: string): string | null;