toolroll 0.9.103 → 0.9.105

package/dist/worktree.d.ts

@@ -1,365 +0,0 @@
-/**
- * The pool of working copies, and the leases over them.
- *
- * Semantics copied from treehouse rather than reinvented, including the two
- * rules that are easy to get wrong and expensive to get wrong quietly:
- *
- * **Untracked files count as dirty.** A repository whose `.gitignore` hides
- * build output is still a repository with somebody's work in it, and a pool
- * that recycles a directory because `git status` looked clean under the
- * operator's config will delete something they wanted. So the check is run
- * with ignored files excluded but untracked files included, which is the
- * conservative reading of "is anyone using this".
- *
- * **Reconstructed state is leased-until-verified.** A worktree found on disk
- * after a crash describes what a dead process was doing, not what is true now.
- * It comes back into the pool marked unverified, and something has to look at
- * it before it is handed to anybody.
- *
- * Where the pool lives is a decision, not a detail. Worktrees are created
- * outside the repository — never inside it, where they would appear as
- * untracked directories in the operator's own `git status`, and never inside a
- * synced folder like OneDrive or Dropbox, where a sync client racing an agent
- * over `.git` internals corrupts both.
- */
-import { type ExecResult, type RunOptions } from "./exec.js";
-import type { Store, WorktreeRow } from "./store.js";
-import { type Git } from "./teardown-git.js";
-export type Runner = (file: string, args: readonly string[], options?: RunOptions) => Promise<ExecResult>;
-export type PoolOptions = {
-    /** Where worktrees are created. Outside the repo, and outside any sync root. */
-    root: string;
-    runner?: Runner;
-};
-export type LeaseRequest = {
-    repo: string;
-    branch: string;
-    runner: string;
-    taskRef?: number;
-    now: Date;
-    /** Branch to create from, when the branch does not exist yet. */
-    base?: string;
-    /**
-     * Reclaim this task's OWN leftover: when the checkout was released dirty
-     * by a finished attempt of the same task (not a dead runner's, not
-     * another task's), keep what it left as a patch under the last run's
-     * evidence and reset the tree for the next attempt. Without this a
-     * failed attempt's half-edit blocks every retry forever.
-     */
-    reclaim?: {
-        evidenceRoot: string;
-    };
-    /** With `base`: a branch that already exists (its checkout removed by storage retention) is checked out as it
-     * stands, as its kept checkout would have been reused. Without it, `base` always starts a new branch (and an
-     * existing one refuses). */
-    reuseBranch?: boolean;
-    /**
-     * Start from current main (fresh base): a checkout still at its recorded base — no commits of its own — and with no
-     * changes moves, with its branch, to `main` before the attempt. Anything else is never moved; the result says how
-     * far behind main it is. Needs `taskRef`. `recordedBase` null means no attempt on the branch recorded one yet, and
-     * then only a HEAD that main already contains counts as having no commits of its own.
-     */
-    freshBase?: {
-        main: string;
-        recordedBase: string | null;
-    };
-};
-/** Where a checkout stands against current main once its lease is granted (fresh base). */
-export type BaseStanding = {
-    /** HEAD as the attempt starts. */
-    head: string;
-    /** Current main's commit. */
-    main: string;
-    /** Commits on main that HEAD does not have. */
-    behind: number;
-    /** Set when this lease moved the checkout to main: where it was, and how far behind that was. */
-    moved: {
-        from: string;
-        behind: number;
-    } | null;
-    /** Why a checkout behind main stayed where it is. */
-    kept: "has commits" | "has changes" | "not on its branch" | null;
-};
-export type LeaseResult = {
-    ok: true;
-    worktree: WorktreeRow;
-    created: boolean;
-    reclaimed?: string;
-    resumedFromRun?: number;
-    recoveryKind?: "completed" | "partial";
-    /** With `freshBase`: where the checkout stands against main (null when main could not be read). */
-    base?: BaseStanding | null;
-} | {
-    ok: false;
-    reason: LeaseFailure;
-    message: string;
-};
-export type LeaseFailure = "held" | "dirty" | "git" | "unverified" | "unknown-runner" | "in-use";
-/** Why storage retention left a checkout in place. */
-export type KeptWhy = "has changes" | "has commits" | "not on its branch" | "unreadable" | "git refused";
-/**
- * The note a lease leaves in the checkout, naming the process holding it.
- *
- * Deliberately inside the worktree rather than beside it: it travels with the
- * directory, and `git status` will show it as untracked, which is honest —
- * something is in there.
- */
-export declare const MARKER = ".standing-orders-lease";
-/**
- * The reflog message of a branch Toolroll created, naming it: its creation entry is the proof, later, that the branch
- * is Toolroll's and how old it is. A branch copied or renamed from it names the old branch, so it proves nothing.
- */
-export declare const branchCreatedMessage: (branch: string) => string;
-/** Scouts' disposable branches: never landed work. */
-export declare const SCOUT_PREFIX = "toolroll-scout/";
-/** What a kept checkout drops once its run ends (only where .gitignore hides it): dependencies and build output. */
-export declare const SLIM_NAMES: readonly string[];
-/** Creating a worktree copies a tree; it is local work but not instant. */
-export declare const WORKTREE_TIMEOUT_MS = 60000;
-/**
- * A path for this repository and branch that is stable across runs.
- *
- * Stable so that a second attempt at the same task reuses the checkout it
- * already paid for, and flattened so a branch called `feat/a/b` cannot escape
- * the pool root through its own slashes.
- */
-export declare function worktreePath(root: string, repo: string, branch: string): string;
-/** The pool root a checkout at `path` of `repo` was made under (worktreePath's layout), or null for one it didn't make. */
-export declare function poolRootOf(path: string, repo: string): string | null;
-/** Record a potentially writing subprocess against the original checkout lease. */
-export declare function recordWorktreeProcess(store: Store, path: string, runner: string, pid: number, leaseEpoch?: string | null): void;
-/** Read-only occupancy witness shared with stop settlement. */
-export declare function worktreeProcessOccupancy(path: string): {
-    held: true;
-    by: number;
-} | {
-    held: false;
-};
-/**
- * A checkout's uncommitted work as one patch — tracked changes against HEAD,
- * then each untracked file against nothing (the lease note aside) — written
- * to `file`. Nothing in the checkout is touched. Every road that is about to
- * reset or clean a tree saves this first.
- */
-export declare function saveWorkPatch(runner: Runner, path: string, file: string, header: string): Promise<{
-    ok: true;
-    file: string;
-} | {
-    ok: false;
-    message: string;
-}>;
-export declare class WorktreePool {
-    private readonly store;
-    private readonly options;
-    private readonly runner;
-    /** The pool's own git in a project's repository and its checkouts (making, moving and reading them): hardened against
-     * a frozen view of the repository's config and info (teardown-git.ts checkoutGit), which agents can write. An injected
-     * runner (tests' stubbed git) is used as given. */
-    private readonly hardened;
-    /** Carried to the independent storage sweep process. */
-    get root(): string;
-    constructor(store: Store, options: PoolOptions);
-    /**
-     * Take a working copy for this branch.
-     *
-     * Refused when somebody else holds it — losing is ordinary, and a caller
-     * that is told who holds it can go and do something else rather than poll.
-     */
-    /**
-     * Whether a live process is working in there, independently of what the
-     * database believes.
-     *
-     * treehouse's rule, and it exists because the database is the thing most
-     * likely to be wrong: a row saying "released" written by a process that then
-     * kept running, or a stale row from a crash, are both cases where the
-     * checkout is genuinely occupied and only the machine can say so. So each
-     * lease drops a note naming the process holding it, and `process.kill(pid, 0)`
-     * — which signals nothing and only asks whether the pid exists — is what
-     * answers the question afterwards.
-     *
-     * A pid can be recycled by the operating system, so this can say "in use"
-     * about a stranger. That is the safe direction: refusing a checkout somebody
-     * may be in costs a retry, and taking one they are in costs their work.
-     */
-    inUse(path: string): {
-        held: true;
-        by: number;
-    } | {
-        held: false;
-    };
-    /**
-     * Once a provider exists it, not the supervising console, is the process
-     * whose liveness protects this checkout. Rewriting the occupancy marker at
-     * spawn means a replacement control plane waits for an orphaned provider
-     * to finish instead of starting a second writer in the same worktree.
-     */
-    markProviderOccupancy(path: string, runner: string, providerPid: number, leaseEpoch?: string | null): boolean;
-    /** Spawn callbacks must fail if custody cannot be recorded. The transport
-     * kills and reaps its child before returning that callback failure. */
-    recordProviderOccupancy(path: string, runner: string, providerPid: number, leaseEpoch?: string | null): void;
-    lease(request: LeaseRequest): Promise<LeaseResult>;
-    private leaseNow;
-    /**
-     * Move an untouched checkout to current main, or say how far behind it is. Untouched means all three: on its own
-     * branch, HEAD still the recorded base (or, with none recorded, a commit main already has), and nothing changed or
-     * untracked. The move is `git reset --keep`, which refuses rather than overwrite anything; HEAD and the tree are read
-     * again right before and after it, and any surprise fails the lease with the checkout left for a person.
-     */
-    private freshen;
-    /**
-     * A crash can strand either a finished handoff or a partial source draft.
-     * The expired lease can no longer authorize a commit, so this never ingests
-     * the old result. It classifies the recovery context for the next freshly
-     * fenced attempt, which must review and prove the inherited work itself.
-     */
-    private recoverableDraft;
-    /**
-     * Preserve a dirty tree's work as one patch — tracked changes against
-     * HEAD, then each untracked file against nothing — under the evidence of
-     * the last run that lived in this checkout (or a leftover folder when no
-     * run is on record). Nothing is deleted here.
-     */
-    private keepLeftover;
-    /** Back to HEAD, untracked gone, our lease note kept; proven clean after. */
-    private resetTree;
-    /** Leave a note naming the process holding this checkout. */
-    private mark;
-    /**
-     * Hand a working copy back.
-     *
-     * The tree is inspected first, and dirt is reported rather than cleaned.
-     * `git reset --hard` leaves untracked files behind and destroys work that
-     * might have been repairable, which is why the failure taxonomy this project
-     * borrows says to preserve a failed commit rather than blanket-reset.
-     */
-    release(path: string, now: Date): Promise<LeaseResult>;
-    /**
-     * Worktrees git knows about that this pool does not, and the reverse.
-     *
-     * The first is somebody else's business and is left alone. The second is
-     * ours: a row for a directory that is no longer there, which happens when a
-     * machine is reimaged or a pool root is deleted between runs.
-     */
-    /**
-     * Remove a released checkout and its branch (v4 review, finding 3): the
-     * read-only roles' workspaces are disposable, so the next attempt starts
-     * from the requested base instead of whatever the last one saw. Refused
-     * while a process holds the directory; a failure leaves the checkout
-     * where `worktrees` can see it rather than pretending it is gone.
-     */
-    discard(path: string, now: Date): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        message: string;
-    }>;
-    orphans(repo: string): Promise<{
-        ok: true;
-        untracked: string[];
-        missing: string[];
-    } | {
-        ok: false;
-        message: string;
-    }>;
-    /**
-     * Take responsibility for worktrees that exist but nothing recorded.
-     *
-     * These turn up after a crash between `git worktree add` and the row that
-     * should have followed it, or when a database is replaced while checkouts
-     * survive on disk. Left alone they are invisible: git knows about them,
-     * every pool query does not, and the same branch gets checked out again
-     * beside them.
-     *
-     * Adopted **released and unverified**, never leased. Nobody watched them
-     * being made, so they are a claim about the past — the same rule that
-     * governs a dead runner's worktrees, for the same reason.
-     *
-     * Rows whose directory is gone are dropped: a lease over a path that does
-     * not exist can only refuse work that could otherwise have run.
-     */
-    adopt(repo: string, now: Date): Promise<{
-        ok: true;
-        adopted: string[];
-        forgotten: string[];
-    } | {
-        ok: false;
-        message: string;
-    }>;
-    /**
-     * Whether a let-go checkout could go without losing anything: clean (build output that .gitignore hides is not
-     * work, and neither are the files Toolroll itself wrote in there), and everything its HEAD reaches on a branch, tag
-     * or remote. Reads only, through `git` when given (teardown's hardened git).
-     */
-    inspect(path: string, git?: Git): Promise<"clean" | KeptWhy>;
-    /**
-     * Whether a checkout a task may still come back to can go, beyond `inspect`: a later lease of its branch must make the
-     * same checkout, and every commit its task recorded must outlive it (git's garbage collection counts a worktree's HEAD
-     * and reflog; once they go only a branch holds a commit). So: the folder is the pool's own, the checkout belongs to its
-     * project by the plane's record (`boundDirs`, not its `.git` file), its HEAD is its recorded branch, every recorded
-     * `heads` commit is on a branch, and no ref lives only in this worktree. Reads only; anything unreadable keeps it.
-     */
-    proveRecreatable(row: WorktreeRow, heads: readonly string[]): Promise<"clean" | KeptWhy>;
-    /**
-     * Keep storage in check: remove the working copies nobody needs any more. Of `rows`, a checkout goes when it is
-     * let go, nothing holds it, `wanted` says it may go (asked again right before it goes, so a task coming back or a
-     * lease since keeps it) and `inspect` finds it clean, then clean still right before it goes (git refuses an edit
-     * made after that). Only the working copy goes: its branch, and so every commit,
-     * stays, and a later lease of the same branch makes a new one. At most `max` go per pass. Every git command goes
-     * through `git` when given: landed cleanup passes its hardened teardown git (teardown-git.ts). `proof` is asked last,
-     * inside the reservation, for what `inspect` doesn't cover (idle cleanup: `proveRecreatable`).
-     */
-    prune(rows: readonly WorktreeRow[], wanted: (row: WorktreeRow, fresh: boolean) => boolean | Promise<boolean>, max?: number, git?: Git, proof?: (row: WorktreeRow) => Promise<"clean" | KeptWhy>): Promise<{
-        removed: WorktreeRow[];
-        kept: {
-            path: string;
-            why: KeptWhy;
-        }[];
-    }>;
-    /**
-     * Drop a let-go, idle checkout's dependencies and build output: the folders .gitignore hides that are named like
-     * them (SLIM_NAMES). Its work, tracked or untracked, is untouched. The setup stamp goes first, so the next lease
-     * runs the project's setup again and restores them. `wanted` is asked again right before anything goes; `deps`
-     * false keeps node_modules (no setup would restore it).
-     */
-    slim(row: WorktreeRow, wanted: (row: WorktreeRow) => boolean, deps?: boolean): Promise<{
-        ok: true;
-        dropped: string[];
-        bytes: number;
-    } | {
-        ok: false;
-        message: string;
-    }>;
-    /**
-     * Throw away a let-go checkout kept for its changes, on purpose: the working copy and what is uncommitted in it
-     * go; its branch, and every commit on it, stays. Refused while anything holds it.
-     */
-    discardChanges(path: string): Promise<{
-        ok: true;
-        row: WorktreeRow;
-    } | {
-        ok: false;
-        message: string;
-    }>;
-    /** Throw away one idle checkout's working copy, changes and all (the caller holds it in `busy`), and forget its row.
-     * Only `discardChanges`, where losing them is what a person asked for. */
-    private removeWorkingCopy;
-    /**
-     * Remove one idle checkout's working copy only while it is still clean (the caller holds it in `busy`, and its
-     * reservation outside the checkout holds it for other processes): inspected once more right before it goes, then
-     * removed without --force, so git itself refuses an edit made since. Only Toolroll's own files go first, because
-     * git's check would count them.
-     */
-    private removeCleanCopy;
-    private forgetRemoved;
-    /**
-     * Whether anybody's work is in there. null means we could not tell, which is
-     * neither clean nor dirty and must not be rounded to either.
-     *
-     * `--untracked-files=all` and no `--ignored`: build output that .gitignore
-     * hides is not work, but a file somebody dropped in and never staged is.
-     */
-    private isDirty;
-    /** All disposal and inspection paths share the hardened teardown boundary. */
-    private readonly teardown;
-    private git;
-}

package/dist/writes-mode.d.ts

@@ -1,9 +0,0 @@
-/**
- * Where a build may write (docs/plans/agent-baseline-hardening.md arc 2). `workspace`: only its allowlist (agent-fence.ts
- * WriteAllowlist), whatever its permission mode; `anywhere`: anywhere its fence doesn't deny, as builds did before.
- */
-export type WritesMode = "workspace" | "anywhere";
-export declare const WRITES_DEFAULT: WritesMode;
-export declare const isWritesMode: (value: unknown) => value is WritesMode;
-/** What an approval card and the CLI say of where a build may write (absent: sealed before write allowlists). */
-export declare function writesWords(writes: WritesMode | undefined): string;

package/dist/youiyoux-intake.d.ts

@@ -1,234 +0,0 @@
-/**
- * youiyoux change and options requests become tasks (docs/guide/getting-started.md, "Change requests from youiyoux").
- *
- * youiyoux is a design-system tool: in its hub a person points at a component on a screenshot of their app and asks
- * for a change, and it saves the request as `<project>/.youi/requests/<id>.json` (`youi.request/v1`). A project that
- * uses youiyoux (a `youi.project.json` at its root, or a `.youi/requests` folder) has this intake on with no step of
- * its own, unless a person turned it off in Settings → Integrations.
- *
- * On the worker's flow pass this reads the project's main checkout — the path from Toolroll's own records, resolved
- * with realpath — and files each open change request with a task exactly once, keyed by the project and the request
- * id in `youiyoux_request`: never again, whatever the file says later. Everything in the folder is outside text,
- * written by whoever can write the project's folder:
- *
- * - the folders and files must be real (never a link), a file a single link to itself, at most 64 KB, read without
- *   following a link or waiting on a pipe, and at most 200 are read in one pass;
- * - a file whose name, schema or id is wrong is counted (the integration says so) and never filed;
- * - text that looks like a key or password is left out (recorded once, never filed), as flow triggers do;
- * - a path the task may touch is kept only when youiyoux knew them all and every one is a plain relative path;
- * - the task is filed through the one filing door (proposal.ts) by the "youiyoux" automation, unplanned, and waits
- *   for a person: its provenance (`filed_via = 'youiyoux'`) keeps every seal no person looked at off it (store.ts,
- *   the outside-request quarantine), so no operating mode, grant, schedule or automatic seal approves it. A person
- *   approves it in Toolroll, or with their own two taps in their paired chat where they turned approving from chat
- *   on (chat-decide.ts), bound to the exact scope the card showed.
- *
- * Beside each request it writes `<id>.task.json` (`youi.request-task/v1`): the task and its status, and, when the
- * console has an address (the one the installation names, else this machine's own console where `up` serves it, on
- * loopback), the task's link and `home`, where a person approves all waiting work. It is written when filed, whenever
- * the status changes, and once more when that address changes. Beside an options request's options file (below), it is
- * the only file it writes in the checkout: written whole (a temporary file in the same folder, then renamed over),
- * refused when the folder or the target is a link, never the request itself. The status is also kept in the store;
- * nothing Toolroll decides reads the file back.
- *
- * Status words (task-status.ts headline → youiyoux): Queued → queued; Planning, Building and Waiting (work going on
- * by itself) → building; Needs you → needs-you; Ready for review → ready; Complete → done; Failed → failed;
- * Stopped → stopped.
- *
- * An options request (`kind: "options"`) asks an agent for two to four options for one component, which youiyoux shows
- * on its Screens canvas. It is filed the same way, once, waiting for a person, and only as youiyoux's contract has it:
- * its offer names `p-<its own hex>`, that proposal's file `.youi/proposals/p-<hex>.json`, and the task may touch that
- * one file (anything else is counted as a file that couldn't be read, and never filed). The proposal it names is kept
- * when filed; the request is never read for it again. Then (runYouiyoux, the worker's pass):
- *
- * - When the task is Ready for review (or Complete), its result is read: the file at the result's commit, the commit
- *   Toolroll recorded for the build (never the checkout the agent had, which it controls and the pool hands on), read
- *   with the hardened git (teardown-git.ts). It must be a plain file in that commit (never a link), at most 64 KB, a
- *   `youi.proposal/v1` file whose id is the proposal, which answers this request, still open (an agent proposes; only a
- *   person decides), by an agent, with no key-like text. Then it is copied, byte for byte, into the project's main
- *   checkout as `.youi/proposals/<id>.json` the way the status file is written (folders real, never through a link;
- *   a temporary file, then linked into place, which never replaces a file already there: a person may have decided on
- *   it). A file missing from the result, or one that isn't safe, is said in the status file and never copied; a newer
- *   result is read again.
- * - Only a file Toolroll copied is read for a decision: one already at that name is left as it was (a person may
- *   have decided on it) and never read for one, unless it is byte for byte the result's (an earlier pass's copy).
- * - When that copy says a person chose an option or dismissed them all (youiyoux's hub writes that), and it is still
- *   the proposal copied (only its status, choice, decidedBy, decidedAt, request and updatedAt may differ), decided by
- *   a person, at a time, the task is marked complete by Toolroll, as landed work is (result-completion.ts LANDED_ACTOR), without
- *   merging or publishing its branch: its deliverable was the options, and youiyoux has used them. Only the exact
- *   result whose file was copied, and only through every guard a person's completion passes (landed-cleanup.ts
- *   completionProblem): otherwise it stays Ready for review and the ledger says why. The ledger keeps who decided
- *   what, as youiyoux wrote it (outside text, cleaned). A decision never approves, publishes or merges anything.
- */
-import type { Store } from "./store.js";
-import type { Headline } from "./task-status.js";
-import { type Git } from "./landed-cleanup.js";
-import { YOUIYOUX_FILED_VIA, type YouiyouxRequest, type YouiyouxRequestTask, type YouiyouxTaskStatus } from "./contracts/youiyoux-request.js";
-export { YOUIYOUX_FILED_VIA };
-/** Who files the tasks: an automation, like a flow trigger. */
-export declare const YOUIYOUX_ACTOR = "youiyoux";
-export declare const REQUEST_BYTES: number;
-export declare const REQUESTS_PER_PASS = 200;
-export declare const FILED_PER_PASS = 10;
-/** The ledger's word for a decision youiyoux's hub made on a task's options. */
-export declare const OPTIONS_DECIDED_ACTION = "youiyoux options decided";
-export declare const OPTIONS_COPIED_ACTION = "youiyoux options copied";
-/** The flow pass runs every 15 seconds; the folder is read at most this often. */
-export declare const INTAKE_EVERY_MS = 30000;
-export declare const STATUS_OF_HEADLINE: Readonly<Record<Headline, YouiyouxTaskStatus>>;
-/** Whether a project uses youiyoux: a `youi.project.json` at its root, or a `.youi` folder. Only their presence is
- * read here (a link counts, so the integration can say it is Broken); requestsFolder decides what may be read. */
-export declare function usesYouiyoux(repo: string): boolean;
-/** The paths a request may touch: every one a plain relative path inside the project, or none at all. */
-export declare function safeTouches(touches: readonly string[]): string[] | null;
-export type RequestTask = {
-    title: string;
-    goal: string;
-    outOfScope: string | null;
-    touches: string[];
-    acceptance: {
-        id: string;
-        statement: string;
-        how: null;
-        evidence: string[];
-    }[];
-    /** Where the person pointed, for the task page: the route, the component, and `file:line` when youiyoux knew a plain one. */
-    pointed: {
-        route: string;
-        component: string;
-        at: string | null;
-    };
-};
-/** The task a request asks for, in Toolroll's terms. Text is cleaned here; whether it may be filed is decided by the caller. */
-export declare function requestTask(request: YouiyouxRequest): RequestTask;
-/** A person turns the intake off or back on for a project; the ledger keeps who. */
-export declare function setYouiyouxIntake(store: Store, repo: string, on: boolean, by: string, now: Date): void;
-export type YouiyouxState = {
-    /** The project uses youiyoux, as the worker's last pass found. */
-    uses: boolean;
-    /** Requests become tasks: it uses youiyoux and nobody turned it off. */
-    on: boolean;
-    /** A person turned it off. */
-    off: boolean;
-    /** Filed tasks not yet done, failed or stopped. */
-    queued: number;
-    filed: number;
-    invalid: number;
-    problem: string | null;
-    checkedAt: string | null;
-};
-/** How the intake stands for one project, from the store alone: a page reads it on every render, so it never reads the
- * project's folder (one that doesn't answer must not hold the console). Whether it uses youiyoux is the last pass's. */
-export declare function youiyouxState(store: Store, repo: string): YouiyouxState;
-/** The one line `toolroll onboard` says for a project that uses youiyoux; null when it doesn't. */
-export declare function youiyouxOnboardLine(store: Store, repo: string): string | null;
-/** The console the links name: the address the installation names (CONSOLE_URL or the console-url file), else, with
- * none named, this machine's own console where `up` serves it (loopback http only, never a guessed host); null without
- * either. Either way http(s) with no credentials, query or fragment. */
-export declare function consoleBase(env: Record<string, string | undefined>, dir: string | null): string | null;
-/** The task's page in that console; null without one. */
-export declare function taskLink(env: Record<string, string | undefined>, dir: string | null, taskId: string): string | null;
-/**
- * Write `<id>.task.json` beside its request, whole. The folders are checked again now (a link is refused), the request
- * must still be a plain file, the target must be a plain file or absent, and the content goes to a fresh temporary file
- * in the same folder (created exclusively, never through a link) that is then renamed over the target.
- */
-export declare function writeStatusFile(repo: string, body: YouiyouxRequestTask): {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * Put an options file into the project's main checkout as `.youi/proposals/<id>.json`, whole, and never over a file
- * already there (a person may have decided on it). The folders are checked as the status file's are (`.youi/proposals`
- * is made, as a real folder, when missing), the content goes to a fresh temporary file in the same folder (created
- * exclusively, never through a link), the folders are checked again, and the temporary file is linked into place, which
- * fails rather than replace anything at that name, a link included. `same`: that exact content was already there;
- * `taken`: something else was, and is left as it was.
- */
-export declare function writeProposalFile(repo: string, id: string, text: string): {
-    ok: true;
-    made: "written" | "same" | "taken";
-} | {
-    ok: false;
-    problem: string;
-};
-/** `git`: the hardened git an options request's result is read with (landed-cleanup.ts gitOf), and `evidenceRoot`, where
- * results' saved evidence is (a completion is bound to the receipt read with it). Without either, options wait. */
-export type YouiyouxIo = {
-    dir: string | null;
-    env: Record<string, string | undefined>;
-    git?: Git;
-    evidenceRoot?: string | null;
-};
-/** `copied`: options files that went to the hub; `decided`: decisions in the hub Toolroll acted on. */
-export type YouiyouxPass = {
-    filed: number;
-    skipped: number;
-    invalid: number;
-    updated: number;
-    copied: number;
-    decided: number;
-    problems: string[];
-};
-export declare const NO_YOUIYOUX_PASS: Readonly<YouiyouxPass>;
-/** File one request's task, exactly once: the claim and the filing are one transaction (two passes, in two processes
- * or one, make one task). */
-export declare function fileYouiyouxRequest(store: Store, repo: string, request: YouiyouxRequest, now: Date): {
-    made: "filed";
-    taskId: string;
-} | {
-    made: "seen";
-} | {
-    made: "skipped";
-    note: string;
-};
-/**
- * One message for what a pass filed, however many: the person's paired chats draw it as one card (chat-decide.ts) that
- * lists each new task, with Approve all and each one's own Approve and Open, and a phone push links to what needs
- * them. Keyed by the pass's first task, so a pass says it once; the tasks are the ones filed with it (one project, one
- * moment: requestPassOf). Titles are cleaned outside text, as filed.
- */
-export declare function noteYouiyouxFiled(store: Store, taskIds: readonly string[], now: Date): void;
-/** What a pass's tasks were asked for, in a word: "change request", "options request", or "request" for both. */
-export declare function requestKindWord(store: Store, taskIds: readonly string[]): string;
-/** The tasks one pass filed beside this one (one project, one moment), in request order; empty for any other task. */
-export declare function requestPassOf(store: Store, taskId: string): string[];
-/**
- * One project's pass: read new requests and file them, then write each filed task's status where it changed (no
- * options moved: runYouiyoux does that too). The folder read is the project in Toolroll's records that `given`
- * resolves to; anything else is left alone.
- */
-export declare function runYouiyouxIntake(store: Store, given: string, now: Date, io: YouiyouxIo, options?: {
-    force?: boolean;
-}): YouiyouxPass;
-/** The worker's pass for one project (flow-cadence.ts): the intake, then each options request's options, both ways. */
-export declare function runYouiyoux(store: Store, given: string, now: Date, io: YouiyouxIo, options?: {
-    force?: boolean;
-}): Promise<YouiyouxPass>;
-export type OptionsRow = {
-    request: string;
-    taskId: string;
-    proposal: string;
-    state: string | null;
-    run: number | null;
-    digest: string | null;
-};
-/** The digest of an options file apart from what a decision changes: the proposal itself, every other key included. */
-export declare function proposalIdentity(raw: unknown): string | null;
-/** Why an agent's options file can't go to the hub as it stands, or null. Toolroll checks what makes it safe to copy
- * and this request's; youiyoux checks each option against the component's contract when it reads it. */
-export declare function proposalProblem(text: string, proposal: string, request: string): string | null;
-export type Decision = {
-    status: "chosen" | "dismissed";
-    choice: string | null;
-    label: string | null;
-    by: string | null;
-    at: string | null;
-};
-/**
- * A person decided in the hub: mark the task complete as landed work is, bound to the exact result whose options were
- * copied, through every guard a person's completion passes, or leave it Ready for review and say why. Once per request,
- * in one transaction with the read. Waits (false) while the task isn't Ready, Complete or cancelled.
- */
-export declare function actOnDecision(store: Store, repo: string, row: OptionsRow, decision: Decision, now: Date, root: string): boolean;