@uchibeke/gallivant 0.2.1 → 0.3.0

package/lib/commands/init.mjs

@@ -9,14 +9,19 @@
 import { mkdirSync, openSync, closeSync, writeFileSync, lstatSync, realpathSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { execFileSync } from "node:child_process";
+import { isDeepStrictEqual } from "node:util";
 import { gallivantHome, expand, templatePath, readJson, writeJsonAtomic, contract, VERSION, PACKAGE_NAME } from "../fs.mjs";
 import { discoverHarnesses, validate, merge, configPath, repoEntry } from "../config.mjs";
-import { makeGh, repoFromRemote } from "../gh.mjs";
+import { hosts, makeHostRegistry } from "../hosts.mjs";
+import { repositoryReviewConfig } from "../review_policy.mjs";
+import { safeOrigin, assertBranchName } from "../repository.mjs";
+export { safeOrigin };
 import { silentLog } from "../log.mjs";
 import { checkHarness } from "../probe.mjs";
-import { resolveCredential, describe as describeCredential } from "../credential.mjs";
+import { describe as describeCredential } from "../credential.mjs";
 import { doctor as runDoctor, repositoryWriteScopeCheck } from "./doctor.mjs";
 import { acquireCliMutation } from "../daemon.mjs";
+import { repositoryPreflight } from "../repository_preflight.mjs";
 
 export const INIT_HARNESSES = ["codex", "claude"];
 
@@ -26,13 +31,6 @@ const NOTHING_WRITTEN = "Setup did not complete and nothing was written.";
 const firstLine = e => String(e?.message || e).split("\n")[0];
 const isSymlink = p => { try { return lstatSync(p).isSymbolicLink(); } catch { return false; } };
 
-/**
- * A remote URL with its userinfo removed. `https://x-access-token:SECRET@github.com/...` is a remote git and
- * `repoFromRemote` both accept, and every message here that names the origin would otherwise print the secret into
- * a terminal or a CI log. Only scheme URLs carry userinfo; `git@github.com:owner/name` names a login, not a secret.
- */
-export const safeOrigin = url => String(url || "").replace(/^([a-z][a-z0-9+.-]*:\/\/)[^@/]*@/i, "$1");
-
 /**
  * The repository a checkout belongs to, read from its `origin` remote. Local only: no network, no `gh`. Throws a
  * message naming the unmet prerequisite, so a directory that is not a GitHub checkout is refused before anything else
@@ -50,8 +48,9 @@ export function targetRepository(dir = process.cwd(), exec = execFileSync) {
   if (!checkout) throw new Error(`${dir} is not inside a Git checkout. Run gallivant init from the repository you want to set up (cd into it first). ${NOTHING_WRITTEN}`);
   const origin = git(["remote", "get-url", "origin"]);
   if (!origin) throw new Error(`${checkout} has no origin remote. Create the repository on GitHub and add it (git remote add origin https://github.com/<owner>/<name>.git), then rerun gallivant init. ${NOTHING_WRITTEN}`);
-  const repo = repoFromRemote(origin);
-  if (!repo) throw new Error(`origin remote ${safeOrigin(origin)} is not a github.com repository URL. Gallivant opens pull requests on github.com; point origin at the GitHub repository, then rerun gallivant init. ${NOTHING_WRITTEN}`);
+  let repo;
+  try { repo = hosts.inspectRemote(origin).repository.key; }
+  catch (error) { throw new Error(`${error.message} ${NOTHING_WRITTEN}`); }
   // The redacted form is the only one returned: nothing downstream needs the credential, and nothing may print it.
   return { checkout, origin: safeOrigin(origin), repo };
 }
@@ -86,9 +85,9 @@ export async function init(options = {}) {
   }
 }
 
-async function initAttempt({ home = gallivantHome(), harness = null, worktrees = null, dir = process.cwd(),
-  discover = discoverHarnesses, gh = makeGh({ log: silentLog }), repository = targetRepository, harnessCheck = checkHarness, doctor = runDoctor,
-  resolve = resolveCredential, ghFor = credential => makeGh({ credential: async () => credential, log: silentLog }) } = {}) {
+async function initAttempt({ home = gallivantHome(), harness = null, worktrees = null, hostConfig = null, base = null, dir = process.cwd(),
+  discover = discoverHarnesses, gh = null, repository = targetRepository, harnessCheck = checkHarness, doctor = runDoctor,
+  resolve = null, ghFor = null, transportPreflight = repositoryPreflight } = {}) {
   if (harness != null && !INIT_HARNESSES.includes(harness)) throw new Error("init supports --harness codex or claude; configure other adapters explicitly after checking docs/install.md");
   home = expand(home);
   const file = configPath(home);
@@ -104,15 +103,41 @@ async function initAttempt({ home = gallivantHome(), harness = null, worktrees =
 
   // 1. The repository, before any network call: a directory that is not a GitHub checkout has nothing to set up.
   const target = repository(dir);
+  if (base !== null) assertBranchName(base);
+  const setup = existing ? structuredClone(raw) : {};
+  let selectedHost = makeHostRegistry({ config: setup }).inspect(target.repo);
+  if (hostConfig !== null) {
+    const settings = readJson(expand(hostConfig), null);
+    const errors = selectedHost.adapter.validateConfig?.(settings) ?? ["This host does not support --host-config"];
+    if (errors.length) throw new Error(`${errors.join("; ")}. ${NOTHING_WRITTEN}`);
+    const previous = setup.git_hosts?.[selectedHost.repository.host];
+    // Setup adds observed identities after importing policy. Carry only those
+    // generated fields into the comparison; omitted policy remains a conflict,
+    // and a supplied identity may never overwrite a different saved binding.
+    for (const [path, binding] of Object.entries(previous?.repositories ?? {})) {
+      if (!binding || typeof binding !== "object") continue;
+      const identity = Object.fromEntries(["uuid", "workspaceUuid"].filter(key => Object.hasOwn(binding, key)).map(key => [key, binding[key]]));
+      if (Object.keys(identity).length) settings.repositories = { ...settings.repositories, [path]: { ...identity, ...settings.repositories?.[path] } };
+    }
+    if (previous && !isDeepStrictEqual(previous, settings)) throw new Error(`Existing host settings differ; edit the selected config explicitly instead of replacing them with --host-config. ${NOTHING_WRITTEN}`);
+    setup.git_hosts = { ...setup.git_hosts, [selectedHost.repository.host]: previous ?? settings };
+    selectedHost = makeHostRegistry({ config: setup }).inspect(target.repo);
+  }
+  gh ??= selectedHost.api;
+  resolve ??= config => selectedHost.adapter.credential(config, selectedHost.repository);
+  ghFor ??= credential => makeHostRegistry({ credential: async () => credential, log: silentLog }).inspect(target.repo).api;
 
   // 2. GitHub sign-in, by asking `gh` who it is. The fix is `gh`'s own login flow; nothing here reads a credential.
   let login = null, ghError = null;
   try { login = await gh.user(); } catch (e) { ghError = firstLine(e); }
-  if (!/^[A-Za-z0-9][A-Za-z0-9-]*$/.test(login || "")) throw new Error(`GitHub CLI is not signed in${ghError ? ` (${ghError})` : ""}.\nRun: gh auth login\nThen rerun gallivant init. ${NOTHING_WRITTEN}`);
+  if (selectedHost.adapter.features?.transportSetup) {
+    if (!login) throw new Error(`${ghError || "Host API credential is missing"}\n${NOTHING_WRITTEN}`);
+  } else if (!/^[A-Za-z0-9][A-Za-z0-9-]*$/.test(login || "")) throw new Error(`GitHub CLI is not signed in${ghError ? ` (${ghError})` : ""}.\nRun: gh auth login\nThen rerun gallivant init. ${NOTHING_WRITTEN}`);
 
   // 3. The config this run would leave behind, built but not yet written.
   const selected = harness ?? (existing ? onlyLocalHarness(raw) : "codex");
-  const candidate = existing ? structuredClone(raw) : {
+  const candidate = existing ? setup : {
+    ...setup,
     trusted_authors: [login], worktrees: expand(worktrees || join(dirname(home), ".gallivant-worktrees")),
     harness: {}, notify: null, github_token_file: null, repos: [],
   };
@@ -122,6 +147,11 @@ async function initAttempt({ home = gallivantHome(), harness = null, worktrees =
     if (!found) throw new Error(`${selected} is not on PATH. Install it and sign in, then retry gallivant init --harness ${selected}. ${NOTHING_WRITTEN}`);
     candidate.harness = { ...(candidate.harness || {}), [selected]: found };
   }
+  if (selectedHost.adapter.reviewPolicy) repositoryReviewConfig(candidate, target.repo, selectedHost.adapter);
+  if (base !== null) {
+    const previous = (candidate.repos || []).find(r => repoEntry(r)?.repo === target.repo);
+    candidate.repos = [...(candidate.repos || []).filter(r => repoEntry(r)?.repo !== target.repo), { ...(typeof previous === "object" ? previous : {}), repo: target.repo, base }];
+  }
   const merged = merge(candidate, home);
   const problems = validate(merged, home);
   if (problems.length) throw new Error(`${existing ? `Config problems in ${contract(file)}: ` : ""}${problems.join("; ")}. ${NOTHING_WRITTEN}`);
@@ -139,18 +169,26 @@ async function initAttempt({ home = gallivantHome(), harness = null, worktrees =
   //    operator's ambient login is the wrong identity to ask: an explicit PAT that cannot reach the repository is the
   //    failure this check exists to catch, and an ambient login that can would hide it.
   const runConfig = { ...merged, github_token_file: merged.github_token_file ? expand(merged.github_token_file) : null };
-  let credential;
-  try { credential = await resolve(runConfig); } catch (e) { throw new Error(`${firstLine(e)}\n${NOTHING_WRITTEN}`); }
-  if (!credential?.token) throw new Error(`${credential?.why || "No GitHub credential could be resolved for a run."}\n${NOTHING_WRITTEN}`);
-  const identity = describeCredential(credential);
-  const runGh = ghFor(credential);
-  const perm = await runGh.repoPermissions(target.repo).catch(e => ({ error: firstLine(e) }));
-  if (!perm || perm.error) throw new Error(`GitHub cannot resolve ${target.repo} with the run credential (${identity})${perm?.error ? `: ${perm.error}` : ""}. Check that origin (${safeOrigin(target.origin)}) names a repository that credential can see, then rerun gallivant init. ${NOTHING_WRITTEN}`);
-  if (perm.archived) throw new Error(`${target.repo} is archived, so nothing can be pushed to it. Unarchive it or run gallivant init in another repository. ${NOTHING_WRITTEN}`);
-  if (!perm.push) throw new Error(`the run credential (${identity}) has no push permission on ${target.repo}. ${runConfig.github_token_file ? `Give the token in ${contract(runConfig.github_token_file)} Contents: write on ${target.repo}` : "Ask for write access, or fork it and point origin at the fork"}, then rerun gallivant init. ${NOTHING_WRITTEN}`);
-  // Repository role alone does not grant a classic token write scope, even when that account can push.
-  const scope = await repositoryWriteScopeCheck(runGh, credential);
-  if (!scope.ok) throw new Error(`${scope.detail}.\nFix: ${scope.fix}\n${NOTHING_WRITTEN}`);
+  if (selectedHost.adapter.features?.transportSetup) {
+    const report = await transportPreflight(runConfig, target.repo);
+    const host = selectedHost.repository.host, path = selectedHost.repository.path;
+    candidate.git_hosts = { ...candidate.git_hosts, [host]: { ...candidate.git_hosts?.[host], repositories: {
+      ...candidate.git_hosts?.[host]?.repositories, [path]: { ...candidate.git_hosts?.[host]?.repositories?.[path], uuid: report.identity.uuid, workspaceUuid: report.identity.workspaceUuid },
+    } } };
+  } else {
+    let credential;
+    try { credential = await resolve(runConfig); } catch (e) { throw new Error(`${firstLine(e)}\n${NOTHING_WRITTEN}`); }
+    if (!credential?.token) throw new Error(`${credential?.why || "No GitHub credential could be resolved for a run."}\n${NOTHING_WRITTEN}`);
+    const identity = describeCredential(credential);
+    const runGh = ghFor(credential);
+    const perm = await runGh.repoPermissions(selectedHost.repository.path).catch(e => ({ error: firstLine(e) }));
+    if (!perm || perm.error) throw new Error(`GitHub cannot resolve ${target.repo} with the run credential (${identity})${perm?.error ? `: ${perm.error}` : ""}. Check that origin (${safeOrigin(target.origin)}) names a repository that credential can see, then rerun gallivant init. ${NOTHING_WRITTEN}`);
+    if (perm.archived) throw new Error(`${target.repo} is archived, so nothing can be pushed to it. Unarchive it or run gallivant init in another repository. ${NOTHING_WRITTEN}`);
+    if (!perm.push) throw new Error(`the run credential (${identity}) has no push permission on ${target.repo}. ${runConfig.github_token_file ? `Give the token in ${contract(runConfig.github_token_file)} Contents: write on ${target.repo}` : "Ask for write access, or fork it and point origin at the fork"}, then rerun gallivant init. ${NOTHING_WRITTEN}`);
+    // Repository role alone does not grant a classic token write scope, even when that account can push.
+    const scope = selectedHost.adapter.features?.repositoryScopes ? await repositoryWriteScopeCheck(runGh, credential) : { ok: true };
+    if (!scope.ok) throw new Error(`${scope.detail}.\nFix: ${scope.fix}\n${NOTHING_WRITTEN}`);
+  }
 
   // 6. Write. The repository is deduplicated by lowercased name whichever form each entry takes, so a second run,
   //    or a run from a clone whose remote spells the owner differently, never appends a duplicate. The string form is
@@ -183,8 +221,8 @@ async function initAttempt({ home = gallivantHome(), harness = null, worktrees =
     repo: target.repo, checkout: target.checkout, recorded: !known,
     harness: selected, harnesses: Object.keys(merged.harness),
     worktrees: expand(merged.worktrees),
-    preserved: existing ? Object.keys(raw).filter(k => k !== "repos") : [],
-    config: merged, doctor: results,
+    preserved: existing ? Object.keys(raw).filter(k => k !== "repos" && !(selectedHost.adapter.features?.transportSetup && k === "git_hosts")) : [],
+    config: merged, doctor: results, dispatchGuidance: selectedHost.adapter.dispatchReason ?? null,
     templates: { passport: templatePath("passport.gallivant.json"), sandbox: templatePath("claude-settings.json") },
   };
 }
@@ -223,6 +261,10 @@ export function renderInit(r, report, { npx = viaNpx(), script = process.argv[1]
     "",
     "Next:",
   ];
+  if (r.dispatchGuidance) {
+    lines.push(`  ${r.dispatchGuidance}`, `  Check access again: ${cmd} doctor`);
+    return lines.join("\n");
+  }
   if (failed) lines.push(`  Fix the ${failed} failing check(s) above, then run:   ${cmd} doctor`);
   else lines.push(`  All checks passed. Confirm the reviewer setting in ${contract(r.file)} (default: the Codex GitHub review integration), then start a small task.`);
   lines.push(

package/lib/commands/register.mjs

@@ -1,3 +1,7 @@
+import { repositoryReviewConfig } from "../review_policy.mjs";
+import { hosts } from "../hosts.mjs";
+import { assertRepositoryAccess } from "../host_contract.mjs";
+import { hostApi } from "../hosts.mjs";
 // `gallivant register <pr-url>`: put a hand-made PR, or one opened from a terminal session, into the loop.
 // On an entry that already exists it is the reset: reason cleared, iteration zero, a reset comment posted so the
 // count recovered from GitHub agrees, watching again.
@@ -5,7 +9,9 @@ import { resolve } from "node:path";
 import { newEntry, entryId, STATES } from "../state.mjs";
 import { worktreePath, isOurBranch, prdIdFromBranch } from "../git.mjs";
 import { parseBlock, normalizePublicBody } from "../block.mjs";
-import { repoFromUrl, remoteMatches, RESET_MARKER } from "../gh.mjs";
+import { repoFromUrl } from "../hosts.mjs";
+import { remoteMatches, safeOrigin } from "../repository.mjs";
+import { RESET_MARKER } from "../host_contract.mjs";
 import { receiptHash } from "../deliverable.mjs";
 import { rememberRepo, defaultHarness } from "../config.mjs";
 import { isSessionFor, capabilitiesFor } from "../harness.mjs";
@@ -13,22 +19,28 @@ import { executionEpoch, reserveExecutionEpoch } from "../execution.mjs";
 import { acquireRuntimeOwner } from "../daemon.mjs";
 import { ensurePrdSnapshot, toPrdId } from "../prd.mjs";
 import { nowIso, floorSecond } from "../time.mjs";
+import { legacyReviewPolicy, selectReviewPolicy } from "../review_policy.mjs";
 
 /** The PRD id for a hand-made branch: our own convention when the branch follows it, else a slug of the name. */
 const prdIdFor = branch => prdIdFromBranch(branch) ?? toPrdId(branch);
 
 export async function register(ctx, { url, harness = null, session = null, worktree = null }) {
-  const { config, state, gh, git, log } = ctx;
+  const { config, state, git, log } = ctx;
+  const host = hostApi(ctx);
   const publicSince = floorSecond(nowIso());
   // Resolved against the directory `register` runs in, before anything reads it. The registry is read back by a
   // daemon whose working directory is its own, so a relative path stored as typed would point somewhere else there:
   // the harness would run in the wrong tree, or `ensureWorktree` would clone over it. Absolute from here on.
   if (worktree) worktree = resolve(worktree);
-  const parsed = repoFromUrl(url);
-  if (!parsed) throw new Error(`not a GitHub PR URL: ${url}`);
-  const pr = await gh.prView(parsed.repo, parsed.number);
+  const selectedHost = (ctx.hosts ?? hosts).fromUrl(url);
+  const parsed = { repo: selectedHost.repository.key, number: selectedHost.number };
+  if (!parsed) throw new Error("Invalid or unsupported host PR URL; use a canonical URL on a qualified host");
+  repositoryReviewConfig(config, parsed.repo, selectedHost.adapter);
+  const pr = await host.prView(parsed.repo, parsed.number);
   // The repo as GitHub spells it, so an oddly cased URL never yields a second entry for the same PR.
-  const repo = repoFromUrl(pr.url)?.repo || parsed.repo;
+  const observed = (ctx.hosts ?? hosts).fromUrl(pr.url);
+  if (observed.repository.key !== parsed.repo || observed.number !== parsed.number) throw new Error("PR identity mismatch; restore the qualified URL before registering");
+  const repo = observed.repository.key;
   if (pr.isCrossRepository) throw new Error("fork PRs are not registered");
   if (pr.state !== "OPEN") throw new Error(`PR is ${pr.state}`);
 
@@ -37,10 +49,12 @@ export async function register(ctx, { url, harness = null, session = null, workt
   const found = state.findByPr(repo, pr.number);
   const id = found ? found[0] : entryId(repo, prdId);
   const existing = found ? found[1] : state.get(id);
+  const reviewPolicy = existing?.reviewPolicy || (existing ? legacyReviewPolicy(repositoryReviewConfig(config, repo, selectedHost.adapter)) : ctx.reviewService ? await ctx.reviewService.preflight(repo) : selectReviewPolicy(config, repo));
   state.assertCanRegister(id);
   if (existing && existing.pr !== pr.number && existing.pr !== null) throw new Error(`${id} already watches PR #${existing.pr}`);
   const chosenHarness = harness || existing?.harness || block?.harness || defaultHarness(config);
   if (!config.harness[chosenHarness]) throw new Error(`harness "${chosenHarness}" is not configured`);
+  assertRepositoryAccess(capabilitiesFor(chosenHarness), selectedHost.repository);
   const switching = existing && chosenHarness !== existing.harness;
   // A daemon holds this lock for its entire lifetime. Claim it through the
   // GitHub reset and registry write so an old-provider tick cannot dispatch
@@ -141,14 +155,14 @@ export async function register(ctx, { url, harness = null, session = null, workt
     fenced = true;
   }
   if (existing) {
-    try { await gh.comment(repo, pr.number, `Watching again from here.\n\n${RESET_MARKER}`); }
+    try { await host.comment(repo, pr.number, `Watching again from here.\n\n${RESET_MARKER}`); }
     catch (e) { throw new Error(`cannot post the reset comment on ${pr.url}: ${e.message}. Nothing was reset; the entry keeps its ${existing.iteration} round${existing.iteration === 1 ? "" : "s"} and its state, and its recorded harness and session are unchanged. Fix the cause and run register again.`); }
   }
   // The identity of record, written last of the two and still before anything reaches the registry, so a failure here
   // leaves GitHub and the registry agreeing on the OLD identity rather than disagreeing.
   if (writesRecovery && (!block || stale)) {
     if (switching) remoteMayBeNew = true; // A failed reply cannot prove that the body write did not land.
-    try { const updated = await gh.setRecoveryMetadata(repo, pr.number, identity, { taskId: id }); pr.body = updated.body; }
+    try { const updated = await host.setRecoveryMetadata(repo, pr.number, identity, { taskId: id }); pr.body = updated.body; }
     // The message names the identity that survived, and only claims the PR agrees when the PR actually had a block to
     // agree with: an existing entry on a PR with no block at all is a case where the registry has an identity and
     // GitHub has none, which is what this write was about to fix and is not the same as the two of them agreeing.
@@ -177,7 +191,7 @@ export async function register(ctx, { url, harness = null, session = null, workt
   // piece of feedback written in that second and lose it for good.
   const since = floorSecond(existing ? nowIso() : pr.createdAt);
   const entry = {
-    ...base, public_since: existing?.public_since || publicSince, harness: chosenHarness, session: chosenSession, worktree: dir, pr: pr.number, url: pr.url, base: prBase ?? base.base ?? null,
+    ...base, reviewPolicy, public_since: existing?.public_since || publicSince, harness: chosenHarness, session: chosenSession, worktree: dir, pr: pr.number, url: pr.url, base: prBase ?? base.base ?? null,
     ...(switching ? { execution_epoch: nextEpoch, execution_handoff: { from: existing.harness, to: chosenHarness, previousRun: existing.last?.run ?? null, at: nowIso() },
       dispatch_stopped: null, handoff_pending: null } : {}),
     // `retry` goes with `reason`: it counts the consecutive failures of one GitHub write the tick declines a step for,
@@ -218,7 +232,7 @@ export async function register(ctx, { url, harness = null, session = null, workt
   // A snapshot already on disk is kept, so a reset never replaces the authoritative copy with the one the session
   // could have edited.
   await ensurePrdSnapshot(ctx, { id, repo, path: blockPrd, ref: pr.headRefName });
-  if (rememberRepo(repo, config.home)) await gh.ensureLabels(repo).catch(e => log.warn(`${repo}: labels not created: ${e.message}`));
+  if (rememberRepo(repo, config.home)) await host.ensureLabels(repo).catch(e => log.warn(`${repo}: labels not created: ${e.message}`));
   log.info(`${id}: ${existing ? "reset and " : ""}watching ${pr.url} with ${chosenHarness}${chosenSession ? " (resume)" : " (fresh session on first fix)"}`);
   return { id, pr: pr.number, worktree: dir, harness: chosenHarness, session: chosenSession };
   } catch (error) {
@@ -241,7 +255,7 @@ async function assertCheckout(git, dir, repo, branch) {
   let origin;
   try { origin = await git.originOf(dir); }
   catch (e) { throw new Error(`--worktree ${dir} has no origin remote: ${e.message}`); }
-  if (!remoteMatches(origin, repo)) throw new Error(`--worktree ${dir} is a clone of ${origin}, not ${repo}`);
+  if (!remoteMatches(origin, repo)) throw new Error(`--worktree ${dir} is a clone of ${safeOrigin(origin)}, not ${repo}`);
   let current;
   try { current = await git.currentBranch(dir); }
   catch (e) { throw new Error(`--worktree ${dir}: cannot read the checked-out branch: ${e.message}`); }

package/lib/commands/resume.mjs

@@ -1,3 +1,5 @@
+import { hosts } from "../hosts.mjs";
+import { assertRepositoryAccess } from "../host_contract.mjs";
 // Resume a stopped session after validating its contract and preserving any unsettled run.
 import { NETWORK_RECOVERY_WINDOW } from "../network_recovery.mjs";
 import { learningDelivered, learningDeliveryPatch } from "../learning_input.mjs";
@@ -20,6 +22,7 @@ export async function resume(ctx, { handle, note = null, resnapshot = false, fre
   const { state, git, log, readPrd } = ctx;
   const id = resolveHandle(state.entries(), handle);
   let entry = state.get(id);
+  assertRepositoryAccess(capabilitiesFor(entry.harness), (ctx.hosts ?? hosts).select(entry).repository);
   if (entry.dispatch_stopped) throw new Error(`dispatch stopped: ${entry.dispatch_stopped}; cancellation and late results must be reconciled before any new task`);
 
   if (!RESUMABLE.has(entry.state)) throw new Error(`${handleFor(id, entry)} is ${entry.state}; resume takes a stopped or watched entry`);
@@ -159,8 +162,9 @@ export async function resume(ctx, { handle, note = null, resnapshot = false, fre
   const unpushed = git.unpushed ? await git.unpushed(entry.worktree, entry.branch, entry.base ?? null) : [];
   if (unpushed.length) log.info(`${id}: ${unpushed.length} unpushed commit${unpushed.length === 1 ? "" : "s"} on ${entry.branch}; the session is told to preserve and review them before pushing`);
 
-  let prompt = initialDispatch ? [startPrompt({ prd: parsed, repo: entry.repo, branch: entry.branch, base: entry.base, verify: verifyCommands(parsed), receipt: receiptInstructions(criteriaFromPrd(parsed), id), carried: entry.sources ?? [] }),
+  let prompt = initialDispatch ? [startPrompt({ host: (ctx.hosts ?? hosts).select(entry).adapter.prompts, prd: parsed, repo: entry.repo, branch: entry.branch, base: entry.base, verify: verifyCommands(parsed), receipt: receiptInstructions(criteriaFromPrd(parsed), id), carried: entry.sources ?? [] }),
     "This is the first provider implementation; the previous launch was refused before submission. Work from the supplied current source revision and preserve its commits.", ...(note ? [`Operator clarification: ${note}`] : [])].join("\n\n") : resumePrompt({
+    host: (ctx.hosts ?? hosts).select(entry).adapter.prompts,
     repo: entry.repo,
     pr: entry.pr,
     base: entry.base,

package/lib/commands/review.mjs

@@ -0,0 +1,66 @@
+import { resolveHandle } from "../state.mjs";
+import { executionRunner } from "../execution.mjs";
+import { STATES } from "../state.mjs";
+import { READY_LABEL } from "../host_contract.mjs";
+import { hostApi, hosts } from "../hosts.mjs";
+import { reviewDisclosure, REVIEW_MODES } from "../review_policy.mjs";
+import { withReviewState } from "../review_state.mjs";
+
+export async function reviewCommand(ctx, { action, handle, repo, mode, reason, finding, run = false, capability = "text", retry = false, wait = false }) {
+  if (action === "qualify") {
+    if (!repo) throw new Error("review qualify requires --repo owner/name or host/owner/name");
+    const { repository } = (ctx.hosts ?? hosts).select(repo);
+    if (wait && !run) throw new Error("qualification --wait requires --run");
+    let result = await ctx.reviewService.qualify(repository.key, { run, capability, retry, reason });
+    while (wait && ["preparing", "launch-intent", "running", "retry-waiting"].includes(result.status)) {
+      await new Promise(resolve => setTimeout(resolve, 250));
+      result = await ctx.reviewService.qualify(repository.key, { run: true, capability });
+    }
+    return result;
+  }
+  if (!handle) throw new Error("review status|policy|dispute|retry needs a task handle");
+  const id = resolveHandle(ctx.state.entries(), handle), entry = ctx.state.get(id);
+  if (action === "status") return { id, policy: entry.reviewPolicy, disclosure: reviewDisclosure(entry), record: entry.firstPartyReview, readiness: entry.review_readiness, history: ctx.state.reviewHistory ? ctx.state.reviewHistory(id) : entry.reviewHistory || [] };
+  if (!reason?.trim()) throw new Error("review policy/dispute/retry requires --reason with an explicit operator reason");
+  return withReviewState(ctx, id, () => mutateReview(ctx, id, { action, mode, reason, finding }));
+}
+
+async function mutateReview(ctx, id, { action, mode, reason, finding }) {
+  const entry = ctx.state.get(id);
+  (ctx.hosts ?? hosts).select(entry);
+  const host = hostApi(ctx);
+  if (executionRunner(ctx, id).current()?.running) throw new Error("settle the active coding run before changing review state");
+  if (action === "retry") {
+    const audit = await ctx.reviewService.retry(id, entry, reason);
+    ctx.state.update(id, { state: STATES.prOpen, reason: null, firstPartyReview: null,
+      reviewHistory: [...(entry.reviewHistory || []), entry.firstPartyReview], review_readiness: null,
+      reviewBinding: entry.reviewBinding ?? entry.firstPartyReview?.binding ?? null,
+      // Only local output is retried. Keep the existing external review window
+      // and binding: unchanged evidence retains approval, while a moved base,
+      // receipt or check still triggers the ordinary fresh-review requirement.
+      review_next_at: 0,
+      last: { ...entry.last, event: "operator authorized retry of a settled review job" } });
+    return { id, ...audit, reevaluation: "failed pieces queued; completed pieces and original attempts retained" };
+  }
+  if (action === "dispute") {
+    if (!entry.firstPartyReview?.result?.findings?.some(f => f.id === finding)) throw new Error("--finding must identify a recorded first-party finding");
+    const dispute = { finding, reason: reason.trim(), status: "pending-human", at: new Date().toISOString() };
+    ctx.state.update(id, { reviewDisputes: [...(entry.reviewDisputes || []), dispute], state: STATES.needsHuman, reason: "review-dispute", review_readiness: null, review_label_pending: Boolean(entry.pr) });
+    if (entry.pr) await host.removeLabel(entry.repo, entry.pr, READY_LABEL);
+    ctx.state.update(id, { review_label_pending: false });
+    return dispute;
+  }
+  if (action !== "policy" || !REVIEW_MODES.includes(mode)) throw new Error(`review policy requires --mode ${REVIEW_MODES.join("|")}`);
+  const policy = await ctx.reviewService.preflight(entry.repo, { mode, legacy_no_review: false });
+  const at = new Date().toISOString();
+  const patch = { reviewPolicy: policy, reviewPolicyHistory: [...(entry.reviewPolicyHistory || []), { policy: entry.reviewPolicy, reason, at }],
+    firstPartyReview: null, reviewHistory: [...(entry.reviewHistory || []), ...(entry.firstPartyReview ? [entry.firstPartyReview] : [])],
+    reviewBinding: null, review_readiness: null, review_next_at: 0, rereview: { at, nudged: false },
+    ...(entry.completionEvidence?.delivery ? { completionEvidence: { ...entry.completionEvidence, delivery: { ...entry.completionEvidence.delivery, invalidatedAt: at, invalidationReason: "explicit review policy change" } } } : {}),
+    state: STATES.needsHuman, reason: "review-policy-changed", review_label_pending: Boolean(entry.pr) };
+  // Fence before the host label write. A failed write cannot preserve clearance.
+  ctx.state.update(id, patch);
+  if (entry.pr) await host.removeLabel(entry.repo, entry.pr, READY_LABEL);
+  ctx.state.update(id, { state: entry.pr ? STATES.prOpen : STATES.needsHuman, review_label_pending: false });
+  return { id, policy, reason, reevaluation: "current head requires new review evidence" };
+}

package/lib/commands/serve.mjs

@@ -24,6 +24,7 @@ import { streamRun, sliceRun, TAIL } from "../tracker/stream.mjs";
 import { listRuns, listFlatRuns, runDir, sourceRunDir, validRunId } from "../tracker/runs.mjs";
 import { ASSETS, themeOf } from "../tracker/assets.mjs";
 import { dashboard, runPage, runsPage, page, esc, CSP, GROUPINGS } from "../tracker/pages.mjs";
+import { reviewActivity } from "../tracker/review.mjs";
 
 export const DEFAULT_PORT = 8791;
 const HOST = "127.0.0.1";
@@ -175,6 +176,13 @@ export const routes = {
     json(res, 200, { control: hit.entry.control || null, lastMessage: lastMessage(hit.entry), state: hit.entry.state, reason: hit.entry.reason });
   },
 
+  "GET /api/run/review-activity": (ctx, _req, res, url) => {
+    const id = url.searchParams.get("id") || "";
+    const entry = id && (ctx.state.reviewActivityEntry ? ctx.state.reviewActivityEntry(id) : ctx.state.get(id));
+    if (!entry) return json(res, 404, { error: "unknown entry" });
+    json(res, 200, reviewActivity(entry));
+  },
+
   "POST /api/run/control": async (ctx, req, res, url) => {
     if (!localRequest(req) || req.headers.origin !== `http://${req.headers.host}`
       || req.headers["x-gallivant-token"] !== tokenFor(ctx)) return json(res, 403, { error: "Open this page on localhost and reload before trying again." });

package/lib/commands/start.mjs

@@ -1,3 +1,9 @@
+import { publicationPolicyOf } from "../work_artifacts.mjs";
+import { repositoryReviewConfig } from "../review_policy.mjs";
+import { repositoryPreflight } from "../repository_preflight.mjs";
+import { hosts } from "../hosts.mjs";
+import { assertRepositoryAccess } from "../host_contract.mjs";
+import { hostApi } from "../hosts.mjs";
 // `gallivant start <prd path>`: one brief becomes one running session in its own checkout.
 //
 // The brief arrives as a Request (lib/sources/), which already names the target repository. `start` no longer works
@@ -10,7 +16,7 @@ import { remoteInput } from "../execution_input.mjs";
 import { learningInput, learningDispatch, learningDelivered, learningDeliveryPatch } from "../learning_input.mjs";
 import { capabilitiesFor, adapterFor, buildRun } from "../harness.mjs";
 import { newEntry, entryId, STATES } from "../state.mjs";
-import { branchFor, runEnv, worktreePath } from "../git.mjs";
+import { branchFor, runSessionEnv, worktreePath } from "../git.mjs";
 import { resolveCredentialFor, describe as describeCredential } from "../credential.mjs";
 import { requireIdentity, describeIdentity } from "../identity.mjs";
 import { rememberRepo, resolveContextPaths, resolveBase, configuredBase, repoNames } from "../config.mjs";
@@ -21,6 +27,7 @@ import { requireHarness } from "../probe.mjs";
 import { criteriaFromPrd, receiptInstructions } from "../deliverable.mjs";
 import { executionRunner, EXECUTION_VERSION } from "../execution.mjs";
 import { taskExecutionConfig } from "../task_allowance.mjs";
+import { selectReviewPolicy } from "../review_policy.mjs";
 
 export async function start(ctx, options) {
   ctx = { ...ctx, config: taskExecutionConfig(ctx.config, options.task) };
@@ -37,10 +44,11 @@ export async function start(ctx, options) {
 }
 
 async function startRequest(ctx, { path, base: askedBase = null, chain = null, request: prepared = null, task = null }, progress) {
-  const { config, state, gh, git, log, runnerFor, writePrd, writeSource, readSource } = ctx;
+  const { config, state, git, log, runnerFor, writePrd, writeSource, readSource } = ctx;
+  const host = hostApi(ctx);
   // Intake supplies an immutable, repository-resolved draft snapshot. All gates,
   // source capture and dispatch ownership below remain shared with file starts.
-  const request = prepared ?? await requestFor(path, { git, gh });
+  const request = prepared ?? await requestFor(path, { git, host });
   // The gate. Every rule that applies to this source, every time, no override: a brief that fails cannot start.
   // A `context_paths:` key in the frontmatter adds to the config list for this brief alone. It is held to exactly
   // the same rules, so a PRD cannot hand a session the home directory or the Gallivant home that the config file is
@@ -57,8 +65,14 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
   // and there was no second half to join it to. It is the operator's path, never the session's, so nothing a session
   // does can move it, and the daemon reads it for exactly one thing: the divergence check.
   const { repo: nameWithOwner, defaultBranch, relPath: prdRel, checkout } = request;
+  const selectedHost = (ctx.hosts ?? hosts).select(nameWithOwner);
+  repositoryReviewConfig(config, nameWithOwner, selectedHost.adapter);
+  assertRepositoryAccess(capabilitiesFor(request.harness), selectedHost.repository);
   const id = entryId(nameWithOwner, request.id);
   if (state.get(id)) throw new Error(`${id} already exists; \`gallivant why ${id}\` explains it, \`gallivant remove ${id}\` forgets it`);
+  // Pin policy before cloning or launching the author. Config edits only apply
+  // to future tasks; the explicit review policy command owns migration.
+  const reviewPolicy = ctx.reviewService ? await ctx.reviewService.preflight(nameWithOwner) : selectReviewPolicy(config, nameWithOwner);
 
   // The base branch this pull request will target, resolved once here and then carried everywhere it is needed: the
   // branch the clone is cut from, the instruction the session is given, and the branch the daemon merges in before
@@ -69,17 +83,18 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
   // Intake pins the resolved base, including its original provenance. Passing
   // that frozen value must not turn a default into a persisted operator override.
   const baseSource = task?.baseSource || selection.source;
-  if (!base) throw new Error(`no base branch for ${nameWithOwner}: GitHub reported no default branch and none is configured. Set one with \`gallivant start ${path} --base <branch>\`.`);
+  if (!base) throw new Error(`no base branch for ${nameWithOwner}: the host reported no default branch and none is configured. Set one with \`gallivant start ${path} --base <branch>\`.`);
   // A base that is not on the remote must fail HERE. Left to `gh pr create --base`, it fails after the session has
   // implemented the entire brief, run the tests and spent the budget, with the work stranded on a branch nobody asked
   // for. One API call before anything is cloned is the whole cost of not doing that.
   //
   // `branchExists` returns false for HTTP404; transport/CLI failures throw a
   // bounded credential-redacted diagnostic before any clone or provider dispatch.
-  if (!await gh.branchExists(nameWithOwner, base)) {
+  if (!await host.branchExists(nameWithOwner, base)) {
     const how = baseSource === "flag" ? "--base names it" : baseSource === "config" ? `repos in config.json names it for ${nameWithOwner}` : `it is ${nameWithOwner}'s default branch`;
-    throw new Error(`base branch "${base}" is not on ${nameWithOwner} (${how}), or GitHub could not be asked. Nothing was cloned and nothing was started. Check the branch name, or run \`gh api repos/${nameWithOwner}/branches/${base}\` to see what GitHub says.`);
+    throw new Error(`base branch "${base}" is not on ${nameWithOwner} (${how}), or the host could not be asked. Nothing was cloned and nothing was started. Check the branch name and host access.`);
   }
+  if (selectedHost.adapter.features?.transportSetup) await repositoryPreflight(config, nameWithOwner, { registry: ctx.hosts ?? hosts, git, base });
   if (baseSource !== "default") log.info(`${id}: base branch ${base} (from ${baseSource === "flag" ? "--base" : "config"}), not ${nameWithOwner}'s default ${defaultBranch ?? "branch"}`);
 
   // Nothing is recorded or cloned for a harness too old to honour its adapter, or one that is signed out.
@@ -94,9 +109,9 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
   // There is no checkout yet, so the host reads as github.com, which is what `gh repo clone owner/name` resolves.
   // An enterprise install is the case this cannot see from here, and `noCredentialMessage` says so by name: the
   // answer there is `github_token_file`, rather than sending a github.com token to a host it cannot authenticate.
-  const credential = await resolveCredentialFor(ctx);
+  const credential = await resolveCredentialFor(ctx, { repo: nameWithOwner });
   if (!credential.token) throw new Error(credential.why);
-  log.info(`${id}: GitHub credential from ${describeCredential(credential)}`);
+  log.info(`${id}: repository credential from ${describeCredential(credential)}`);
   // And an identity, refused here for the same reason and in the same place. A run commits as the operator, so with no
   // identity on the machine every commit the session makes would fail; refusing before the clone means no money spent.
   const identity = await requireIdentity(ctx);
@@ -117,7 +132,7 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
   // The list the brief declared, which the contract rule has already proved readable, so the prompt can name the files
   // before they are snapshotted below and there is no second source of truth about what a brief carries.
   const declared = sourcePathsOf(request);
-  const prompt = startPrompt({ prd: request, repo: nameWithOwner, branch, base, verify: verifyCommands(request), receipt, carried: declared });
+  const prompt = startPrompt({ host: selectedHost.adapter.prompts, prd: request, repo: nameWithOwner, branch, base, verify: verifyCommands(request), receipt, carried: declared });
   // Read-only extras for this session: the config list plus this brief's own frontmatter, merged in one place.
   const contextPaths = resolveContextPaths(config, request);
   if (remote && contextPaths.length) throw Object.assign(new Error("hosted backend cannot enforce private read-only context_paths"), { code: "EXECUTION_POLICY" });
@@ -168,6 +183,7 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
     if (remote) {
       state.validateStart(id, claim.token, chain);
       const pending = newEntry({ prd: prdRel, harness: request.harness, session: null, repo: nameWithOwner, branch, worktree, state: STATES.needsHuman, nowIso: nowIso(), checkout, prdFingerprint: prdFingerprint(request), prdDecision: prdDecision(request), base, sources: carried });
+      pending.reviewPolicy = reviewPolicy;
       // The clone is owned, but snapshot delivery and read-only API preparation
       // can still fail. Consume the claim into an actionable entry before them;
       // preserve the checkout rather than silently deleting unfinished files.
@@ -184,6 +200,8 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
     // operator edits the file in the second between the two writes. Same 0o644/0o755 as the brief, because these are
     // files in a source tree and must not be clamped to daemon-state modes.
     for (const rel of carried) writeRepositoryText(worktree, rel, readSource(id, rel));
+    const hook = git.installHooks?.(worktree, publicationPolicyOf(request, { sources: carried, base }));
+    if (hook && !hook.installed) log.warn(`${id}: publication hook could not be installed (${hook.why}); coordinator publication checks remain mandatory`);
     if (carried.length) log.info(`${id}: carried ${carried.length} file${carried.length === 1 ? "" : "s"} from ${request.checkout} into the checkout`);
     if (!remote) state.validateStart(id, claim.token, chain);
     const execution = executionRunner(ctx, id, request.harness);
@@ -209,7 +227,7 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
     } else {
       // Even a throwing local spawn can have created a child.
       progress.spawnAttempted = true;
-      job = await learningDispatch(ctx, id, managed, () => execution.start("start", spec.cmd, spec.args, { cwd: worktree, runtimeSettings: spec.runtimeSettings, env: { ...runEnv(config, credential, identity, worktree), ...spec.env }, execution: dispatchInput }));
+      job = await learningDispatch(ctx, id, managed, () => execution.start("start", spec.cmd, spec.args, { cwd: worktree, runtimeSettings: spec.runtimeSettings, env: runSessionEnv(spec.env, config, credential, identity, worktree), execution: dispatchInput }));
     }
 
     // `checkout` and the two prd fields are what the divergence check compares against: where the operator's copy lives,
@@ -220,6 +238,7 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
       prd: prdRel, harness: request.harness, session, repo: nameWithOwner, branch, worktree, state: STATES.running, nowIso: nowIso(),
       checkout, prdFingerprint: prdFingerprint(request), prdDecision: prdDecision(request), base, sources: carried,
     });
+    entry.reviewPolicy = reviewPolicy;
     const startedEntry = { ...entry, ...(remote ? { initial_dispatch: null } : {}), ...(job.execution ? { execution: job.execution } : {}), ...(task ? { task: { ...task, run: job.id } } : {}), public_since: publicSince, ...(chain ? { chain: { name: chain.name, index: chain.index, dispatch: chain.dispatch } } : {}), last: { at: nowIso(), run: job.id, exit: null, event: "start" } };
     if (remoteRegistered) state.update(id, current => ({ ...startedEntry, ...learningDeliveryPatch(current, managed, job) }));
     else state.putStarted(id, { ...startedEntry, ...learningDeliveryPatch(null, managed, job) }, claim.token);
@@ -237,7 +256,7 @@ async function startRequest(ctx, { path, base: askedBase = null, chain = null, r
     const persistBase = baseSource === "flag" && !chain ? base : null;
     rememberRepo(nameWithOwner, config.home, persistBase);
     if (persistBase) log.info(`${nameWithOwner}: base branch ${base} recorded in ${config.home}/config.json; later starts in this repository need no --base`);
-    if (isNewRepo) await gh.ensureLabels(nameWithOwner).catch(e => log.warn(`${nameWithOwner}: labels not created: ${e.message}`));
+    if (isNewRepo) await host.ensureLabels(nameWithOwner).catch(e => log.warn(`${nameWithOwner}: labels not created: ${e.message}`));
     log.info(`${id}: started ${request.harness} session in ${worktree}`);
     return { id, worktree, branch, base, baseSource, session, run: job.id };
   } catch (error) {

package/lib/commands/status.mjs

@@ -10,6 +10,19 @@ import { chainRows } from "../chains.mjs";
 import { executionRunner } from "../execution.mjs";
 import { networkRecoveryDetail } from "../network_recovery.mjs";
 import { probeStatus } from "../probe.mjs";
+import { reviewDisclosure, reviewProgressText } from "../review_policy.mjs";
+import { repoNames } from "../config.mjs";
+import { hostGuidance } from "../host_definitions.mjs";
+
+// Registry writes include routine polling. Show an actual run/review start or
+// recorded event instead of making an idle row look newly active on each tick.
+const activityAt = (entry, run, inFlight) => {
+  const reviewStart = entry.firstPartyReview?.startedAt;
+  const times = [reviewStart, inFlight ? run?.startedAt : null, entry.activity_at, entry.last?.at, entry.created_at]
+    .map(value => value == null ? NaN : new Date(value).getTime())
+    .filter(Number.isFinite);
+  return times.length ? new Date(Math.max(...times)).toISOString() : null;
+};
 
 /**
  * The divergence for one entry, never fatal. `status` is what an operator runs when something already looks wrong, so a
@@ -44,8 +57,9 @@ export function model(ctx) {
     else if (e.state === STATES.needsHuman) { section = "needs_you"; label = "needs-human"; detail = e.reason; }
     // `gate_skipped` says the completion gate never ran, which is a different thing from passing it, and a person
     // deciding whether to merge on this line needs to be told which of the two it was.
-    else if (e.state === STATES.ready) { section = "needs_you"; label = "ready"; detail = e.gate_skipped ? `green, no blocking findings, RECEIPT NOT CHECKED (${e.gate_skipped})` : "green, no blocking findings, receipt accepted"; }
+    else if (e.state === STATES.ready) { section = "needs_you"; label = "ready"; detail = `${e.review_readiness?.note || reviewDisclosure(e)}; ${e.gate_skipped ? `RECEIPT NOT CHECKED (${e.gate_skipped})` : "receipt accepted"}`; }
     else if (e.state === STATES.done) { section = "done"; label = "done"; detail = ""; }
+    else if (e.firstPartyReview?.status === "running") { section = "running"; label = "reviewing"; detail = reviewProgressText(e); }
     // `retry` names the one GitHub write the tick is declining a step for, and it is the truest thing this row can say
     // while it is set. Without it, a start run whose identity block will not write read as "ended, settling on the next
     // tick" on every poll: the process HAD ended, and the tick was not settling it, it was retrying one write and
@@ -86,7 +100,7 @@ export function model(ctx) {
       base: e.base ?? null,
       // When the daemon last merged the base into this branch, so an operator can see the history was changed and when.
       base_merge: e.base_merge ?? null,
-      retry: e.retry ?? null, network_retry: e.network_retry ?? null, pr: e.pr, url: e.url || null, harness: e.harness, since: e.updated_at,
+      retry: e.retry ?? null, network_retry: e.network_retry ?? null, pr: e.pr, url: e.url || null, harness: e.harness, since: activityAt(e, run, inFlight),
       // `handle` rides along so a consumer can print the command that resolves it without rebuilding the handle from the
       // other fields: the tracker does exactly that, and `handleFor` is not its to know.
       divergence: divReason ? { verdict: divergence.verdict, reason: divReason, why: divergence.why, diff: divergence.diff, path: divergence.path ?? null, handle } : null,
@@ -95,6 +109,7 @@ export function model(ctx) {
     };
   });
   return {
+    repositoryGuidance: [...new Set([...repoNames(config), ...state.entries().map(([, entry]) => entry.repo)])].map(repo => ({ repo, detail: hostGuidance(repo) })).filter(r => r.detail),
     daemon: daemon ? { alive: daemon.alive, unverified: Boolean(daemon.unverified), pid: daemon.pid, startedAt: daemon.startedAt, lastTick: daemon.lastTick, nextTick: daemon.nextTick, probes: daemon.probes || {}, stale: Boolean(daemon.stale) } : null,
     latestError: log.latest(),
     chains: chainRows(ctx),
@@ -120,6 +135,7 @@ export function render(m, { all = false, clock = Date } = {}) {
     if (m.daemon.stale) lines.push("           the daemon is running code older than what is installed; its runs use the old behaviour. Restart it: gallivant down && gallivant up");
   }
   if (m.latestError) lines.push(`latest error: ${m.latestError}`);
+  for (const guidance of m.repositoryGuidance ?? []) lines.push(`${guidance.repo}: ${guidance.detail}`);
   const section = (title, rows) => {
     lines.push("", title);
     if (!rows.length) { lines.push("  (none)"); return; }