toolroll 0.9.104 → 0.9.105

package/dist/discover.js

@@ -1,52 +1,19 @@
-/**
- * Reading the state of repositories.
- *
- * Every git invocation here is a read, and every one is prefixed with
- * `--no-optional-locks` — Toolroll scans repositories the operator may be
- * working in right now, and a discovery pass must never contend for the index
- * lock with their editor.
- *
- * Nothing raises. A repository that cannot be read comes back as a snapshot
- * carrying a named problem, because the alternative is a scan of forty repos
- * ending on the one that is broken.
- *
- * The reads are deliberately unequal in cost, and that shapes the module.
- * Listing refs, worktrees and the remote is O(refs) and lands in tens of
- * milliseconds. Computing ahead/behind walks history per branch — measured at
- * 22s on a cold 304MB repo — so it is bounded and degrades to a branch list
- * without it. Reading the working tree is O(working tree), measured at over
- * two minutes, so it does not happen at all unless asked for.
- */
 import { basename } from "node:path";
 import { run } from "./exec.js";
 import { checkoutGit } from "./teardown-git.js";
 import { parseWorktrees, parseBranches } from "./git.js";
 import { findRepos } from "./scan.js";
-/** Enough to keep git busy without turning a laptop fan on. */
 export const DEFAULT_CONCURRENCY = 8;
-/** Ref reads land in tens of milliseconds; seconds here means something is wrong. */
 export const REF_TIMEOUT_MS = 5_000;
-/**
- * Ahead/behind is worth waiting for, since it is the signal itself. Ten
- * seconds because a 59MB repo with 18 branches and no commit-graph measured
- * 7.5s cold — just over a five second bound, which is the worst place for a
- * limit to sit.
- */
 export const TRACK_TIMEOUT_MS = 10_000;
-/** The working tree is unbounded, so the bound has to be ours. */
 export const STATUS_TIMEOUT_MS = 10_000;
 const GIT = "git";
-/** Read-only, and refuses to take the index lock it would otherwise want. */
 const READ_ONLY = ["--no-optional-locks"];
 const HEADS = "refs/heads";
 const BRANCH_FORMAT = "--format=%(refname:short)%09%(upstream:track)%09%(committerdate:iso8601-strict)";
-/** The same three columns with the expensive one left empty. */
 const BRANCH_FORMAT_CHEAP = "--format=%(refname:short)%09%09%(committerdate:iso8601-strict)";
 export async function inspectRepo(path, options = {}) {
     const { runner = run, dirty = false } = options;
-    // Scanned and enrolled projects share their repository with every build, which can write its config, info and hooks
-    // (`--dirty`'s status would run a planted fsmonitor or filter): the hardened git, against a frozen view of the
-    // repository (teardown-git.ts checkoutGit). An injected runner (tests) is used as given.
     const hardened = runner === run ? checkoutGit(run, "build") : runner;
     const git = (args, timeoutMs = REF_TIMEOUT_MS) => hardened(GIT, [...READ_ONLY, ...args], { cwd: path, timeoutMs });
     const [worktrees, branchRead, head, remote, status] = await Promise.all([
@@ -56,7 +23,6 @@ export async function inspectRepo(path, options = {}) {
         git(["remote", "get-url", "origin"]),
         dirty ? git(["status", "--porcelain"], STATUS_TIMEOUT_MS) : null,
     ]);
-    // One missing binary is one problem, not five identical ones.
     if (worktrees.notFound) {
         return { ...emptySnapshot(path), problems: ["git is not installed"] };
     }
@@ -72,9 +38,7 @@ export async function inspectRepo(path, options = {}) {
     return {
         path,
         name: basename(path),
-        // A failed symbolic-ref means detached HEAD, which is a state and not a fault.
         head: head.code === 0 ? head.stdout.trim() : null,
-        // A repo with no origin is ordinary; reporting it as an error would be noise.
         remoteUrl: remote.code === 0 ? remote.stdout.trim() : null,
         branches: branches.code === 0 ? parseBranches(branches.stdout) : [],
         worktrees: worktrees.code === 0 ? parseWorktrees(worktrees.stdout) : [],
@@ -83,10 +47,6 @@ export async function inspectRepo(path, options = {}) {
         problems,
     };
 }
-/**
- * Ahead/behind is the whole point of the report, so it is tried first — but a
- * branch list without it beats a timeout with nothing in it.
- */
 async function readBranches(git) {
     const rich = await git(["for-each-ref", BRANCH_FORMAT, HEADS], TRACK_TIMEOUT_MS);
     if (!rich.timedOut)
@@ -94,16 +54,10 @@ async function readBranches(git) {
     const cheap = await git(["for-each-ref", BRANCH_FORMAT_CHEAP, HEADS], REF_TIMEOUT_MS);
     return { result: cheap, degraded: cheap.code === 0 };
 }
-/**
- * Inspect known repositories, skipping the walk entirely. Enrolled paths are
- * already the answer to "which repositories" — searching for them again would
- * be the tool distrusting a list the operator wrote down.
- */
 export async function inspectAll(paths, options = {}) {
     const { runner = run, dirty = false, concurrency = DEFAULT_CONCURRENCY } = options;
     return mapWithConcurrency(paths, concurrency, path => inspectRepo(path, { runner, dirty }));
 }
-/** Every repository at or below `roots`, inspected with bounded concurrency. */
 export async function discover(roots, options = {}) {
     const { scan, ...rest } = options;
     return inspectAll(await findRepos(roots, scan), rest);
@@ -135,10 +89,6 @@ function firstLine(text) {
 function countLines(text) {
     return text.split("\n").filter(line => line.trim() !== "").length;
 }
-/**
- * Results stay in input order regardless of completion order, so the output of
- * a scan does not depend on which repository happened to answer first.
- */
 async function mapWithConcurrency(items, limit, worker) {
     const results = new Array(items.length);
     let next = 0;

package/dist/dispatch.js

@@ -1,18 +1,12 @@
-/**
- * One read-side answer to "will this task run?"
- *
- * The atomic claim remains the authority. This module owns the task-local
- * predicates that claim re-proves under its write transaction, then layers
- * fleet observations on top for people and agents reading the queue. A
- * diagnosis can go stale; it can never grant a lease.
- */
 import { STORAGE_HOLD_PREFIX } from "./needs-you.js";
 import { authorityStandsSql } from "./approval-authority.js";
 import { isAlive } from "./runner.js";
 import { updateAdmissionPaused, UPDATE_PAUSED } from "./desktop-update-gate.js";
 import { approvalOf } from "./scope.js";
 import { plannerSourceProblemOf } from "./planner-source.js";
-import { authPauseOf, authWaitOf, providerName, signInReason } from "./provider-auth.js";
+import { authPauseOf, authWaitOf, messageCommand, providerName, signInReason } from "./provider-auth.js";
+import { signInCommandFor } from "./first-run.js";
+import { LOGIN_PROBE, PATH_PROBE } from "./phase-routing.js";
 import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js";
 import { replacedWords } from "./task-status.js";
 import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
@@ -21,13 +15,8 @@ import { vanishedStopOf, vanishedStopSentence } from "./vanished-retry.js";
 import { routeChangeOf } from "./route-change.js";
 import { wasInterrupted } from "./run-ending.js";
 import { BUILT_IN, refArchived, parseCapabilityKey } from "./store.js";
-import { shortWhen } from "./when-html.js";
+import { shortWhen, viewerZone } from "./when-html.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
-/**
- * Task state, active holds, and unfinished dependencies in the exact order
- * acquireIfReady checks them. The claim path calls this while holding its
- * write transaction; read surfaces call it only as a snapshot.
- */
 export function taskReadinessBlocker(store, taskRef, now) {
     const db = store.handle;
     const stamp = now.toISOString();
@@ -38,7 +27,6 @@ export function taskReadinessBlocker(store, taskRef, now) {
         .get(BUILT_IN, taskRef);
     if (task === undefined)
         return { code: "unknown-task", message: "no such task" };
-    // A put-away task (v145) never dispatches, whatever its state: restore it first.
     if (refArchived(store, taskRef))
         return { code: "archived", message: "put away" };
     const state = String(task["state"]);
@@ -74,11 +62,6 @@ export function taskReadinessBlocker(store, taskRef, now) {
     }
     return null;
 }
-/** The exact live approval predicate used by both the scheduler survey and
- * the atomic claim. Mode-backed approvals count only while their signer and
- * mode still stand. */
-// Recovery reads this same live predicate; a completed run does not grandfather
-// a revoked signer or mode, and this query never creates dispatch authority.
 export function scopeApprovedForDispatch(store, taskRef, now) {
     const row = store.handle
         .prepare(`SELECT 1 AS hit FROM task_scope
@@ -88,8 +71,6 @@ export function scopeApprovedForDispatch(store, taskRef, now) {
         .get(taskRef, now.toISOString(), now.toISOString(), now.toISOString(), now.toISOString());
     return row !== undefined;
 }
-/** The phase the ordinary dispatch loop would choose before it resolves an
- * agent. */
 export function dispatchRoleFor(store, taskRef, now) {
     const ref = store.refForId(taskRef);
     const approved = scopeApprovedForDispatch(store, taskRef, now);
@@ -99,7 +80,6 @@ export function dispatchRoleFor(store, taskRef, now) {
         return "scout";
     return "builder";
 }
-/** The first requirement this task fails, in words, or null. */
 export function missingCapability(store, taskRef, dispatchRepo, now) {
     const db = store.handle;
     const row = db.prepare("SELECT repo, capability_requirements FROM task_ref WHERE id = ?").get(taskRef);
@@ -146,7 +126,6 @@ function answer(code, condition, summary, detail, options = {}) {
         review: options.review ?? null,
     };
 }
-/** The review projection, shaped for readers (v50). */
 function reviewViewOf(sourceRun, retry) {
     const current = retry.live ?? (retry.state === "queued" ? null : retry.latest);
     return {
@@ -167,23 +146,15 @@ function approvedProfile(scope) {
         return null;
     return scope.approvedProfile ?? scope.profile ?? null;
 }
-/** The read-side lifecycle answer. Project access limits dependency detail, never the readiness gate. */
-/** The builders that may take work in `repo`, as dispatch decides: registered and not retired (`all`), bound to the
- * project (`eligible`; only the assigned one when a task names one), and checking in now (`alive`). The first-run
- * "Builder connected" step reads the same answer, so it is done only when a task there could start. */
 export function buildersFor(store, repo, now, assignedRunner = null) {
     const all = store.listRunners().filter(one => one.retiredAt === null);
     const bound = all.filter(one => one.repos.includes(repo));
     const eligible = assignedRunner === null ? bound : bound.filter(one => one.name === assignedRunner);
     return { all, eligible, alive: eligible.filter(one => isAlive(one, now)) };
 }
-/** Whether a task in `repo` could start for want of nothing but a person: a live builder bound to it. */
 export function builderReadyFor(store, repo, now) {
     return repo !== null && buildersFor(store, repo, now).alive.length > 0;
 }
-/** The project the first-run "Builder connected" step speaks for, on Chat and the board alike: the open one; else the
- * saved project of the first filed task the viewer may see (All projects); else, only before any task exists, the
- * first managed project. Null when tasks exist but none sits in a project the viewer may see: then nothing says done. */
 export function firstRunBuilderRepo(store, selected, visible, managed) {
     if (selected !== null)
         return selected;
@@ -205,23 +176,12 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
             return answer("complete", "terminal", "Report ready", "The research report is ready to review.", { action: "open-result" });
         const proof = result === undefined ? null : store.proofVerdictFor(result.id);
         const accepted = result !== undefined && store.proofAcceptance(result.id) !== null;
-        // THE REVIEW STATUS (v50): read from the bounded retry projection — the
-        // open request and the NEWEST root attempt in ordinal order — so a
-        // queued retry is never hidden behind an older failed run, and every
-        // answer below names the attempt count and the one explicit next act.
         const retry = result === undefined ? null : store.reviewRetryStateOf(result.id);
         const review = result === undefined || retry === null || retry.state === "unrequested" ? null : reviewViewOf(result.id, retry);
-        // The words are the workspace's shared projection (package 1, review
-        // fixes): the same label and detail the Work rows, task page, focused
-        // chat, receipt, and review cockpit render for this exact result —
-        // a review in flight included. The codes stay the contract.
         const reviewFacts = reviewFactsOf(retry, runner => {
             const reviewer = store.getRunner(runner)?.runner;
             return reviewer !== undefined && isAlive(reviewer, now);
         }, result !== undefined && buildReviewOf(store, result.id)?.state === "pending");
-        // A no-change conclusion owes no proof beyond its handoff and sealed
-        // diff (the task page's own "attested floor"); with both on record it
-        // is complete, not verification-needed.
         const noChangeRecord = result === undefined || result.outcome !== "no-change"
             ? undefined
             : (() => { const kinds = new Set(store.artifactsFor(result.id).map(one => one.kind)); return kinds.has("handoff") && kinds.has("terminal-diff"); })();
@@ -243,13 +203,11 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
             : status.detail, { action: "open-result", review });
     }
     if (task.state === "cancelled") {
-        // Replaced, never "Cancelled": a successor carries the work on.
         const successor = store.replacementOf(taskId);
         return successor === null ? answer("cancelled", "terminal", "Cancelled", "Nothing else will run for this task.")
             : answer("cancelled", "terminal", replacedWords(successor), `${replacedWords(successor)}. Nothing else will run for this task.`);
     }
     if (task.state === "failed") {
-        // The family's latest finished attempt's own recorded reason, or that none was recorded: never "review its incident".
         const family = store.taskFamilyOf(taskId, ref.repo === null ? [] : [ref.repo], ref.repo === null);
         const runs = family === null || family.problem !== null ? store.runsFor(ref.id) : family.versions.flatMap(version => store.runsFor(version.refId));
         const stopped = vanishedStopOf(store, ref.id);
@@ -263,15 +221,12 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         return answer("updating", "waiting", "Waiting for app update", UPDATE_PAUSED);
     const local = taskReadinessBlocker(store, ref.id, now);
     if (local?.code === "hold") {
-        // The storage check couldn't finish (dispose.ts holdForStorage): its own words, and Try again.
         if (local.ownerKind === "backoff" && local.message.startsWith(`held: ${STORAGE_HOLD_PREFIX}`)) {
             const when = local.until === null ? "" : ` It tries again on its own ${retryWhenWords(local.until, now)}.`;
             return answer("storage-blocked", "waiting", "Needs macOS permission", `${local.message.slice(`held: ${STORAGE_HOLD_PREFIX}`.length)}${when}`, { action: "unhold", nextAt: local.until });
         }
         if (local.ownerKind === "backoff") {
-            // Run 2085: an attempt that stopped before its handoff says so plainly.
             const last = store.runsFor(ref.id).find(one => one.role === "builder" && one.finishedAt !== null);
-            // Said once, with a time a person reads (nextAt keeps the exact stamp for machines).
             const when = local.until === null ? "" : ` It tries again ${retryWhenWords(local.until, now)}.`;
             if (last?.reason === "no-handoff")
                 return answer("retry-scheduled", "retrying", "Retry scheduled", `The agent stopped before handing off; its work was kept and it is being resumed.${when}`, { nextAt: local.until });
@@ -332,24 +287,22 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         if (exhausted.length === available.length) {
             const resets = exhausted.map(one => one?.resetAt ?? null).filter((one) => one !== null).sort();
             const nextAt = resets[0] ?? null;
-            return answer("provider-quota", "retrying", "Provider quota exhausted", nextAt === null ? "The provider gave no reset time. Choose another agent, or wait for the limit to reset." : `The next recorded reset is ${nextAt}.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
+            return answer("provider-quota", "retrying", `${providerName(profile.provider)}'s usage limit is reached`, nextAt === null ? "It gave no reset time. Choose another agent, or wait for the limit to reset." : `It resets ${resetWhenWords(nextAt, now)}, then the task starts again by itself.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
         }
     }
-    // The sign-in pause: the task's provider stopped working; nothing it would
-    // run starts until someone signs in (or a run or check on it works again).
     const provider = profile?.provider ?? (role === "planner" ? ref.planProvider : null) ?? null;
     const signedOut = authWaitOf(store, ref.id) ?? (provider === null ? null : authPauseOf(store, provider));
     if (signedOut !== null) {
-        return answer("signed-out", "waiting", signInReason(signedOut), `This task starts again on its own once ${providerName(signedOut.provider)} works.`, { role });
+        return answer("signed-out", "waiting", signInReason(signedOut), signInAgainWords(signedOut), { role });
     }
+    const agentless = agentlessFirstRun(store, ref, role === "planner", alive.map(one => one.name));
+    if (agentless !== null)
+        return answer("signed-out", "waiting", NO_AGENT_TITLE, agentless.words, { role });
     const openDecisions = store.countUnanswered();
     if (openDecisions >= DEFAULT_MAX_OPEN_DECISIONS && (role === "planner" || ref.parkRate > 0)) {
         return answer("waiting-decision", "waiting", "Decision queue is full", `${openDecisions} decisions already wait; answer some before this task may add another.`, { action: "answer-decision", role });
     }
     if (role === "planner") {
-        // The filed request's own gate (contract handoff, task 1): a request
-        // the planner could not be given whole is refused before spend, and
-        // this is where the task page says so.
         const sourceProblem = plannerSourceProblemOf(store, taskId);
         if (sourceProblem !== null)
             return answer("planner-source", "waiting", sourceProblem.title, sourceProblem.detail, { action: "write-scope", role });
@@ -362,16 +315,12 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
 export function diagnosisIsDispatchable(diagnosis) {
     return diagnosis?.code === "ready" || diagnosis?.code === "planning-ready" || diagnosis?.code === "scouting-ready";
 }
-/** Attach the same lifecycle answer to the bounded fleet snapshot used by
- * both direct chat and the long-running lead. */
 export function withDispatchDiagnoses(store, snapshot, now) {
     return {
         ...snapshot,
         tasks: snapshot.tasks.map(one => ({ ...one, dispatch: diagnoseTaskDispatch(store, one.id, now) })),
     };
 }
-/** When a backed-off task tries again, as a person reads it: "in under a minute", "in 3 minutes", or a later day's
- * time in UTC (the console's own clock words, when-html.ts shortWhen). */
 export function retryWhenWords(until, now) {
     const ms = Date.parse(until) - now.getTime();
     if (Number.isNaN(ms))
@@ -388,3 +337,55 @@ export function retryWhenWords(until, now) {
         return `tomorrow at ${at.slice("Tomorrow ".length)} UTC`;
     return `on ${at} UTC`;
 }
+export const NO_AGENT_TITLE = "No coding agent is signed in";
+export const noAgentWords = (command, modelsCleared = false) => modelsCleared
+    ? `${NO_AGENT_TITLE}. Run \`${command}\`, then choose its models in Settings → Models.`
+    : `${NO_AGENT_TITLE}. Run \`${command}\`, then it starts by itself.`;
+export function modelsEverChosen(store) {
+    return store.handle.prepare("SELECT 1 FROM models_generation LIMIT 1").get() !== undefined;
+}
+const notInstalled = (one) => one.state === "unavailable" && one.probe === PATH_PROBE;
+const signedOut = (one) => one.state === "unavailable" && (one.probe === LOGIN_PROBE || (one.provider === "codex" && one.probe === "identity"));
+export function agentlessCommand(claudeInstalled, codexInstalled, platform = process.platform) {
+    return signInCommandFor({ claude: claudeInstalled ? "signed-out" : "not-installed", codex: codexInstalled ? "signed-out" : "not-installed" }, platform);
+}
+export function agentlessSignIn(store, runners, platform = process.platform) {
+    if (runners.length === 0)
+        return null;
+    let claudeInstalled = false, codexInstalled = false;
+    for (const name of runners) {
+        const reported = store.providerReadiness(name);
+        const claude = reported.find(one => one.provider === "claude"), codex = reported.find(one => one.provider === "codex");
+        if (claude === undefined || codex === undefined || reported.some(one => one.state !== "unavailable"))
+            return null;
+        if (!(notInstalled(claude) || signedOut(claude)) || !(notInstalled(codex) || signedOut(codex)))
+            return null;
+        claudeInstalled ||= signedOut(claude);
+        codexInstalled ||= signedOut(codex);
+    }
+    const command = agentlessCommand(claudeInstalled, codexInstalled, platform);
+    return { command, words: noAgentWords(command, modelsEverChosen(store)) };
+}
+export function modelsUnset(store) {
+    return store.handle.prepare("SELECT 1 FROM phase_config UNION ALL SELECT 1 FROM phase_tier_config UNION ALL SELECT 1 FROM phase_tier_alternate LIMIT 1").get() === undefined;
+}
+export function agentlessFirstRun(store, ref, planning, runners, platform = process.platform) {
+    if (!planning || ref.planProvider !== null || !modelsUnset(store))
+        return null;
+    return agentlessSignIn(store, runners, platform);
+}
+export function signInAgainWords(pause) {
+    return `${signInReason(pause)}. Run \`${messageCommand(pause)}\`, then it starts again by itself.`;
+}
+export function resetWhenWords(at, now, zone = viewerZone()) {
+    const words = shortWhen(at, now, zone, true);
+    if (words === at)
+        return "later";
+    if (/^\d/.test(words))
+        return `at ${words}`;
+    if (words.startsWith("Tomorrow "))
+        return `tomorrow at ${words.slice("Tomorrow ".length)}`;
+    if (words.startsWith("Yesterday "))
+        return "now";
+    return `on ${words}`;
+}