@floh-solutions/pharos-cli 0.31.1 → 0.33.0

package/dist/delegate/argus.d.ts

@@ -0,0 +1,436 @@
+/**
+ * The Argus board socket — the route to a coding agent running in Navarch.
+ *
+ * ## Why there is a fourth route at all
+ *
+ * Terminal takes an Apple Event and VS Code takes a URI, because in both the
+ * thing that owns the terminal is the application. Navarch owns neither: a
+ * worker's PTY belongs to `argusd`, a daemon that outlives the app, and the
+ * app is what watches a screen settle before typing into it. So the delegation
+ * goes over `argusd`'s own socket as one verb — `delegate` — and the two
+ * halves split where the knowledge is: the daemon validates and does the find,
+ * the app starts a worker if there is none, waits for a screen that can take
+ * text, types, and reports back.
+ *
+ * The contract is `docs/delegation-plan.md` in the argus repo (board #1378).
+ * Everything below was measured against an isolated `argusd` built from argus
+ * master `2aaefd3` on 2026-09-11; the fixtures in `test/argus.test.ts` are that
+ * daemon's replies verbatim.
+ *
+ * ## Spoken directly, not through `argus-board`
+ *
+ * `~/.config/argus/bin/argus-board` frames exactly this — one newline-
+ * terminated JSON object in, one line back — and shelling out to it would have
+ * been half the code. It is wrong here for one measured reason: **that script
+ * stamps the CALLER'S identity onto every request**, from the environment.
+ * `_agent` from `$ARGUS_AGENT`, `_worker` from `$ARGUS_WORKER`, plus `_sub`,
+ * `_persona` and `_mission`. A `pharos delegate` run inside an Argus worker —
+ * which is precisely where Pharos.app's Ask Agent runs it — would therefore
+ * raise an approval card naming that worker, and file the ledger entry and the
+ * outcome note under it. The card is the whole point of the dial: it has to
+ * read *Pharos wants to hand work to a claude worker in …*, which is a
+ * question a person can answer.
+ *
+ * Speaking the socket means exactly the keys below travel, and nothing this
+ * process happens to have been started with. It also lets a park hold for the
+ * daemon's full wait (the script's own deadline is `wait + 5`, tuned for the
+ * board's reads) and keeps a transport failure distinguishable from a refusal,
+ * which a script that prints one line for both cannot be.
+ *
+ * ## `ARGUS_BOARD_SOCK` is honoured
+ *
+ * The same variable `argus-board` reads. It is how an isolated daemon is
+ * reached, and a session pointed at one should not have this verb quietly
+ * talking to the live fleet instead.
+ */
+/** Where `argusd` binds its board socket, unless the environment says otherwise. */
+export declare function argusSocketPath(env?: NodeJS.ProcessEnv): string;
+/**
+ * The kinds `delegate` will type a prompt at, as the wire spells them.
+ *
+ * A shell is deliberately not one: a delegation is a prompt, and typed at a
+ * bare shell it is a command. `claude` and `codex` are the two this CLI's
+ * `--agent` offers; `antigravity` exists on the wire and has no `--agent` yet.
+ */
+export type ArgusKind = "claude" | "codex" | "antigravity";
+/** The one-line limit the daemon holds `text` to (`BoardStore.sendTextLimit`). */
+export declare const ARGUS_TEXT_LIMIT = 4000;
+/**
+ * How long to ask the daemon to park, in seconds.
+ *
+ * **60, always, and never the default 10.** Two measured reasons. A delegation
+ * onto an empty folder has to start a worker and wait out a cold agent's first
+ * screen — `FleetControl.delegateSpawnWindow` is 45s — so a ten-second answer
+ * is `pending` with the real outcome landing half a minute later in a reply
+ * nobody is reading. And on the default autonomy dial the first hand-off on a
+ * machine raises an approval card, which answers `pending` the instant it goes
+ * up whatever the wait is; the wait is what catches the person who clicks
+ * *Allow* straight away, and ten seconds does not.
+ *
+ * 60 is also the daemon's ceiling (`maxFleetWait`), so this is "as long as it
+ * will hold", not a number picked here.
+ */
+export declare const ARGUS_WAIT_SECONDS = 60;
+/** What the request is stamped with. The card names this; an anonymous one reads "A program outside the fleet". */
+export declare const ARGUS_AGENT = "Pharos";
+/**
+ * One reply off the socket, decoded no further than `ok`.
+ *
+ * `reason` is `null` rather than absent when the key was not there, because
+ * **that absence is the single most important fact on this wire** — see
+ * {@link mapRefusal}.
+ */
+export interface ArgusSuccess {
+    ok: true;
+    data: Record<string, unknown>;
+}
+export interface ArgusRefusal {
+    ok: false;
+    reason: string | null;
+    error: string;
+    data: Record<string, unknown> | null;
+}
+export type ArgusReply = ArgusSuccess | ArgusRefusal;
+/**
+ * Decode one line. Anything that is not a JSON object with a boolean-ish `ok`
+ * is a transport fault rather than an answer, and is reported as one.
+ */
+export declare function parseArgusReply(line: string): ArgusReply | null;
+/**
+ * The socket was there and the conversation still failed — a park that outlived
+ * its own deadline, a daemon that closed mid-answer, a line that is not JSON.
+ *
+ * Separate from a refusal on purpose: a refusal is a fact about this machine
+ * with a fix on it, and this is the CLI's ordinary failure.
+ */
+export declare class ArgusTransportError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/** Nothing is listening: the socket file is absent, or the connect was refused. */
+export declare class ArgusUnreachableError extends Error {
+    readonly code: string;
+    readonly socketPath: string;
+    constructor(message: string, code: string, socketPath: string);
+}
+/** The machine-facing half, injectable so every shape below is testable without a daemon. */
+export interface ArgusDeps {
+    /** One request, one reply line. Throws {@link ArgusUnreachableError} or {@link ArgusTransportError}. */
+    ask: (request: Record<string, unknown>, timeoutMs: number) => Promise<string>;
+}
+export declare function systemArgusDeps(env?: NodeJS.ProcessEnv): ArgusDeps;
+/**
+ * The refusal ids this route adds to `delegate`'s closed set.
+ *
+ * Every one names a DIFFERENT fix, which is the whole reason they are told
+ * apart — the app renders a fact and the fix beside it, and two states that
+ * share a word send somebody to the wrong Settings pane. `unsupported` and
+ * `folder-missing` are not here because the verb already has them and they
+ * mean the same thing on this route.
+ */
+export declare const ARGUS_REASONS: readonly ["argusd-not-running", "argusd-outdated", "navarch-not-running", "not-an-operator", "rate-limited", "declined", "delivery-failed", "request-unknown", "gh-account-unknown", "argus-refused"];
+export type ArgusReason = (typeof ARGUS_REASONS)[number];
+/** What a delegation is, at whatever point it has got to. */
+export interface ArgusDelegation {
+    /** `pending` is a real answer: a card is up, or the app has not reported yet. */
+    action: "sent" | "launched" | "pending";
+    /** The id `--status` asks about. */
+    request: string;
+    /** **Absent until there is one.** `null` means "we have not got a worker yet", never "the empty string". */
+    worker: string | null;
+    name: string | null;
+    created: boolean;
+    kind: string;
+    directory: string;
+    /** The remote host a worker lives on; empty for this Mac. */
+    host: string;
+    /** The hidden scratch pad the delegation is recorded on. */
+    todo: number | null;
+    /** Prose for a person. The app renders this. */
+    detail: string;
+}
+export interface ArgusFailure {
+    /**
+     * `session-gone` is here and not in {@link ARGUS_REASONS} because it is
+     * `delegate`'s own word, shared with every other host: the daemon's
+     * `worker-not-eligible` means to a caller exactly what a vanished pid means
+     * on Terminal — *the row you picked is not one this machine will deliver
+     * to any more*. One word, one fix (re-read the list and pick again), one
+     * branch in the app.
+     */
+    reason: ArgusReason | "unsupported" | "folder-missing" | "session-gone";
+    detail: string;
+    /** What the daemon actually said. Kept so a reason this pharos does not know is still diagnosable. */
+    argus: {
+        reason: string | null;
+        error: string;
+    };
+    /** The delegation row, on the refusals that carry one — `declined` and `failed` both do. */
+    delegation?: ArgusDelegation;
+}
+/**
+ * Generic over what it is paired with, because three different reads return
+ * "the thing, or the refusal that stopped it": a delegation, a fleet, a list.
+ */
+export declare function isFailure<T extends object>(value: T | ArgusFailure): value is ArgusFailure;
+/**
+ * The delegation inside a reply, or the refusal it is instead.
+ *
+ * One function for all three answers — `delegate`, the end of its park and
+ * `delegate_status` — because the daemon builds all three from one builder and
+ * a caller that parsed them separately would be inventing a difference.
+ */
+export declare function readDelegation(reply: ArgusReply): ArgusDelegation | ArgusFailure;
+/**
+ * A refusal, as an id this CLI's caller already renders.
+ *
+ * ## The rule that matters: **no `reason` key is an OLD DAEMON**
+ *
+ * `reason` arrived with `delegate` itself, so an `argusd` too old to serve the
+ * verb is also too old to stamp one. That is not a corner — it is the first
+ * thing this route meets on any machine whose daemon has not been reloaded,
+ * which on the machine this was written on was every machine the day it
+ * landed. And an old daemon says three different things, two of which accuse
+ * this CLI of a bug it does not have (measured against argus `2fa7bf0`, the
+ * commit before the verb):
+ *
+ * | what is attached | what comes back, with no `reason` |
+ * |---|---|
+ * | old daemon, old app or none | `unknown op 'delegate' — see argus-board help …` |
+ * | old daemon, **new Navarch publishing `delegate`** | `delegate requires a "todo" (id) — the work it serves` |
+ * | …the same, unstamped | `'delegate' is an Argus Agent action — this session was not started as one. …` |
+ *
+ * The middle row is the trap: an old daemon forwards any verb the app claims
+ * it can run, and that forwarder demands the `todo` this verb exists to
+ * remove. A caller that believed the prose would go and add one. So the test
+ * is the MISSING KEY and never the wording — the wording only chooses how
+ * sharply the detail can put it. A current daemon stamps a reason on every
+ * refusal, and argus asserts that in `Tests/delegate_test.py` precisely so this
+ * inference stays true.
+ */
+export declare function mapRefusal(reply: ArgusRefusal): ArgusFailure;
+/**
+ * The word that means "start one anyway", beside the uuids `worker` also takes
+ * (`BoardStore.delegateFreshWorker`).
+ *
+ * It is the same spelling as this CLI's own reserved `--session new`, and that
+ * is a coincidence worth keeping rather than a shared constant: one is a value
+ * a person types at a flag, the other is a value on argus's wire, and the day
+ * either side renames its own the other must not silently follow.
+ */
+export declare const ARGUS_NEW_WORKER = "new";
+/** What a delegation asks for. Nothing else reaches the wire. */
+export interface DelegateJob {
+    /** Absolute, and already canonicalised — the daemon's compare resolves system symlinks only. */
+    directory: string;
+    kind: ArgusKind;
+    /** ONE line. */
+    text: string;
+    /** Seconds to park. Defaults to {@link ARGUS_WAIT_SECONDS}. */
+    wait?: number;
+    /**
+     * Who to aim at: a worker uuid out of `delegate_candidates`, or
+     * {@link ARGUS_NEW_WORKER} to start a fresh one regardless (#1402).
+     *
+     * **Omitted, not sent empty, when the caller has no opinion** — that is the
+     * find, which is every delegation before #1402 and still the common one.
+     */
+    worker?: string;
+    /**
+     * The GitHub identity a worker this delegation STARTS should run as: a
+     * Navarch account label, or a GitHub login (#1402).
+     *
+     * The daemon resolves it against this core's own `accounts.json`, label then
+     * login, and refuses `gh-account-unknown` rather than falling back. It is
+     * ignored — out loud, in the reply's detail — when the text lands in a
+     * worker that is already running, because a session already on the project
+     * is already running as somebody.
+     */
+    ghAccount?: string;
+}
+/**
+ * The request, built in one place.
+ *
+ * `host`, `name`, `stage` and `project` are deliberately never sent. `host`
+ * would name a remote machine and this CLI's `--host` means the application, so
+ * spelling one here would be a collision waiting to pick the wrong worker;
+ * `name` names a NEW worker, which Navarch derives better than a caller can;
+ * `project` and `stage` belong to a board this delegation does not have.
+ *
+ * **`worker` and `gh_account` are omitted when absent rather than sent null.**
+ * The daemon reads a JSON null as absent, so either would work — but a daemon
+ * that predates #1402 IGNORES both keys silently, and an omitted key keeps the
+ * two requests byte-identical to what that daemon has always been sent. The
+ * capability check that stops us sending them to a daemon that would ignore
+ * them is the caller's; see `delegate.ts`.
+ */
+export declare function delegateRequest(job: DelegateJob): Record<string, unknown>;
+/**
+ * `delegate_candidates` — **the find, asked instead of performed** (#1402).
+ *
+ * A read: ungated, not rate-limited, and answered from the same fleet snapshot
+ * `fleet_status` is served from, so it says strictly less than this socket
+ * already tells everyone on it. It is stamped like every other request from
+ * here all the same, so a refusal cannot be about the stamp.
+ *
+ * `host` is deliberately not sent. It would name a remote machine, and this
+ * CLI's `--host` means the application — the daemon defaults it to empty,
+ * which is this Mac, and that is the only fleet this verb can reach.
+ */
+export declare function delegateCandidatesRequest(directory: string, kind: ArgusKind): Record<string, unknown>;
+export declare function delegateStatusRequest(request: string, wait?: number): Record<string, unknown>;
+export declare function fleetStatusRequest(): Record<string, unknown>;
+/**
+ * How long to wait on the socket for a park of `wait` seconds.
+ *
+ * The daemon has to notice its own deadline and write a reply after it, so the
+ * read has to outlast the park or every timed-out delegation reads as a broken
+ * socket. Ten seconds of margin, the same shape `argus-board` uses (it allows
+ * five, for reads that are not parked on a person).
+ */
+export declare function readTimeoutMs(waitSeconds: number): number;
+export declare function askArgus(deps: ArgusDeps, request: Record<string, unknown>, timeoutMs: number): Promise<ArgusReply>;
+/** The refusal for a socket nothing is listening on. */
+export declare function unreachable(error: ArgusUnreachableError): ArgusFailure;
+/**
+ * One worker as `fleet_status` reports it (`FleetWorkerStatus.boardRow`).
+ *
+ * Only the fields the find and a menu row need. `todo` is the mission a worker
+ * is holding — see {@link eligible} for why it is a weaker signal here than it
+ * is inside the daemon.
+ */
+export interface ArgusWorker {
+    id: string;
+    name: string;
+    kind: string;
+    /** `waiting`, `working`, `starting`, `exited`, … — the daemon's own words. */
+    status: string;
+    /** What it is doing, in its own words. Often empty. */
+    stage: string;
+    directory: string;
+    /** The remote machine it runs on; empty for this Mac. */
+    host: string;
+    /** The mission todo it is holding, when the board still has that row. */
+    todo: number | null;
+    /** True for an Argus Agent — an operator, which a delegation must never land in. */
+    fleet: boolean;
+}
+export declare function parseFleet(reply: ArgusSuccess): ArgusWorker[];
+/**
+ * What `delegate_candidates` answered: the rows this core would accept, in the
+ * order its own find ranks them, and the one it would pick.
+ *
+ * **Already filtered and already ranked**, so nothing here re-applies
+ * {@link eligible} or {@link rankWorkers}. That is the entire point of the
+ * read: this CLI's own predicate is a PREDICTION of the daemon's, and a good
+ * one, but it is weaker in a way that matters — `fleet_status` writes `todo`
+ * onto a row only while the board still holds that todo, so a mission whose
+ * todo was deleted reads free here and is excluded there. Re-filtering the
+ * daemon's own list could only subtract a row the daemon has just said it
+ * accepts.
+ *
+ * `target` is **absent when there is none**, exactly like `worker` on a
+ * delegation that has not landed — so it is null here rather than `""`. It is
+ * the head of `candidates` by construction (both come from one predicate and
+ * one sort), which is why {@link ArgusCandidates.target} is read rather than
+ * inferred: it is the daemon's own statement of what a plain delegate takes.
+ */
+export interface ArgusCandidates {
+    workers: ArgusWorker[];
+    target: string | null;
+}
+export declare function parseCandidates(reply: ArgusSuccess): ArgusCandidates;
+/**
+ * Is this worker a candidate for a delegation onto `directory`?
+ *
+ * `BoardStore.delegateTarget`, rule for rule. Two of the five exclusions are
+ * the interesting ones, and both look like perfectly good targets from here:
+ *
+ * - **a mission worker** runs in a shared base checkout and would match, and
+ *   typing an unrelated work item into an agent mid-branch derails the todo it
+ *   is holding;
+ * - **an Argus Agent** is a claude worker with no mission sitting in a base
+ *   checkout — which is exactly the folder a person links in Pharos. A
+ *   delegation landing there hands the work item to the thing that *drives* the
+ *   fleet, in the session whose next turn can start missions and type into
+ *   every other worker.
+ *
+ * **Mission-hood is weaker here than it is inside the daemon**, and the
+ * difference is worth knowing. The daemon tests `missionTodo` on the worker
+ * itself; `fleet_status` only writes `todo` onto the row when the board still
+ * holds that todo, so a mission whose todo was deleted reads as free here and
+ * is excluded there. The direction of the error is the safe one — this can
+ * only list or predict a worker the daemon would decline to use, never hide
+ * one it would pick — but it is why a prediction is all this is, and why the
+ * send itself never names a worker: the daemon does the find that counts.
+ */
+export declare function eligible(worker: ArgusWorker, kind: ArgusKind, directory: string): boolean;
+/**
+ * Two spellings of one folder.
+ *
+ * The daemon compares `standardizingPath` on both sides, which expands `~`,
+ * drops `.`/`..` and a trailing slash and resolves the symlinked prefixes
+ * macOS ships (`/tmp` → `/private/tmp`) — but NOT an arbitrary symlink
+ * somebody made. That is why the caller canonicalises the folder with
+ * `realpath` before it gets here, the same way the Terminal route does; this
+ * is the rest of the daemon's normalisation, and it is case-insensitive
+ * because `caseInsensitiveCompare` is what the daemon uses.
+ */
+export declare function sameFolder(a: string, b: string): boolean;
+/**
+ * The candidates for a delegation onto `directory`, in the order the daemon
+ * would pick them. `[0]` is the worker a plain delegate takes.
+ *
+ * **The tie-break is the id and never the status**, because two calls a second
+ * apart must pick the same pane. A worker that has not painted yet is worst —
+ * there is no box to type into — and everything else is equal, so `starting`
+ * sinks and the rest sort on a uuid that never changes.
+ */
+export declare function rankWorkers(workers: readonly ArgusWorker[], kind: ArgusKind, directory: string): ArgusWorker[];
+/**
+ * The read that answers "has this argusd been reloaded since `delegate`
+ * landed?" without delegating anything.
+ *
+ * `delegate_status` is a pure read of the daemon's own table — not gated, not
+ * rate-limited, and about an id it minted — so asking it about one that cannot
+ * exist costs nothing and changes nothing. A current daemon answers
+ * `unknown-request`; one that predates the verb answers `unknown op
+ * 'delegate_status'` with no `reason` at all, which is the same tell the send
+ * path uses.
+ *
+ * It earns its round trip on `--list` and `--dry-run`, which otherwise read
+ * `fleet_status` — a verb every generation of the daemon serves — and would
+ * cheerfully list workers that a send is about to refuse to deliver to.
+ */
+export declare const PROBE_REQUEST = "00000000-0000-0000-0000-000000000000";
+/** True when the reply says this daemon knows the delegate family. */
+export declare function servesDelegate(reply: ArgusReply): boolean;
+/**
+ * What one `delegate_candidates` reply says about the daemon that sent it.
+ *
+ * **Three generations of argusd are live at once on a real machine**, and they
+ * answer this one read three different ways. Telling them apart is what lets
+ * `--list` fall back instead of refusing, and — far more important — what
+ * stops `--session` and `--gh-account` being sent to a daemon that would
+ * SILENTLY IGNORE them:
+ *
+ * | daemon | what it answers | {@link candidatesSupport} |
+ * |---|---|---|
+ * | predates `delegate` (before argus #1378) | a refusal with **no `reason` key at all** | `pre-delegate` |
+ * | serves `delegate`, predates #1402 (kit 57) | `reason: "unknown-op"` | `no-op` |
+ * | #1402 or later (kit 58) | the list — or `bad-directory`/`bad-kind`, which only an op that EXISTS can say | `yes` |
+ *
+ * The middle row is the one that costs something. `delegate` reads the keys it
+ * knows and ignores the rest, so a kit-57 daemon handed `worker` does its own
+ * find and answers `sent` about a worker the person did not choose — the exact
+ * substitution `--session` exists to prevent, and nothing in the reply says it
+ * happened. Nothing else on the wire reports the gap either, so this read is
+ * the only way to know, and it has to be taken BEFORE the send.
+ *
+ * A refusal that is neither shape counts as `yes` on purpose: only an op the
+ * daemon dispatches can refuse for a reason of its own, and the same rule the
+ * whole route follows applies — **test the key, never the prose**.
+ */
+export type CandidatesSupport = "yes" | "no-op" | "pre-delegate";
+export declare function candidatesSupport(reply: ArgusReply): CandidatesSupport;
+//# sourceMappingURL=argus.d.ts.map

package/dist/delegate/argus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argus.d.ts","sourceRoot":"","sources":["../../src/delegate/argus.ts"],"names":[],"mappings":"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"}