@openagt/dashboard 0.8.0 → 0.9.0

package/dist/auto-pm.d.ts

@@ -1,538 +0,0 @@
-import type { QuotaBoundaryStatus } from './quota-boundary.js';
-import type { AutoHandoffSkip } from './events.js';
-/**
- * Auto PM (#685): spend leftover subscription quota on product management instead of
- * letting it expire. While the account is still under its quota boundary (#879) and nobody
- * is at the keyboard, the daemon runs the cycle by itself: it starts an agent on the queued work
- * whenever the `agent-data` branch moved (#1774), and once a run finds nothing queued it refills
- * the queue — triaging tickets, then spiking and planning the ones that have neither yet.
- *
- * The daemon reads no queue and names no skill (#1774). It watches one thing, the head of the
- * `agent-data` branch, and reacts to the commits it did not write itself: someone queued an entry,
- * an agent claimed or closed a ticket. The agent started for that reads the skills in its checkout
- * and takes one queued task; its own commits move the branch again, so the daemon fires again as
- * the run ends, and the chain drains the queue by itself. A run that finds nothing writes nothing,
- * and the chain stops. One heartbeat a day is the belt.
- *
- * The whole feature is one policy question ("is now a good time to spend tokens on our
- * own roadmap?"), so that question lives here as a pure function and the daemon only
- * supplies the readings. #298 is the parent idea (background jobs / "max out the usage"),
- * and #879 defines the boundary this reads.
- */
-/** How often the daemon looks at the branch and re-asks {@link autoPmDecision}: right after each data pull. */
-export declare const DEFAULT_AUTO_PM_INTERVAL_MS: number;
-/**
- * The belt (#1774): a run on the queued work once a day even when nothing moved, so a branch the
- * daemon missed a move on — a range git could not walk, a restart between a push and the look —
- * is looked at by an agent within a day.
- */
-export declare const DEFAULT_AUTO_PM_HEARTBEAT_MS: number;
-/** What the policy was told about one project at one moment. */
-export interface AutoPmInputs {
-    /** The `autoPm` preference. Off = the feature does nothing at all. */
-    enabled: boolean;
-    /** Live agents on this project, measured against {@link AutoPmInputs.concurrency}. */
-    activeAgents: number;
-    /**
-     * What holds each of those slots (#1646), one label per run, for the stand-down's wording. A
-     * cap reached by a process the Agents panel no longer shows looked exactly like one reached by
-     * real work; named, the reader can go and look at the run it names.
-     */
-    running?: readonly string[];
-    /**
-     * How many agents the routine may keep going on this project at once (#1204);
-     * {@link DEFAULT_AUTO_PM_CONCURRENCY} when unset. Floored at one, because zero concurrent
-     * agents is what `enabled: false` already spells.
-     */
-    concurrency?: number;
-    /** Where the account stands against its quota boundary, or `undefined` when it could not be read. */
-    quota: QuotaBoundaryStatus | undefined;
-    /**
-     * Milliseconds since the rotation last started an agent for this project, or `undefined` when
-     * the cooldown does not apply: the rotation never did, or this start is for a move of the branch.
-     */
-    sinceLastStartMs?: number;
-    /** Override {@link DEFAULT_AUTO_PM_COOLDOWN_MS}. */
-    cooldownMs?: number;
-    /**
-     * A person asked for this pass (#1210's Run now), so the cooldown does not apply (#1642): it
-     * paces work nobody asked for, and a click is asking. The concurrency cap still does — that is
-     * what keeps a second click from doubling up, since a start registers before the sweep moves on.
-     */
-    onDemand?: boolean;
-}
-/** Why the sweep is not starting anything. Logged, so it reads as a sentence. */
-export type AutoPmRefusal = {
-    start: false;
-    reason: string;
-};
-/** Whether the budget allows spending unasked at all, before asking what to spend it on. */
-export type QuotaDecision = {
-    start: true;
-} | AutoPmRefusal;
-/** Start, or the reason not to. */
-export type AutoPmDecision = {
-    start: true;
-} | AutoPmRefusal;
-/**
- * Whether the budget allows spending unasked.
- *
- * The gate is the quota boundary (#879): the pro-rated share of the week's allowance elapsed so
- * far, rising continuously with the clock (#960 Edit), so auto PM spends up to that line and
- * stands down at it. Work the user asks for is free to cross it and borrow against the days still
- * to come; work nobody asked for is exactly what the line is there to stop.
- *
- * **It fails closed on a quota it cannot read, and that is the opposite of the per-agent guard.**
- * #519 settled that an unreadable quota must never *stop* the user's own work, so
- * `startConsumptionGuard` fails open. Quietly burning a subscription on work nobody asked for
- * is a far worse failure than skipping a tick.
- *
- * Reading the account's own week also means a restarted daemon is not blind: the figure is
- * absolute and complete, unlike the delta meter this replaced, which reported zero consumed
- * after a restart however much the account had spent (#848).
- */
-export declare function quotaHeadroom(quota: QuotaBoundaryStatus | undefined): QuotaDecision;
-/**
- * Whether to start an agent for one project right now. Every condition is a reason to
- * *not* spend the user's quota, checked cheapest first so the common "someone is working"
- * case never reaches the meter.
- */
-export declare function autoPmDecision(input: AutoPmInputs): AutoPmDecision;
-/**
- * One thing auto PM knows how to do while the machine is idle (#773).
- *
- * The jobs form a cycle, and the order matters: triage turns tickets into queued work, [Plan
- * tickets] turns the rest into plans. Once a job queues something the branch moves and the queued
- * work is started (#1774); the rotation resumes where it left off once a run finds nothing queued.
- */
-export interface AutoPmJob {
-    /** Stable id: the rotation and the opt-out list (#1209) key on it. */
-    name: string;
-    /** The prompt to run, verbatim. */
-    prompt: string;
-    /**
-     * A line saying what the job does, wherever its {@link label} does not already: under the label
-     * in the routines list, and as the log line's wording. Only the maintenance sweep carries one --
-     * "Maintenance" names its preset rather than the work -- while the other routines' labels read
-     * as what they do, so their rows stay one line and their log lines say the label itself rather
-     * than the same thing twice. Data on the job rather than a name matched in the dashboard, so a
-     * rename cannot quietly move the line around.
-     */
-    describe?: string;
-    /**
-     * The user-facing name, for a surface that lists the routines (#1159). Read off the preset the
-     * job fires rather than written again here, so a relabelled preset relabels its routine.
-     */
-    label?: string;
-    /**
-     * The preset's own one-line "what this does" (#1506), for a surface that has to say what a click
-     * is about to spend an agent on before it spends it. Read off the preset like
-     * {@link AutoPmJob.label}, so the sentence the launcher shows for a preset and the sentence the
-     * routines list shows for its routine are the same sentence. Absent for a preset without one.
-     */
-    tooltip?: string | undefined;
-    /**
-     * This job works the queued work rather than making more of it (#1774): the daemon fires it
-     * when the `agent-data` branch moved, and a Run now on its row is that same fire, asked for.
-     * Declared here rather than matched on {@link AutoPmJob.name} at the call site, so the job says
-     * what it does and a rename cannot quietly unhook it.
-     */
-    works?: boolean;
-    /**
-     * The routine lock this job holds while it runs (#1659), as `routines/<lock>.lock.md` on the
-     * agent-data branch: the triage routines rewrite the shared queue and may take hours, so no two may
-     * run at once, on any machine. The sweep mints it before the start and releases it when the
-     * run ends. Declared as data on the job, like {@link AutoPmJob.works}, so the sweep never
-     * matches on {@link AutoPmJob.name} at the call site.
-     */
-    lock?: string;
-    /**
-     * Merge this job's PR once its agent opens it (#1216). Set on the job that works the queue: what
-     * it implements has already been triaged as consensual, quick-win work a human could have vetoed
-     * on the queue, so its PR is the one kind whose review happened before the agent. Declared as
-     * data on the job for the same no-name-matching reason as {@link AutoPmJob.works}.
-     */
-    autoMerge?: boolean;
-    /**
-     * This rotation job may fan out to several agents pinned one ticket each (#1327). Only
-     * [Plan tickets] declares it: unlike the other rotation jobs it writes per-ticket sibling files
-     * rather than rewriting the shared queue document, so concurrent copies do disjoint work and
-     * land disjoint edits. Declared as data on the job for the same no-name-matching reason as
-     * {@link AutoPmJob.works}.
-     */
-    fansOut?: boolean;
-    /**
-     * The one ticket a fanned-out job is pinned to (#1327), as its filename inside `tickets/`. Set
-     * only on the per-start variants {@link pinnedPlanJob} builds: which tickets are open is known
-     * only at the moment the sweep locks them.
-     */
-    ticket?: string;
-    /**
-     * The `.lock.md` claim the sweep minted for this start (#1420/#1583), on the pinned variants.
-     * What lets the sweep free the claim itself when the agent settles with nothing to hand off:
-     * the agent's PR is what normally deletes the lock, and an agent that never made a commit is
-     * never opening one.
-     */
-    claim?: PlanAssignment;
-}
-/** One fanned-out agent's claim (#1327): the ticket it is pinned to, and the id its lock names. */
-export interface PlanAssignment {
-    /** The ticket's filename inside `tickets/`. */
-    ticket: string;
-    /**
-     * The agent's id: what the `.lock.md`'s `CLAIMED:` line carries (#1420/#1748) and the id the
-     * agent is then started with, so the claim and the run are one. Minted by the sweep before the
-     * claim, the way a start would mint it a moment later ({@link agentIdFromStartedAt}).
-     */
-    agentId: string;
-}
-/**
- * A fan-out job pinned to one locked ticket (#1327).
- *
- * The stock prompt covers every ticket that has no plan or claim yet, and with a batch going out
- * that instruction is a collision: every agent forks the same checkout and would pick the same
- * most-important ticket. The pin is *appended* to the stock prompt rather than spliced into it,
- * so the verdict rules the preset carries keep riding along verbatim and a rewritten preset (the
- * maintainer owns its wording) cannot silently lose the pin.
- *
- * The agent is also told which claim is its own: its ticket's `.lock.md` already exists with the
- * `CLAIMED:` line the daemon pushed (#1420), and finding anything else there means the
- * assignment is stale — another agent's claim, or work that landed meanwhile — so it stops. It
- * is told to delete the lock in the same data-branch commit as the plan (#1582), because nothing
- * else releases it: #1420 removed the staleness timer, so a forgotten lock stands until a human
- * clicks it away.
- */
-export declare function pinnedPlanJob(job: AutoPmJob, assignment: PlanAssignment): AutoPmJob;
-/**
- * The default cycle: bring the tickets across from GitHub (#1208), triage the quick ones (#891),
- * then the significant-but-agreed ones (#892), and only then make more plans (#685). Planning is
- * the most expensive turn and the one whose output the earlier jobs consume, so it runs last.
- *
- * Importing leads because it is the only job that can add a ticket none of the others have seen
- * (#1334): a routine that triages and plans a set nothing ever refills eventually has nothing
- * left to do, and a new issue would wait for a human to press the button. It is safe to repeat --
- * the preset resumes from `tickets/meta.json`'s `lastImportedAt` and reconciles, so a firing with
- * nothing changed since the last one is a no-op rather than a re-import.
- *
- * This rotation is what #891/#892 mean by "with a cron job regularly firing this preset". No
- * separate scheduler is involved and none is needed: the rotation fires after every run that found
- * nothing queued, which is exactly when the queue wants refilling. That is the opposite of
- * the maintenance sweep (#882), which is paced by a calendar because it looks at static history and
- * would otherwise never come due — hence its own {@link AUTO_PM_MAINTENANCE_JOB} outside the cycle.
- *
- * The presets that end in `<AWAIT>` (Research, Suggest tickets to work on) are deliberately not
- * here: firing one with nobody at the keyboard would park an agent against a human who will never
- * answer.
- *
- * Each triage prompt pins its own session name, so a triage always lands on the same branch. What
- * keeps a rotation from triaging twice is the routine lock (`routine-locks.ts`), taken before the
- * agent starts: a firing that finds the lock held stands down without spending an agent, and the
- * rotation advances past it rather than retrying a job that is already running.
- */
-export declare const AUTO_PM_JOBS: readonly AutoPmJob[];
-/**
- * The command skill the daemon fires on the queued work (#1774): `work-queue`, a skill file the
- * project tracks under `.claude/skills/<command>`, marked so that only a person or the daemon
- * invokes it. Its prompt is the slash command; the agent's harness expands it. The daemon ships
- * no skill file, links none into a checkout and depends on no skill package.
- */
-export declare const WORK_QUEUE_SKILL_NAME = "work-queue";
-/**
- * The job for the queued work (#1774): one agent, told nothing but `/work-queue`, takes one
- * queued task off the queue by composing the skills in its checkout. Outside the rotation on
- * purpose — the rotation is about what to *make* when there is nothing to do, and this is the
- * thing to do. Its label and tooltip are written here: the routine is a skill file, not a preset.
- */
-export declare const AUTO_PM_WORK_JOB: AutoPmJob;
-/**
- * The periodic codebase-wide sweep (#882): fire the [Maintenance] preset (#881) so a repo that
- * adopted The Framework late gets its pre-existing history looked at.
- *
- * Outside the rotation, like {@link AUTO_PM_WORK_JOB} and for the same kind of reason: the
- * rotation is "what to make next" and cycles on every run that found nothing queued, while this is
- * paced by a calendar and must not advance or be advanced by the cycle. It takes precedence over
- * the rotation when due, because the entries it queues are what the rotation would otherwise be
- * inventing work instead of.
- *
- * The prompt renders at module load with no session, so `tf.params.what` falls back to its
- * default of the entire codebase, which is exactly this job's scope.
- */
-export declare const AUTO_PM_MAINTENANCE_JOB: AutoPmJob;
-/**
- * Every routine the sweep can fire, in the order a surface should list them (#1159).
- *
- * Derived from the three constants above rather than written out again, so the list the dashboard
- * shows and the jobs the daemon actually runs cannot drift. The order is the sweep's own precedence
- * (#855/#882 read the other way round): the queued work comes first because it is what happens
- * whenever the branch moved, the rotation is what happens when a run found nothing, and the
- * calendar-paced maintenance sweep is the exception outside both.
- */
-export declare const AUTO_PM_ROUTINES: readonly AutoPmJob[];
-/**
- * What became of one look at an agent this loop started. A finished agent is `settled` and stops
- * being asked about; a still-running one is not, and is asked again next tick.
- */
-export interface SettleOutcome {
-    /** Stop tracking this agent: it is finished. */
-    settled: boolean;
-    /**
-     * Why the settled run's handoff skipped, when its record says so (#1583). The sweep needs
-     * exactly one fact from the record: a run that ended `no-commits` will never open the PR that
-     * lifts the `.lock.md` it was started under, so the sweep releases that claim itself.
-     */
-    handoffSkip?: AutoHandoffSkip;
-    /**
-     * The run finished cleanly but its epilogue has not reported yet (#1583): the `end` lands
-     * before the handoff does its work, so a sweep can catch the gap between them. A claim-carrying
-     * agent observed there is held pending a little longer rather than settled — settling would
-     * drop the claim with the ending unread, and the release would be missed for good.
-     */
-    handoffPending?: boolean;
-}
-/** A project the sweep considers. */
-export interface AutoPmProject {
-    /** Registry id, as `start` and the live-agent lookup take it. */
-    id: string;
-    /** Absolute repo path, for reading its branch. */
-    path: string;
-}
-/** The readings and effects {@link startAutoPm} needs, injected so the loop is testable off disk. */
-export interface AutoPmDeps {
-    /** The projects to consider. */
-    projects(): Promise<readonly AutoPmProject[]>;
-    /** The `autoPm` preference, re-read per tick so the toggle takes effect without a restart. */
-    enabled(): Promise<boolean>;
-    /**
-     * The routines the user has switched off, by {@link AutoPmJob.name} (#1209). Re-read per tick
-     * for the same reason {@link AutoPmDeps.enabled} is, and an unreadable answer means none:
-     * a preference that cannot be read must not silently switch the whole rotation off.
-     */
-    optedOut?(): Promise<readonly string[]>;
-    /**
-     * The local head of the project's `agent-data` branch (#1774), or `undefined` when the branch
-     * does not exist yet. Read after the daemon's data pull, so it says what other machines and the
-     * agents pushed.
-     */
-    dataHead(project: AutoPmProject): Promise<string | undefined>;
-    /**
-     * How many commits between two heads of the branch were written by something other than a
-     * daemon (#1774): a person queuing an entry, an agent claiming or closing a ticket. The daemon's
-     * own writes — a run's record, a routine lock, a claim — carry a trailer and are not counted,
-     * or every record would start the next run.
-     */
-    foreignCommits(project: AutoPmProject, from: string, to: string): Promise<number>;
-    /**
-     * The agents live on a project, one label each (#1646) — the run's id and pid, as the daemon
-     * holds them. Their number is what the cap is measured against; their names are what the
-     * stand-down and the fan-out say, so a slot held by a process the dashboard no longer shows
-     * names itself rather than reading as a bug in the count.
-     */
-    activeAgents(project: AutoPmProject): readonly string[];
-    /**
-     * How many agents the routine may keep going per project (#1204). Re-read per tick like
-     * {@link AutoPmDeps.enabled}, so the setting takes effect without a restart. Unset or unreadable
-     * falls back to {@link DEFAULT_AUTO_PM_CONCURRENCY} rather than to one: the absence of the
-     * setting has never meant "less".
-     */
-    concurrency?(): Promise<number | undefined>;
-    /**
-     * Where the account stands against its boundary for the work *this project* would start, or
-     * `undefined` when there is no reading.
-     *
-     * Asked per project rather than once per sweep (#1619): the model is a project-resolvable
-     * setting, and the model's own weekly window binds alongside the account's (#879) — so two
-     * projects on two models can stand at two different places against the same reading.
-     */
-    quota(project: AutoPmProject): Promise<QuotaBoundaryStatus | undefined>;
-    /** The jobs to rotate through, in cycle order. Used once a run found nothing queued. */
-    jobs: readonly AutoPmJob[];
-    /** The job for the queued work (#1774); {@link AUTO_PM_WORK_JOB} by default. */
-    workJob?: AutoPmJob;
-    /**
-     * Whether a project is due its periodic codebase sweep (#882). Injected rather than computed
-     * here because the schedule lives in a file in the project checkout, and this module is pure
-     * policy. Omitted entirely (or throwing) means "not due", so a daemon that cannot read the
-     * schedule keeps doing the rotation rather than sweeping on every tick.
-     */
-    maintenanceDue?(project: AutoPmProject): Promise<boolean>;
-    /** Stamp a project as swept, so the next sweep is an interval away. Paired with {@link AutoPmDeps.maintenanceDue}. */
-    recordMaintenance?(project: AutoPmProject): Promise<void>;
-    /** The job fired when {@link AutoPmDeps.maintenanceDue} says yes; {@link AUTO_PM_MAINTENANCE_JOB} by default. */
-    maintenanceJob?: AutoPmJob;
-    /** Start the agent. Resolves the agent's id, or undefined when the daemon refused. */
-    start(project: AutoPmProject, job: AutoPmJob): Promise<string | undefined>;
-    /**
-     * Take a job's {@link AutoPmJob.lock} before its run starts (#1659): `routines/<lock>.lock.md`
-     * on the agent-data branch, pushed, so every machine sharing it sees the routine as taken. `ok: false`
-     * stands the job down with the reason — the lock's holder, or a write that could not land.
-     * Omitted, the job starts unguarded.
-     */
-    lockRoutine?(project: AutoPmProject, lock: string): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: string;
-    }>;
-    /**
-     * Drop this daemon's {@link AutoPmJob.lock} once its run has ended, whatever the ending
-     * (#1659): a triage never opens the PR that would lift a ticket claim. `false` when the release
-     * could not land, so the loop holds the agent and retries next sweep.
-     */
-    releaseRoutine?(project: AutoPmProject, lock: string): Promise<boolean>;
-    /**
-     * Drop the locks a previous daemon on this machine left behind whose runs are gone (#1659).
-     * Asked once per project, on the project's first sweep: this loop holds nothing in memory for
-     * them, so nothing else would ever release them before the expiry.
-     */
-    releaseDeadLocks?(project: AutoPmProject): Promise<unknown>;
-    /**
-     * Whether an agent this loop started has finished (#852/#1583), and how its handoff ended.
-     * Asked before the sweep decides anything, so a run that just ended is closed out first: its
-     * routine lock released, a claim it abandoned freed, the rotation's turn earned.
-     */
-    settled(project: AutoPmProject, agent: {
-        agentId: string;
-    }): Promise<SettleOutcome>;
-    /**
-     * The tickets open for planning (#1327): no plan or `.lock.md` claim yet (#1420) — most
-     * important first, as filenames inside `tickets/`. Asked only when the tick lands on a
-     * {@link AutoPmJob.fansOut} job. Unreadable means none, and no seam at all means the stock
-     * single driver: the fan-out is an addition, not a precondition, and a loop wired without it
-     * behaves exactly as before #1327.
-     */
-    planCandidates?(project: AutoPmProject): Promise<readonly string[]>;
-    /**
-     * Claim `assignments`' tickets before their agents start (#1327/#1420): one `.lock.md` sibling
-     * per ticket reading `CLAIMED: <AGENT_ID>`, committed as one batch and pushed to the default
-     * branch, so agents forked from any checkout — and cloud sessions, which is the point — find
-     * the file and skip the ticket. Resolves the subset actually locked: a ticket lost to a race
-     * locks fewer, and each missing lock costs one agent of the batch rather than the batch.
-     * Failing (or absent) resolves nothing locked, and the sweep falls back to the stock single
-     * agent — one unpinned agent is what ran before #1327 and needs no lock to be safe.
-     */
-    lockPlans?(project: AutoPmProject, assignments: readonly PlanAssignment[]): Promise<readonly PlanAssignment[]>;
-    /**
-     * Free a claim this loop minted whose agent settled with nothing to hand off (#1583): the
-     * lock's normal release is the agent's own PR deleting it, and a run whose handoff skipped as
-     * `no-commits` is never opening one — without this the planning livelocks on the dead claim
-     * until a human clicks Release. Keyed off the run's recorded ending, never a timer (#1420).
-     * Only the exact minted claim is freed — the callee leaves a lock naming anyone else alone.
-     *
-     * Resolves `true` when the claim is dealt with (freed, already gone, or someone else's), and
-     * `false` when the release could not land — a transient `index.lock`, say — so the loop holds
-     * the agent and tries again next sweep rather than losing the one shot. Absent (or throwing)
-     * leaves the lock standing, exactly as before this seam.
-     */
-    releaseLock?(project: AutoPmProject, claim: PlanAssignment): Promise<boolean>;
-    /** Progress line. */
-    log(message: string): void;
-    /** Override the tick interval. */
-    intervalMs?: number;
-    /** Override the per-project cooldown. */
-    cooldownMs?: number;
-    /** Override {@link DEFAULT_AUTO_PM_HEARTBEAT_MS}. */
-    heartbeatMs?: number;
-    /** Clock, injectable for tests. */
-    now?: () => number;
-}
-/** What the last sweep decided about one project. */
-export interface AutoPmOutcome {
-    /** Registry id of the project considered. */
-    projectId: string;
-    /** Its path, which is what the log line names and the panel shows. */
-    path: string;
-    /** Whether an agent was started for it. */
-    started: boolean;
-    /** The sentence: what was started, or the reason for standing down. */
-    message: string;
-}
-/**
- * What auto PM has done lately (#1161).
- *
- * Every decision was already logged (#855), but the log is the daemon's stdout and the toggle
- * lives in a browser, so from the dashboard a wedged sweep and a healthy idle one looked
- * identical — the same failure #855 fixed one layer down.
- */
-export interface AutoPmReport {
-    /** Whether the preference was on at the last sweep. `undefined` before the first one. */
-    enabled?: boolean;
-    /** When the last sweep finished, epoch ms. `undefined` before the first one. */
-    sweptAt?: number;
-    /** When the next sweep is due, epoch ms. */
-    nextSweepAt: number;
-    /** One line per project the last sweep considered, in sweep order. */
-    outcomes: AutoPmOutcome[];
-}
-/**
- * Where the dashboard reads {@link AutoPmReport} from. The daemon wires its live loop; a public
- * host (the relay) leaves it unset, and one that has not finished starting answers `undefined`.
- */
-export type AutoPmReporter = () => AutoPmReport | undefined;
-/** A running sweep. */
-export interface AutoPmLoop {
-    /**
-     * Run one sweep now, rather than waiting for the next tick. Called when the preference is
-     * switched on (#1161) as well as from tests: the sweep re-reads it per tick, so without this
-     * the box you just ticked does nothing at all for a whole interval.
-     *
-     * `onDemand` marks a sweep a person explicitly asked for (#1210's trigger button). The `autoPm`
-     * preference is consent to spend quota *unasked*, and a click is asking — so an on-demand sweep
-     * runs with the preference off. It skips the cooldown for the same reason (#1642): the cooldown
-     * paces the unattended rotation, and for half an hour after any run it made Run now a button
-     * that could start nothing. Every other reason to stand down (live agents, the quota boundary,
-     * unticked routines) still holds. A plain on-demand sweep starts the queued work when the branch
-     * moved, else the rotation's next job: the click is the ask, so it does not wait for a run to
-     * have found nothing.
-     *
-     * `only` narrows the sweep to one routine's work (#1204), for a Run now on a routine's row:
-     *
-     * - `'work'` — the queued-work row's Run now means "start an agent on the queue now", whether
-     *   or not the daemon saw the branch move; a tick that has nothing queued spends one run finding
-     *   that out, which is what the click asked for.
-     * - `'plan'` — the one rotation job that fans out ({@link AutoPmJob.fansOut}). Its Run now
-     *   used to be a plain single start, so the concurrency setting was the one thing that click
-     *   ignored; narrowing here reaches the same claim-then-start path the rotation takes, locks
-     *   included.
-     * - `{ lock }` — the rotation job holding that lock ({@link AutoPmJob.lock}), for a triage's Run
-     *   now (#1643/#1659). One agent, like the rotation's own firing, but through the sweep so the
-     *   lock is taken before the start — a plain start would run unguarded.
-     *
-     * `projectId` scopes the sweep to one project, which is what a Run now fired from a card with a
-     * project picked means. Absent, every project the daemon watches is visited, which is what the
-     * queued-work row's Run now says it does.
-     */
-    tick(opts?: {
-        onDemand?: boolean;
-        only?: AutoPmOnly;
-        projectId?: string;
-    }): Promise<void>;
-    /** What the last sweep decided, for the dashboard to show (#1161). */
-    report(): AutoPmReport;
-    stop(): void;
-}
-/**
- * Which routine's work a narrowed sweep is for (#1204/#1643). `'work'` is the queued work
- * (#1774) and `'plan'` the fan-out that writes one ticket's own sibling files per agent. `{ lock }`
- * names a rotation job by the lock it holds ({@link AutoPmJob.lock}): one agent is all it can
- * use, and the lock that guards it is the sweep's to take (#1659) — a Run now that started it
- * outside the sweep would run unguarded. Keyed on the lock rather than the job's name for the same
- * no-name-matching reason the job carries the property at all: the card sends whatever the job
- * it renders declares. A rotation job that neither fans out nor holds a lock has nothing to
- * narrow to — a plain start is exactly what it is.
- */
-export type AutoPmOnly = 'work' | 'plan' | {
-    lock: string;
-};
-/**
- * Start the auto-PM sweep (#685): every {@link DEFAULT_AUTO_PM_INTERVAL_MS}, look at each
- * project's `agent-data` branch, ask {@link autoPmDecision}, and start an agent for the projects
- * that say yes.
- *
- * Ticks never overlap — a sweep reads a live-agent map that its own `start` calls mutate,
- * so a second sweep running over the first would decide against a stale picture.
- *
- * Nothing here survives the daemon: per #519 a Ctrl+C that stops everything is the feature,
- * not a gap, so this loop is deliberately not restartable from outside the process.
- */
-export declare function startAutoPm(deps: AutoPmDeps): AutoPmLoop;
-//# sourceMappingURL=auto-pm.d.ts.map

package/dist/auto-pm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auto-pm.d.ts","sourceRoot":"","sources":["../src/auto-pm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAKlD;;;;;;;;;;;;;;;;;;GAkBG;AAEH,+GAA+G;AAC/G,eAAO,MAAM,2BAA2B,QAAY,CAAA;AASpD;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,QAAsB,CAAA;AAE/D,gEAAgE;AAChE,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,OAAO,EAAE,OAAO,CAAA;IAChB,sFAAsF;IACtF,YAAY,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,qGAAqG;IACrG,KAAK,EAAE,mBAAmB,GAAG,SAAS,CAAA;IACtC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,iFAAiF;AACjF,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5D,4FAA4F;AAC5F,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GAAG,aAAa,CAAA;AAE3D,mCAAmC;AACnC,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GAAG,aAAa,CAAA;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,mBAAmB,GAAG,SAAS,GAAG,aAAa,CAmBnF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc,CAkBlE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,KAAK,CAAC,EAAE,cAAc,CAAA;CACvB;AAED,mGAAmG;AACnG,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB;AAiBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,GAAG,SAAS,CAgBnF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,SAAS,EA4B5C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,eAAe,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAO9B,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAMrC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,SAAS,EAIhD,CAAA;AAKD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAA;IACV,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAA;CACb;AAED,qGAAqG;AACrG,MAAM,WAAW,UAAU;IACzB,gCAAgC;IAChC,QAAQ,IAAI,OAAO,CAAC,SAAS,aAAa,EAAE,CAAC,CAAA;IAC7C,8FAA8F;IAC9F,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAA;IACvC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAC7D;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACjF;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,MAAM,EAAE,CAAA;IACvD;;;;;OAKG;IACH,WAAW,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAC3C;;;;;;;OAOG;IACH,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAA;IACvE,wFAAwF;IACxF,IAAI,EAAE,SAAS,SAAS,EAAE,CAAA;IAC1B,gFAAgF;IAChF,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;;OAKG;IACH,cAAc,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACzD,sHAAsH;IACtH,iBAAiB,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACzD,iHAAiH;IACjH,cAAc,CAAC,EAAE,SAAS,CAAA;IAC1B,sFAAsF;IACtF,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAC1E;;;;;OAKG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACzG;;;;OAIG;IACH,cAAc,CAAC,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACvE;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3D;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IACnF;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAA;IACnE;;;;;;;;OAQG;IACH,SAAS,CAAC,CACR,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,SAAS,cAAc,EAAE,GACrC,OAAO,CAAC,SAAS,cAAc,EAAE,CAAC,CAAA;IACrC;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC7E,qBAAqB;IACrB,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mCAAmC;IACnC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAA;IACjB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAA;IACZ,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAA;IAChB,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,yFAAyF;IACzF,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,QAAQ,EAAE,aAAa,EAAE,CAAA;CAC1B;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,YAAY,GAAG,SAAS,CAAA;AAE3D,uBAAuB;AACvB,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,IAAI,CAAC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,UAAU,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACzF,sEAAsE;IACtE,MAAM,IAAI,YAAY,CAAA;IACtB,IAAI,IAAI,IAAI,CAAA;CACb;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAybxD"}