toolroll 0.9.92 → 0.9.94

package/dist/needs-you.js

@@ -22,9 +22,10 @@ export const NEEDS = {
     answer: { sentence: () => "Answer the question so the work can continue.", action: { code: "answer-decision", label: "Answer the question" }, useReason: always },
     questions: { sentence: () => "Too many questions are open. Answer one so this task can start.", action: { code: "inspect-decisions", label: "Answer questions" } },
     "sign-in": { sentence: context => `${context.provider ?? "Your agent"} needs you to sign in again. The task starts on its own after.`, action: { code: "sign-in", label: "Sign in again" }, useReason: reason => /sign in|API key/i.test(reason) },
-    "confirm-stopped": { sentence: context => `Toolroll can't confirm ${build(context)} stopped. Nothing from it is running.`, action: { code: "confirm-stopped", label: "Confirm it stopped" } },
-    // Toolroll can't look at all: never "nothing is running"; the person checks, says so, then confirms.
-    "check-stopped": { sentence: context => `Toolroll can't check whether ${build(context)} stopped. Make sure nothing from it is running, then confirm.`, action: { code: "confirm-stopped", label: "Confirm it stopped" } },
+    // Toolroll proves a build stopped itself (stop-proof.ts); nobody is asked to vouch for it. Only when this computer
+    // can't look, or something Toolroll didn't start is using the build's folder, is the work held: the person can close
+    // what's theirs and have it look again, nothing more.
+    "stop-unproven": { sentence: context => `Toolroll can't prove ${build(context)} stopped from this computer, so the work is held. Close anything of yours that is using its folder, then check again.`, action: { code: "recheck-stopped", label: "Check again" } },
     hold: { sentence: () => "A hold is keeping this task from starting. Review it to release it.", action: { code: "inspect-hold", label: "Review hold" } },
     "choose-project": { sentence: () => "Choose a project so a builder can start.", action: { code: "place-task", label: "Choose a project" } },
     "define-task": { sentence: () => "Say what the task should do so it can be planned.", action: { code: "write-scope", label: "Define the task" } },
@@ -40,14 +41,18 @@ export const NEEDS = {
         } },
     "add-requirement": { sentence: () => "This project is missing something the task needs. Add it so a builder can start.", action: { code: "repair-capability", label: "Add the requirement" } },
     "connect-builder": { sentence: () => "No builder works on this project yet. Connect one so the task can start.", action: { code: "start-worker", label: "Connect a builder" } },
-    "start-builder": { sentence: () => "The builder for this project is offline. Start it and the task begins on its own.", action: { code: "start-worker", label: "Start the builder" } },
-    vanished: { sentence: context => `${Build(context)} stopped without finishing. Check it, then retry.`, action: { code: "reconcile-run", label: "Check the build" } },
-    "review-result": { sentence: () => "Check the result, then accept it or ask for changes.", action: { code: "open-result", label: "Open result" } },
+    "start-builder": { sentence: () => "The builder is offline. Start the builder.", action: { code: "start-worker", label: "Start the builder" } },
+    // The same act as before (it opens the build, where Retry is): only the words are plainer.
+    vanished: { sentence: context => `${Build(context)} stopped unexpectedly. Retry it.`, action: { code: "reconcile-run", label: "Open the build" } },
+    "review-result": { sentence: () => "Check the result, then accept it or send it back.", action: { code: "open-result", label: "Open result" } },
     // Accepting it would not help: it was built to terms that are no longer the plan.
-    rebuild: { sentence: context => `${Build(context)} was made to an earlier plan. Build it again to the current plan.`, action: { code: "retry-task", label: "Build again" } },
+    rebuild: { sentence: context => `${Build(context)} was made to an earlier plan. Retry it on the current plan.`, action: { code: "retry-task", label: "Retry" } },
     // The plan was rewritten after the build and not yet approved: the yes comes first, then Build again.
-    replan: { sentence: context => `The plan changed after ${build(context)}. Approve the new plan, then build it again.`, action: { code: "approve-scope", label: "Approve plan" } },
-    "earlier-version": { sentence: () => "An earlier version of this task still needs you. Finish it first.", action: { code: "inspect-task", label: "Open earlier version" } },
+    replan: { sentence: context => `The plan changed after ${build(context)}. Approve the new plan, then retry it.`, action: { code: "approve-scope", label: "Approve plan" } },
+    "earlier-version": { sentence: context => context.task == null ? "An earlier version of this task still needs you. Finish it first." : `An earlier version, ${context.task}, still needs you. Finish it first.`,
+        action: { code: "inspect-task", label: "Open earlier version" } },
+    // An actionable need, never a quiet Waiting: a person opens it to retry or archive it.
+    history: { sentence: () => "Toolroll can't read this task's history. Open it to retry or archive it.", action: { code: "inspect-task", label: "Open the task" } },
     other: { sentence: () => "Open the task to see what it needs from you.", action: { code: "inspect-task", label: "Open the task" }, useReason: always },
 };
 export const ASKS = ["decide", "review", "unblock"];
@@ -70,7 +75,7 @@ export function askChipOf(read) {
         return "Question";
     if (read.need === "hold")
         return "On hold";
-    if (read.need === "vanished" || read.need === "confirm-stopped" || read.need === "check-stopped")
+    if (read.need === "vanished" || read.need === "stop-unproven")
         return "Stopped";
     if (read.need === "sign-in")
         return "Sign in";
@@ -100,21 +105,28 @@ export const NEED_ASK = {
     approval: "decide", card: "decide", answer: "decide", questions: "decide", "choose-project": "decide", "define-task": "decide",
     "fix-request": "decide", "choose-agent": "decide",
     "review-result": "review", rebuild: "review", replan: "decide",
-    "sign-in": "unblock", "confirm-stopped": "unblock", "check-stopped": "unblock", hold: "unblock", "fix-dependency": "unblock",
-    "add-requirement": "unblock", "connect-builder": "unblock", "start-builder": "unblock", vanished: "unblock", "earlier-version": "unblock", other: "unblock",
+    "sign-in": "unblock", "stop-unproven": "unblock", hold: "unblock", "fix-dependency": "unblock",
+    "add-requirement": "unblock", "connect-builder": "unblock", "start-builder": "unblock", vanished: "unblock", "earlier-version": "unblock", history: "unblock", other: "unblock",
 };
 export const WAITS = {
     "build-finishing": () => "Finishing up; this clears on its own.",
-    "build-stopping": context => `Waiting for ${build(context)} to stop. Nothing is needed from you.`,
+    "build-checking": context => `Making sure ${build(context)} stopped. This clears on its own.`,
+    "build-stopping": context => `Waiting: Toolroll is stopping ${build(context)}.`,
     "other-computer": context => `Waiting for the computer that ran ${build(context)} to confirm it stopped.`,
     "card-reply": () => "Waiting for a reply.",
     "card-time": () => "Waiting before moving on.",
     "card-ci": () => "Waiting for the pull request's checks.",
+    "plan-next": () => "Waiting to plan.",
+    "research-next": () => "Waiting to research.",
+    "builders-busy": () => "Waiting its turn: builders are busy.",
+    "retry-later": context => `Waiting: Toolroll retries ${build(context)} ${context.retry ?? "soon"}.`,
+    "app-update": () => "Waiting: Toolroll is updating. New work starts after it.",
+    "other-task": context => context.task == null ? "Waiting for another task to finish first." : `Waiting for ${context.task} to finish first.`,
 };
-/** Words that name the machine's internals; no Needs you or Waiting sentence carries them. */
-export const BANNED_WORDS = ["witness", "unproven", "quiescence", "quiescent", "digest", "scope digest"];
-const BANNED = new RegExp(`\\b(?:${BANNED_WORDS.join("|")})\\b`, "i");
-export const hasInternalWords = (text) => BANNED.test(text);
+/** Words that name the machine's internals (plain-words.ts, the one table); no Needs you or Waiting sentence carries
+ * them, and a recorded reason that does is replaced by the need's own words. */
+export { BANNED_WORDS, PLAIN_WORDS, bannedWordsIn, hasInternalWords } from "./plain-words.js";
+import { hasInternalWords } from "./plain-words.js";
 /** The sentence for a need: its recorded reason when the need keeps one and
  * it reads plainly, otherwise the need's own words. */
 export function needSentence(key, reason, context = {}) {
@@ -124,35 +136,82 @@ export function needSentence(key, reason, context = {}) {
         return need.sentence(context);
     return need.withReason === undefined ? plain : need.withReason(plain);
 }
+/** Waits whose words need a fact (when it retries, which task it waits on): without it, a plain recorded reason that
+ * already says it is kept. */
+const WAITS_WITH_FACTS = {
+    "retry-later": context => context.retry != null, "other-task": context => context.task != null,
+};
 export function waitSentence(key, reason, context = {}) {
-    if (key !== undefined)
-        return WAITS[key](context);
     const plain = reason?.trim() || null;
-    return plain !== null && !hasInternalWords(plain) ? plain : "Waiting for the work to continue on its own.";
+    const known = plain !== null && !hasInternalWords(plain) ? plain : null;
+    if (key !== undefined)
+        return WAITS_WITH_FACTS[key]?.(context) === false && known !== null ? known : WAITS[key](context);
+    return known ?? "Waiting for the work to continue on its own.";
 }
-/** A finished run Toolroll can't prove stopped (store.stopQuiescenceFact):
- * a person can confirm it only when nothing of it may still be running.
- * `unknown`: Toolroll can't check, so the person confirms they checked. */
+/** A finished run Toolroll can't yet prove stopped (store.stopQuiescenceFact). Nobody is asked to confirm it:
+ * `unprovable` is Toolroll's own check still to run (stop-proof.ts), which settles by itself; `unknown` is that this
+ * computer can't look, or something Toolroll didn't start is in the build's folder — held, with nothing to vouch for. */
 export function processNeedOf(fact) {
     if (fact === null)
         return null;
     if (fact.kind === "settling")
         return { wait: "build-finishing", build: fact.run };
     if (fact.kind === "unprovable")
-        return { need: "confirm-stopped", build: fact.run };
+        return { wait: "build-checking", build: fact.run };
     if (fact.kind === "unknown")
-        return { need: "check-stopped", build: fact.run };
+        return { need: "stop-unproven", build: fact.run };
     return { wait: fact.kind === "elsewhere" ? "other-computer" : "build-stopping", build: fact.run };
 }
-/** Dispatch and work-index codes that wait on a person, as their need. */
-export const CODE_NEED = {
-    "signed-out": "sign-in", "needs-approval": "approval", "waiting-decision": "answer", "decision-queue": "answer",
-    "needs-project": "choose-project", "needs-scope": "define-task", "planner-source": "fix-request", "needs-agent-profile": "choose-agent",
-    "terminal-dependency": "fix-dependency", "missing-requirement": "add-requirement", "no-worker-registered": "connect-builder",
-    "no-worker-online": "start-builder", "vanished-run": "vanished", "needs-verification": "review-result", "proof-refuted": "review-result",
-    "no-build-record": "review-result", "verification-needed": "review-result", "evidence-mismatch": "review-result",
-    "record-incomplete": "review-result", "evidence-damaged": "review-result",
+export const CODE_READING = {
+    // Plain states: nothing is asked and nothing is waited on by name.
+    queued: { stage: "queued" }, ready: { stage: "queued" }, "provider-quota": { stage: "queued" },
+    running: { stage: "building" }, reviewing: { stage: "reviewing" }, "review-pending": { stage: "building" }, "checks-running": { stage: "checking" },
+    "ready-to-check": { stage: "finished", act: "open-result" }, "ready-to-review": { stage: "finished" }, "report-ready": { stage: "finished" }, "no-change": { stage: "finished" },
+    "pr-opened": { stage: "finished" }, "merge-observed": { stage: "finished" }, "pr-closed": { stage: "finished" }, "agent-attested": { stage: "finished" }, "accepted-exception": { stage: "finished" },
+    complete: { stage: "complete", act: "open-result" }, cancelled: { stage: "stopped", act: "inspect-task" }, paused: { stage: "stopped" },
+    stopped: { stage: "stopped", act: "resume-run" },
+    failed: { stage: "failed", act: "retry-task" }, "checks-failed": { stage: "failed" },
+    // The same failure again and again: a need over Retry, its own act, said plainly.
+    "waiting-incident": { stage: "failed", act: "retry-task" },
+    // Waits: Toolroll or another task moves these on; no person is asked.
+    stopping: { stage: "waiting", wait: "build-stopping" },
+    "build-stopping": { stage: "waiting", wait: "build-stopping" }, "other-computer": { stage: "waiting", wait: "other-computer" },
+    "planning-ready": { stage: "waiting", wait: "plan-next" }, "scouting-ready": { stage: "waiting", wait: "research-next" },
+    "worker-at-capacity": { stage: "waiting", wait: "builders-busy" }, "retry-scheduled": { stage: "waiting", wait: "retry-later" },
+    updating: { stage: "waiting", wait: "app-update" }, "waiting-dependency": { stage: "waiting", wait: "other-task" },
+    // Needs, each over the act it has always had.
+    "history-problem": { stage: "needs-you", need: "history", act: "inspect-task" },
+    "earlier-active": { stage: "needs-you", need: "earlier-version", act: "inspect-task" },
+    "waiting-decision": { stage: "needs-you", need: "answer", act: "answer-decision" },
+    "decision-queue": { stage: "needs-you", need: "questions", act: "inspect-decisions" },
+    // A saved result that can't simply be accepted yet: its own reason (resultHoldUpSentence) is the sentence.
+    "result-needs-attention": { stage: "needs-you", need: "other", act: "inspect-run" },
+    "process-needs-attention": { stage: "needs-you", need: "stop-unproven", act: "inspect-run" },
+    "vanished-run": { stage: "needs-you", need: "vanished", act: "reconcile-run" },
+    held: { stage: "needs-you", need: "hold", act: "inspect-hold" },
+    "terminal-dependency": { stage: "needs-you", need: "fix-dependency", act: "repair-dependency" },
+    "needs-project": { stage: "needs-you", need: "choose-project", act: "place-task" },
+    "needs-scope": { stage: "needs-you", need: "define-task", act: "write-scope" },
+    "invalid-scope": { stage: "needs-you", need: "define-task", act: "write-scope" },
+    "planner-source": { stage: "needs-you", need: "fix-request", act: "write-scope" },
+    "needs-agent-profile": { stage: "needs-you", need: "choose-agent", act: "select-agent" },
+    "needs-approval": { stage: "needs-you", need: "approval", act: "approve-scope" },
+    "missing-requirement": { stage: "needs-you", need: "add-requirement", act: "repair-capability" },
+    "no-worker-registered": { stage: "needs-you", need: "connect-builder", act: "start-worker" },
+    "no-worker-online": { stage: "needs-you", need: "start-builder", act: "start-worker" },
+    "signed-out": { stage: "needs-you", need: "sign-in", act: "sign-in" },
+    "needs-verification": { stage: "needs-you", need: "review-result" }, "proof-refuted": { stage: "needs-you", need: "review-result" },
+    "no-build-record": { stage: "needs-you", need: "review-result" }, "verification-needed": { stage: "needs-you", need: "review-result" },
+    "evidence-mismatch": { stage: "needs-you", need: "review-result" }, "record-incomplete": { stage: "needs-you", need: "review-result" },
+    "evidence-damaged": { stage: "needs-you", need: "review-result" },
 };
+/** A code that waits on Toolroll or another task: no person is asked. */
+export const isWaitCode = (code) => CODE_READING[code]?.stage === "waiting";
+/** Notification kinds that need nothing from a person: they stay in the activity log and never ping a phone. */
+export const ACTIVITY_ONLY_KINDS = new Set(["check-progress"]);
+/** Dispatch and work-index codes that wait on a person, as their need (read from CODE_READING). */
+export const CODE_NEED = Object.fromEntries(Object.entries(CODE_READING)
+    .flatMap(([code, reading]) => reading.need === undefined ? [] : [[code, reading.need]]));
 /** A stopped run's recorded reason code, in words (the run record, the thread, a failed task's status). */
 export const RUN_REASON_WORDS = {
     agent: "the agent failed",
@@ -165,28 +224,28 @@ export const RUN_REASON_WORDS = {
     git: "a git step failed",
     "malformed-decision": "the agent's question was malformed",
     "malformed-plan": "the plan was malformed",
-    fenced: "another worker took the task over",
-    unapproved: "the scope was not approved",
-    "scope-changed": "the scope changed after approval",
+    fenced: "another builder took the task over",
+    unapproved: "the plan was not approved",
+    "scope-changed": "the plan changed after approval",
     capability: "a requirement was missing",
     setup: "the workspace preparation step failed",
     "provider-init": "the agent could not start",
     "commit-failure": "the commit failed",
     "protected-branch": "refused to touch a protected branch",
     "wrong-branch": "the checkout was on the wrong branch",
-    "not-leased": "the lease was not valid",
-    "no-claim": "the lease was not valid",
-    "not-yours": "the lease was not valid",
-    "no-run-record": "the run record was missing",
-    "missing-mailbox": "the resume mailbox could not be read",
-    "unreadable-mailbox": "the resume mailbox could not be read",
+    "not-leased": "the builder lost its hold on the task",
+    "no-claim": "the builder lost its hold on the task",
+    "not-yours": "the builder lost its hold on the task",
+    "no-run-record": "the build's record was missing",
+    "missing-mailbox": "the saved notes to resume from could not be read",
+    "unreadable-mailbox": "the saved notes to resume from could not be read",
     "revision-brief": "the revision brief could not be read",
     "repaired-park": "resumed from a parked question",
-    stopped: "stopped by the operator",
-    acceptance: "the result didn't meet its signed requirements",
-    evidence: "its evidence could not be saved",
+    stopped: "stopped by a person",
+    acceptance: "the result didn't meet its approved requirements",
+    evidence: "its saved files could not be kept",
     interrupted: "the attempt was interrupted",
-    orphaned: "the attempt lost its worker",
+    orphaned: "the attempt lost its builder",
     "retryable-infra": "a temporary problem on the machine stopped it",
     unknown: "the attempt stopped unexpectedly",
     "spawn-failed": "the agent process could not start",
@@ -194,12 +253,12 @@ export const RUN_REASON_WORDS = {
     "auth-expired": "the agent's sign-in expired",
     "budget-unenforceable": "its spending limit could not be enforced",
     "stale-source": "the request changed while the plan was being made",
-    "stale-approval": "the approval no longer matched the scope",
+    "stale-approval": "the approval no longer matched the plan",
     "source-invalid": "the plan's source could not be recorded",
     "external-closed": "the linked issue was closed while it was being built",
     "repair-admission": "the repair could not start",
     "reviewer-error": "the review failed",
-    "malformed-report": "the scout's report was malformed",
+    "malformed-report": "the research report was malformed",
     "attempts-exhausted": "it failed too many times in a row",
     "plan-revised": "the plan changed, so a fresh attempt took over",
 };
@@ -257,7 +316,7 @@ export function failedAttemptSentence(reason) {
 /** What to change before the next attempt, by a stopped run's recorded reason: one plain suggestion, the note Retry
  * starts with. A reason with no suggestion of its own gets the general one. */
 const STOP_SUGGESTIONS = {
-    acceptance: "Before handing off, check each signed requirement against the changes.",
+    acceptance: "Before handing off, check each approved requirement against the changes.",
     timeout: "Split the work into smaller steps, or name the one part to finish first.",
     "no-op": "Say exactly which files or behaviour should change.",
     agent: "Say what to do differently this time, or name the part to try first.",

package/dist/nightly-github.d.ts

@@ -159,6 +159,8 @@ export type NightlyRead = {
  * failed call stops where it is; what was recorded stays, and the cursor never moves past a page it couldn't read.
  */
 export declare function readGithubNightly(store: Store, repo: string, deps: NightlyDeps, budgetMs: number): Promise<NightlyRead>;
+/** Read one run by id, strictly. */
+export declare function readRun(get: Get, slug: string, id: number): Promise<GhRun | null>;
 /** Every job of one exact attempt of one run, every page, each GitHub's record of that run, attempt and commit. Null
  * when any page can't be read whole. */
 export declare function readAttemptJobs(get: Get, slug: string, run: number, attempt: number, sha: string): Promise<GhJob[] | null>;

package/dist/nightly-github.js

@@ -410,7 +410,7 @@ async function listRuns(store, repo, slug, get, now) {
     return { ok: true, listed, complete: false };
 }
 /** Read one run by id, strictly. */
-async function readRun(get, slug, id) {
+export async function readRun(get, slug, id) {
     const got = await get(`repos/${slug}/actions/runs/${id}`);
     if (!got.ok)
         return null;
@@ -556,7 +556,7 @@ function recordAttempt(store, repo, attempt, now) {
                 store.enqueueNotification({ dedupeKey: `github-nightly-failed:${Number(opened.lastInsertRowid)}`, kind: "github-nightly-failed", subject: "GitHub's nightly failed on main",
                     body: `Nightly checks failed: ${lane}, on main at ${attempt.sha.slice(0, 7)}. Releases wait until it passes again.`, pushClass: "attention",
                     // The project it belongs to, so its people's chats may carry it (Codex round 1, finding 8).
-                    source: { project: repo }, link: "/board" }, now);
+                    source: { project: repo }, link: "/tasks?view=board" }, now);
             }
         }
     });
@@ -954,7 +954,7 @@ export function nightlyNeedsYou(store, shown) {
         for (const failure of openFailures(store, repo)) {
             needs.push({ key: `github-nightly-${failure.id}`, repo, title: `Nightly checks failed: ${laneName(store, repo, failure.laneId)}`,
                 reason: `On main at ${failure.sha.slice(0, 7)}. Releases wait until it passes again.`,
-                href: slug === null ? "/board" : `https://github.com/${slug}/actions/runs/${failure.ghRun}/job/${failure.jobId}`, since: failure.openedAt });
+                href: slug === null ? "/tasks?view=board" : `https://github.com/${slug}/actions/runs/${failure.ghRun}/job/${failure.jobId}`, since: failure.openedAt });
         }
     }
     // The plane's own nightly check of main (nightly-check.ts): one item per failed check, its items summed up.
@@ -968,7 +968,7 @@ export function nightlyNeedsYou(store, shown) {
         const items = store.handle.prepare("SELECT item FROM main_check_failure WHERE repo = ? AND run = ? AND cleared_at IS NULL ORDER BY item").all(repo, Number(row["run"])).map(one => String(one["item"]));
         needs.push({ key: `main-check-${Number(row["run"])}`, repo, title: `Nightly check of main failed: ${failureSummary(items)}`,
             reason: `On main at ${String(row["sha"]).slice(0, 7)}. Composed releases wait until a full check passes.`,
-            href: task === null ? "/board" : `/t/${encodeURIComponent(task)}`, since: String(row["since"]) });
+            href: task === null ? "/tasks?view=board" : `/t/${encodeURIComponent(task)}`, since: String(row["since"]) });
     }
     return needs.sort((a, b) => a.since.localeCompare(b.since));
 }

package/dist/operate-remote-arguments.js

@@ -20,6 +20,7 @@ export const REMOTE_ARGUMENTS = new Map([
     ['task ask', args('id:task', 'person why')],
     ['task checks', args('task:task', 'level')],
     ['task ship', args('task:task')],
+    ['task ready', args('task:task')],
     ['task add-tests', args('task:task')],
     ['task list', args('', 'state view limit cursor')],
     ['task show', args('id:task')],
@@ -57,10 +58,14 @@ export const REMOTE_ARGUMENTS = new Map([
     ['template show', args('name')],
     ...['search', 'impact'].map(action => [`knowledge ${action}`, args('query', 'base')]),
     ['knowledge refresh', args('', 'base')],
+    ['map', args('', 'cursor')], ...['area', 'file'].map(action => [`map ${action}`, args('target', 'cursor')]), ['map search', args('target*', 'cursor')], ['map refresh', args('')],
     // Decision reads are already project-bound in project-memory.ts. Memory writes (decide, retire, apply) are a person's
     // step-up, never a token's act, so none is listed here.
+    // Project-bound by flaky-cli.ts like memory reads; a row's key is compared inside the reader's own project.
+    ['flaky list', args('', 'days')],
+    ['flaky show', args('identity*', 'days')],
     ...['search', 'decisions', 'show', 'review', 'status'].map(action => [`memory ${action}`,
-        args(action === 'search' ? 'query*' : action === 'show' ? 'query' : '', 'why reason supersedes source all decision sessions no-local')]),
+        args(action === 'search' ? 'query*' : action === 'show' ? 'query' : '', 'why reason supersedes source all decision claim choice revision sessions no-local')]),
     ['flows list', args()],
     ['flows show', args('flow:flow')], ['flows export', args('flow:flow')],
     ['flows create', args('', 'yes name template', { steps: 'steps' })],

package/dist/operate-remote.js

@@ -37,7 +37,7 @@ const references = { kind: "references" }, listing = { kind: "listing" };
 export const REMOTE_SCOPES = new Map([
     ["status", listing], ["integrations", installation], ["ready", listing], ["grants", installation], ["sync", installation],
     ["gaps", repo], ["task add", repo],
-    ...["ask", "checks", "ship", "add-tests", "show", "wait", "complete", "revise", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign", "scope", "plan", "hold",
+    ...["ask", "checks", "ship", "ready", "add-tests", "show", "wait", "complete", "revise", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign", "scope", "plan", "hold",
         "unhold", "require", "requeue", "review", "repair", "route", "reopen", "stop", "resume"].map(action => [`task ${action}`, references]),
     ["check-progress", references],
     ["task list", listing],
@@ -50,7 +50,9 @@ export const REMOTE_SCOPES = new Map([
     // The person's own remote actions, or everyone's within their projects for an approver (remote-audit.ts).
     ["audit", self],
     ["knowledge search", repo], ["knowledge impact", repo], ["knowledge refresh", repo],
+    ["map", repo], ["map area", repo], ["map file", repo], ["map search", repo], ["map refresh", repo],
     ...["search", "decisions", "show", "review", "status"].map(action => [`memory ${action}`, self]),
+    ["flaky list", self], ["flaky show", self],
     ...["list", "show", "export", "create", "edit", "trigger add", "trigger pause", "trigger resume", "trigger remove", "card add", "archive"]
         .map(action => [`flows ${action}`, self]),
     ["models status", global], ["models list", global],

package/dist/operate.d.ts

@@ -124,7 +124,7 @@ type Args = {
  * exports are behavior, not commentary — and the declared command guide
  * (surface.ts) is tested for exact equality against them.
  */
-export declare const TASK_ACTIONS: readonly ["add", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign", "reopen", "scope", "approve", "hold", "unhold", "require", "requeue", "regate", "plan", "review", "accept", "repair", "route", "stop", "resume", "complete", "revise", "merge", "ask", "checks", "add-tests", "archive", "restore", "tidy", "ship"];
+export declare const TASK_ACTIONS: readonly ["add", "new", "keep", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign", "reopen", "scope", "approve", "hold", "unhold", "require", "requeue", "regate", "plan", "review", "accept", "repair", "route", "stop", "resume", "complete", "revise", "merge", "ask", "checks", "add-tests", "archive", "restore", "tidy", "ship", "ready"];
 export declare const PUBLISH_ACTIONS: readonly ["setup", "grant", "revoke", "status", "unblock", "rearm", "merge", "refire"];
 export declare const CONFIG_ACTIONS: readonly ["show", "set", "clear"];
 export declare const APPROVER_ACTIONS: readonly ["list", "add"];
@@ -360,6 +360,8 @@ export type EasyCommandSeams = {
     check?: import("./provider-connection.js").ConnectionChecker;
     ask?: (question: string) => Promise<string>;
     askHidden?: (question: string) => Promise<string>;
+    confirm?: (question: string) => Promise<boolean>;
+    github?: import("./github-import.js").ImportDeps;
 };
 /**
  * Easy start: the ports `up --laptop` (no --port) tries, in order. The port this install saved, alone; else, for a NEW
@@ -368,3 +370,6 @@ export type EasyCommandSeams = {
  * way) `up`'s default alone, as before. `fromSeam` replaces the default range in tests.
  */
 export declare function upLaptopPortCandidates(store: Store, fromSeam?: readonly number[]): number[];
+/** The watch loop's background learning pass (docs/plans/learning-loops.md): advisory reads, each project at most every
+ * 30 minutes through the plane's own gh. A failure here never reaches the loop: it is tried on the next pass. */
+export declare function refreshLearning(store: Store, now: () => Date, reads?: GhRead): Promise<void>;