toolroll 0.9.61 → 0.9.62

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.9.62 — 2026-10-12
+
+- **Release checks in minutes.** The upgrade path runs on a sample, CI's
+  passing run on the exact commit is reused, and the first failure stops it.
+- **Storage sweep waits for quiet.** It runs when nothing is building, and
+  Settings → Storage says when it last ran and why it waits.
+- **Landing proof you can trust.** A task completes on its own only for a
+  merged pull request or the project's recorded remote main, never a local
+  branch a build could move. Projects added before this need it once: you
+  (the owner) or an instance operator's lead runs
+  `toolroll repos add <project> --remote <url>`. Until then, their tasks wait
+  for you.
+- **Cleanup follow-ups.** Only branches Toolroll created are removed, counted
+  from when it made them; scout branches stay, and duplicate teardowns merge.
+- **Fresh base.** A task with no commits starts from current main; the task
+  page shows its base.
+
 ## 0.9.61 — 2026-10-12
 
 - **Agents board.** One place to check on running agents: Needs you,

package/dist/cli.js

@@ -506,7 +506,14 @@ async function runReposCommand(argv, write, onboard) {
     const tokenAt = argv.indexOf("--token");
     const tokenFlag = tokenAt === -1 ? undefined : argv[tokenAt + 1];
     const bare = argv.filter((argument, index) => argument !== "--json" && (tokenAt === -1 || (index !== tokenAt && index !== tokenAt + 1)));
-    const [action, ...paths] = bare;
+    const remoteAt = bare.indexOf("--remote");
+    const remoteUrl = remoteAt === -1 ? undefined : bare[remoteAt + 1];
+    const [action, ...paths] = bare.filter((_, i) => remoteAt === -1 || (i !== remoteAt && i !== remoteAt + 1));
+    if (remoteAt !== -1 && (action !== "add" || bare.filter(v => v === "--remote").length !== 1 || remoteUrl === undefined || remoteUrl.startsWith("-") || paths.length > 1)) {
+        const message = "Use repos add <project> --remote <url> for one project.";
+        write(json ? envelopeJson({ ok: false, command: "repos", reason: "usage", message }) : message);
+        return USAGE_EXIT;
+    }
     const databaseFile = databasePath(process.env, homedir());
     const file = registryBeside(databaseFile);
     if (tokenAt !== -1 && (tokenFlag === undefined || tokenFlag.startsWith("-"))) {
@@ -529,11 +536,18 @@ async function runReposCommand(argv, write, onboard) {
         return 1;
     }
     if (action === undefined) {
-        if (json) {
-            write(envelopeJson({ ok: true, command: "repos", count: loaded.repos.length, repos: loaded.repos, file }));
-            return 0;
+        const store = openStore(databaseFile);
+        try {
+            const projects = loaded.repos.map(repo => ({ repo, remoteUrl: store.projectRemote(repo) }));
+            if (json) {
+                write(envelopeJson({ ok: true, command: "repos", count: loaded.repos.length, repos: loaded.repos, projects, file }));
+                return 0;
+            }
+            return listRepos(loaded.repos, file, write, new Map(projects.map(p => [p.repo, p.remoteUrl])));
+        }
+        finally {
+            store.close();
         }
-        return listRepos(loaded.repos, file, write);
     }
     if (action !== "add" && action !== "remove") {
         const message = `unknown command \`repos ${action}\` — try \`repos\`, \`repos add\`, \`repos remove\`, or \`repos add-from-github <owner/name>\``;
@@ -545,7 +559,7 @@ async function runReposCommand(argv, write, onboard) {
     const lines = [];
     const said = {};
     const say = json ? (line) => lines.push(line) : write;
-    const code = await withAdmission({ databaseFile, registryFile: file, ...(leadToken === undefined ? {} : { leadToken }) }, say, said, admission => action === "add" ? addToRepos(admission, targets, say, said) : removeFromRepos(admission, targets, say, said));
+    const code = await withAdmission({ databaseFile, registryFile: file, ...(leadToken === undefined ? {} : { leadToken }) }, say, said, admission => action === "add" ? addToRepos(admission, targets, say, said, remoteUrl) : removeFromRepos(admission, targets, say, said));
     if (json) {
         write(envelopeJson({
             ok: code === 0,
@@ -582,7 +596,7 @@ async function withAdmission(where, write, said, body) {
         store.close();
     }
 }
-function listRepos(repos, file, write) {
+function listRepos(repos, file, write, remotes) {
     if (repos.length === 0) {
         write("No repositories connected. Toolroll reports on everything it can find.");
         write("");
@@ -592,8 +606,10 @@ function listRepos(repos, file, write) {
         return 0;
     }
     write(`${repos.length === 1 ? "1 repository" : `${repos.length} repositories`} connected:`);
-    for (const repo of repos)
+    for (const repo of repos) {
         write(`  ${repo}${existsSync(repo) ? "" : "   (missing)"}`);
+        write(`    Recorded remote: ${remotes.get(repo) ?? "None"}`);
+    }
     write("");
     write("  toolroll repos add <path>      add another; it is in the console at once");
     write("  toolroll repos remove <path>   take one out of the console; its tasks stay");
@@ -606,7 +622,7 @@ function listRepos(repos, file, write) {
 function admissionExit(reason) {
     return reason === "not-git" || reason === "unavailable" ? USAGE_EXIT : 1;
 }
-async function addToRepos(admission, targets, write, said) {
+async function addToRepos(admission, targets, write, said, remoteUrl) {
     // Every folder is proved before anything is written: one that is not a
     // repository fails here, not later and further away.
     let refused = false;
@@ -624,7 +640,7 @@ async function addToRepos(admission, targets, write, said) {
     const running = consoleRunning(admission.store, now);
     const projects = [];
     for (const path of targets) {
-        const admitted = await admitProject(admission.store, { registryFile: admission.registryFile, path, actor: admission.actor, now });
+        const admitted = await admitProject(admission.store, { registryFile: admission.registryFile, path, actor: admission.actor, now, captureOrigin: true, ...(remoteUrl === undefined ? {} : { remoteUrl }) });
         if (!admitted.ok) {
             // The updater's own taxonomy survives (verification finding 4): a held
             // lock or a malformed registry is an operational fact, never "usage".
@@ -633,8 +649,9 @@ async function addToRepos(admission, targets, write, said) {
             write(admitted.message);
             return admissionExit(admitted.reason);
         }
-        projects.push({ repo: admitted.repo, name: admitted.name, added: admitted.added });
+        projects.push({ repo: admitted.repo, name: admitted.name, added: admitted.added, remoteUrl: admitted.remote.url });
         write(addedWords(admitted.name, admitted.added, running));
+        write(`Recorded remote: ${admitted.remote.url ?? "None. Use repos add <project> --remote <url> to record one."}`);
     }
     said.projects = projects;
     return 0;

package/dist/landed-cleanup.d.ts

@@ -1,4 +1,5 @@
 import { type ExecResult } from "./exec.js";
+import type { RemoteMainRead, RemoteMains } from "./remote-main.js";
 import type { Store } from "./store.js";
 import { type Runner, type WorktreePool } from "./worktree.js";
 /** `storage clean --landed` takes only what has waited at least this long. */
@@ -13,10 +14,12 @@ export declare const AUTO_ITEMS = 40;
 export type Git = (cwd: string, args: readonly string[]) => Promise<ExecResult>;
 export declare function gitOf(runner?: Runner): Git;
 export type LandedHow = "merged" | "in-main" | "content-in-main";
+/** `trusted`: it may complete a task automatically (a recorded merge, or the recorded remote's main). */
 export type LandedProof = {
     landed: true;
     how: LandedHow;
     reason: string;
+    trusted: boolean;
 } | {
     landed: false;
     why: string;
@@ -28,10 +31,17 @@ export type PullRequestFact = {
     number: number | null;
 };
 /**
- * Whether this commit's work landed, read from what Toolroll recorded and the local repository only. Fails closed:
- * every doubt is "not proven", with the reason in a few words.
+ * Whether this commit's work landed, read from what Toolroll recorded and the local repository. Fails closed: every
+ * doubt is "not proven", with the reason in a few words. Only a recorded merge is trusted to complete a task: a build
+ * can write the local main.
  */
 export declare function landedProof(git: Git, repo: string, head: string | null, pullRequest?: PullRequestFact | null): Promise<LandedProof>;
+/**
+ * The proof automatic completion trusts: a recorded merge of this exact commit, or its work in the main of the
+ * project's recorded remote, compared only in the private directory that main was fetched into. `remote` is read only
+ * when no recorded merge settles it.
+ */
+export declare function remoteLandedProof(remote: () => Promise<RemoteMainRead>, repo: string, head: string | null, pullRequest?: PullRequestFact | null): Promise<LandedProof>;
 export type LandedTarget = {
     kind: "checkout" | "branch";
     target: string;
@@ -54,6 +64,8 @@ export type LandedCandidate = {
     completes: boolean;
     how: LandedHow;
     reason: string;
+    /** Proven by a recorded merge or the recorded remote's main: only then may it complete. */
+    trusted: boolean;
     targets: LandedTarget[];
     keeps: LandedKeep[];
 };
@@ -62,7 +74,7 @@ export type LandedCandidate = {
  * `limit` caps how many results are read against git (reconcile's bound; results read before and unchanged since
  * don't count); `before` takes only results finished before it (the one-time pass's seven days).
  */
-export declare function landedResults(store: Store, git: Git, repo: string, root: string, now: Date, options?: {
+export declare function landedResults(store: Store, git: Git, remotes: RemoteMains, repo: string, root: string, now: Date, options?: {
     limit?: number;
     before?: string;
     memo?: boolean;
@@ -104,9 +116,10 @@ export type LandedStep = {
 /**
  * Finish what teardowns intended: pending items, oldest first (checkouts before branches). Each is checked again
  * right before it goes, and recorded right after. Doubt leaves it pending for the next pass; a branch that moved, or
- * a result that has newer work, is kept for good. `only` limits it to these teardowns.
+ * a result that has newer work, is kept for good. `limit` caps the items settled (removed, already gone or kept), so
+ * items left waiting never crowd out later ones. `only` limits it to these teardowns.
  */
-export declare function finishLanded(store: Store, pool: WorktreePool, git: Git, now: () => Date, options?: {
+export declare function finishLanded(store: Store, pool: WorktreePool, git: Git, remotes: RemoteMains, now: () => Date, options?: {
     repo?: string;
     limit?: number;
     only?: ReadonlySet<number>;
@@ -115,7 +128,7 @@ export declare function finishLanded(store: Store, pool: WorktreePool, git: Git,
  * Reconcile's part: finish teardowns a crash cut short, then find newly landed results (a bounded few), mark them
  * complete and tear them down.
  */
-export declare function reconcileLanded(store: Store, pool: WorktreePool, git: Git, repo: string, root: string, now: () => Date): Promise<{
+export declare function reconcileLanded(store: Store, pool: WorktreePool, git: Git, remotes: RemoteMains, repo: string, root: string, now: () => Date): Promise<{
     completed: string[];
     steps: LandedStep[];
 }>;
@@ -142,15 +155,15 @@ export type LandedPlan = {
 };
 /**
  * What `storage clean --landed` would do now, across every project: landed results finished at least a week ago,
- * and Toolroll's own branches (toolroll/, toolroll-plan/, standing-orders/) no task uses whose last commit is at
- * least a week old and landed in main. Reads only.
+ * and branches Toolroll created (toolroll/, toolroll-plan/, standing-orders/) at least a week ago that no task uses
+ * and that landed in main. Reads only.
  */
-export declare function landedBacklog(store: Store, git: Git, root: string, now: Date, options?: {
+export declare function landedBacklog(store: Store, git: Git, remotes: RemoteMains, root: string, now: Date, options?: {
     repos?: readonly string[];
 }): Promise<LandedPlan>;
 /** Act on a preview: record every teardown first, then carry them out. Refuses nothing it previewed silently: what
  * changed since is reported as kept. */
-export declare function cleanLandedBacklog(store: Store, pool: WorktreePool, git: Git, root: string, now: () => Date, plan: LandedPlan, actor: string): Promise<{
+export declare function cleanLandedBacklog(store: Store, pool: WorktreePool, git: Git, remotes: RemoteMains, root: string, now: () => Date, plan: LandedPlan, actor: string): Promise<{
     completed: string[];
     steps: LandedStep[];
     refused: LandedKeep[];