cloving 1.1.0 → 1.3.0

package/dist/src/cli/watch-phone.js

@@ -0,0 +1,53 @@
+import { qrMatrix } from "../phone/qr-matrix.js";
+import { qrPicture } from "../phone/qr-picture.js";
+import { phoneRequest } from "./phone-client.js";
+import { actionAllowed, actionBody, } from "./watch-actions.js";
+const operations = {
+    "/actions/phone/pair": "phone-pair-start",
+    "/actions/phone/cancel": "phone-pair-cancel",
+    "/actions/phone/accept": "phone-pair-accept",
+    "/actions/phone/deny": "phone-pair-deny",
+    "/actions/phone/remove": "phone-remove",
+};
+export function isPhoneAction(path) {
+    return Object.hasOwn(operations, path);
+}
+function withPicture(result) {
+    const link = result["link"];
+    return typeof link === "string"
+        ? { ...result, picture: qrPicture(qrMatrix(link).modules) }
+        : result;
+}
+export async function phoneAction(actions, request) {
+    const operation = operations[new URL(String(request.url), "http://localhost").pathname];
+    if (operation === undefined || !actionAllowed(actions, request))
+        return null;
+    const body = await actionBody(request);
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+        return null;
+    const reply = await phoneRequest(actions.runtimeDirectory, {
+        operation,
+        parameters: { ...body },
+    });
+    if (reply === undefined)
+        return JSON.stringify({
+            error: {
+                code: "phone-relay-off",
+                detail: "The phone relay is off or not started.",
+            },
+        });
+    return JSON.stringify(reply.kind === "result"
+        ? withPicture(reply.result)
+        : { error: reply.error });
+}
+export async function phoneRead(runtimeDirectory) {
+    const reply = await phoneRequest(runtimeDirectory, {
+        operation: "phone-state",
+        parameters: {},
+    });
+    if (reply === undefined)
+        return JSON.stringify({ relay: "off" });
+    return JSON.stringify(reply.kind === "result"
+        ? { relay: "on", ...reply.result }
+        : { relay: "on", error: reply.error });
+}

package/dist/src/cli/watch-pr-command.d.ts

@@ -1,4 +1,4 @@
-import { type PrIdentity, type PrObservation } from "./watch-pr-identity.ts";
+import { type PrIdentity, type PrReadResult } from "./watch-pr-identity.ts";
 export interface WatchCommandOutput {
     readonly stdout: string;
     readonly stderr: string;
@@ -12,4 +12,7 @@ export interface WatchCommandRequest {
 }
 export type WatchCommandRunner = (request: WatchCommandRequest) => Promise<WatchCommandOutput>;
 export declare function prArguments(identity: PrIdentity): readonly string[];
-export declare function prCommandResult(identity: PrIdentity, output: WatchCommandOutput): PrObservation;
+export declare function prCommandResult(identity: PrIdentity, reply: {
+    readonly output: WatchCommandOutput;
+    readonly now: number;
+}): PrReadResult;

package/dist/src/cli/watch-pr-command.js

@@ -15,15 +15,52 @@ function commandFailure(output) {
         /^HTTP\/[^ ]+ (\d{3})/m.exec(output.stdout)?.[1]);
     if (status === 429 ||
         /rate limit/i.test(output.stderr) ||
-        /x-ratelimit-remaining: 0\s*$/im.test(output.stdout))
+        headerValues(output.stdout, "x-ratelimit-remaining").includes("0"))
         return "rate-limit";
     if (output.status === 4 || [401, 403, 404].includes(status))
         return "access";
     return "command";
 }
-export function prCommandResult(identity, output) {
-    if (output.status !== 0 || output.errorCode !== null)
-        return { status: "unavailable", failure: commandFailure(output) };
+function headerValues(stdout, name) {
+    if (!/^HTTP\/[^ ]+ \d{3}/.test(stdout))
+        return [];
+    const headers = stdout.split(/\r?\n\r?\n/, 1)[0] ?? "";
+    return headers.split(/\r?\n/).flatMap((line) => {
+        const separator = line.indexOf(":");
+        return line.slice(0, separator).toLowerCase() === name
+            ? [line.slice(separator + 1).trim()]
+            : [];
+    });
+}
+function millisecondsOf(value) {
+    if (!/^\d+$/.test(value))
+        return [];
+    const milliseconds = Number(value) * 1000;
+    return Number.isSafeInteger(milliseconds) ? [milliseconds] : [];
+}
+function retryDeadline(output, now) {
+    const delays = headerValues(output.stdout, "retry-after")
+        .flatMap(millisecondsOf)
+        .map((delay) => now + delay)
+        .filter(Number.isSafeInteger);
+    const resets = headerValues(output.stdout, "x-ratelimit-remaining").includes("0")
+        ? headerValues(output.stdout, "x-ratelimit-reset").flatMap(millisecondsOf)
+        : [];
+    const deadlines = [...delays, ...resets];
+    return deadlines.length === 0 ? now + 60000 : Math.max(now, ...deadlines);
+}
+export function prCommandResult(identity, reply) {
+    const { output, now } = reply;
+    if (output.status !== 0 || output.errorCode !== null) {
+        const failure = commandFailure(output);
+        return {
+            status: "unavailable",
+            failure,
+            ...(failure === "rate-limit"
+                ? { retryAt: retryDeadline(output, now) }
+                : {}),
+        };
+    }
     const envelope = /^HTTP\/[^ ]+ 200[^\n]*\r?\n[\s\S]*?\r?\n\r?\n([\s\S]*)$/.exec(output.stdout);
     if (envelope?.[1] === undefined)
         return { status: "unavailable", failure: "response" };

package/dist/src/cli/watch-pr-identity.d.ts

@@ -5,14 +5,26 @@ export interface PrIdentity {
     readonly number: number;
 }
 export type PrFailure = "configuration" | "identity" | "command" | "access" | "rate-limit" | "response" | "timeout";
-export type PrObservation = {
+export type PrReadResult = {
     readonly status: "merged" | "unmerged";
 } | {
     readonly status: "unavailable";
     readonly failure: PrFailure;
+    readonly retryAt?: number;
 };
-export declare function prResponse(identity: PrIdentity, value: unknown): PrObservation;
+export type PrObservation = (PrReadResult | {
+    readonly status: "pending";
+}) & {
+    readonly retryAt?: number;
+    readonly lastSuccess?: {
+        readonly status: "merged" | "unmerged";
+        readonly readAt: number;
+    };
+};
+export declare function prResponse(identity: PrIdentity, value: unknown): PrReadResult;
 export type PrRepository = Omit<PrIdentity, "number">;
+export declare function establishedIssue(repository: PrRepository | null, value: unknown): PrIdentity | null;
+export declare function sameIssue(first: PrIdentity | null | undefined, second: PrIdentity | null | undefined): boolean;
 export declare function prRepository(origin: string): PrRepository | null;
 export declare function prIdentity(repository: PrRepository, pullRequest: {
     readonly number: number;

package/dist/src/cli/watch-pr-identity.js

@@ -31,6 +31,31 @@ export function prResponse(identity, value) {
         return { status: "unavailable", failure: "response" };
     return { status: merged ? "merged" : "unmerged" };
 }
+export function establishedIssue(repository, value) {
+    const fields = record(value) ?? {};
+    const number = fields["number"];
+    if (repository === null ||
+        typeof number !== "number" ||
+        !Number.isSafeInteger(number) ||
+        number <= 0)
+        return null;
+    const owner = fields["owner"];
+    const name = fields["repository"];
+    if (typeof owner !== "string" ||
+        typeof name !== "string" ||
+        owner.toLowerCase() !== repository.owner ||
+        name.toLowerCase() !== repository.repository)
+        return null;
+    return { ...repository, number };
+}
+export function sameIssue(first, second) {
+    return (first != null &&
+        second != null &&
+        first.host === second.host &&
+        first.owner === second.owner &&
+        first.repository === second.repository &&
+        first.number === second.number);
+}
 export function prRepository(origin) {
     const address = origin
         .replace(/^git@([^:/]+):/, "ssh://git@$1/")

package/dist/src/cli/watch-pr-observer.d.ts

@@ -2,6 +2,7 @@ import type { WatchPullRequest } from "./watch-render.ts";
 import { type WatchCommandRunner } from "./watch-pr-command.ts";
 import { type PrObservation, type PrRepository } from "./watch-pr-identity.ts";
 export interface PrObserver {
+    readonly repository?: PrRepository | null;
     readonly observe: (pullRequest: WatchPullRequest) => PrObservation | null;
     readonly close: () => void;
 }

package/dist/src/cli/watch-pr-observer.js

@@ -9,13 +9,23 @@ const systemClock = {
         };
     },
 };
+function observationOf(entry, reply) {
+    const { result, now } = reply;
+    if (result.status !== "unavailable")
+        return { ...result, lastSuccess: { status: result.status, readAt: now } };
+    const lastSuccess = entry.result?.lastSuccess;
+    return { ...result, ...(lastSuccess === undefined ? {} : { lastSuccess }) };
+}
 async function readPr(state, attempt) {
     const { entry, controller } = attempt;
     const deadline = { expired: false };
     const timeout = { status: "unavailable", failure: "timeout" };
     const cancel = state.clock.after(() => {
         deadline.expired = true;
-        entry.result = timeout;
+        entry.result = observationOf(entry, {
+            result: timeout,
+            now: state.clock.now(),
+        });
         controller.abort();
     }, 5000);
     controller.signal.addEventListener("abort", cancel, { once: true });
@@ -28,7 +38,9 @@ async function readPr(state, attempt) {
             directory: state.settings.directory,
             signal: controller.signal,
         }));
-        return deadline.expired ? timeout : prCommandResult(entry.identity, output);
+        return deadline.expired
+            ? timeout
+            : prCommandResult(entry.identity, { output, now: state.clock.now() });
     }
     catch {
         return deadline.expired
@@ -43,14 +55,32 @@ async function readPr(state, attempt) {
 function pump(state) {
     if (state.closed || state.active !== null)
         return;
-    const entry = state.queue.shift();
+    state.wake?.();
+    state.wake = null;
+    if (state.queue.length === 0)
+        return;
+    const now = state.clock.now();
+    const position = state.queue.findIndex((entry) => (state.retryDeadlines.get(entry.identity.host) ?? 0) <= now);
+    if (position === -1) {
+        const next = Math.min(...state.queue.map((entry) => state.retryDeadlines.get(entry.identity.host) ?? now));
+        state.wake = state.clock.after(() => {
+            state.wake = null;
+            pump(state);
+        }, Math.min(next - now, 2147483647));
+        return;
+    }
+    const [entry] = state.queue.splice(position, 1);
     if (entry === undefined)
         return;
     const controller = new AbortController();
     state.active = controller;
     entry.started = state.clock.now();
     const completed = (result) => {
-        entry.result = result;
+        if (state.closed)
+            return;
+        entry.result = observationOf(entry, { result, now: state.clock.now() });
+        if (result.status === "unavailable" && result.failure === "rate-limit")
+            state.retryDeadlines.set(entry.identity.host, Math.max(state.retryDeadlines.get(entry.identity.host) ?? 0, result.retryAt ?? state.clock.now() + 60000));
         entry.pending = false;
         state.active = null;
         pump(state);
@@ -59,6 +89,11 @@ function pump(state) {
         completed({ status: "unavailable", failure: "command" });
     });
 }
+function currentObservation(state, entry) {
+    const result = entry.result ?? { status: "pending" };
+    const retryAt = state.retryDeadlines.get(entry.identity.host) ?? 0;
+    return retryAt > state.clock.now() ? { ...result, retryAt } : result;
+}
 function needsRead(entry, now) {
     if (entry === undefined)
         return true;
@@ -72,6 +107,8 @@ export function prObserver(settings) {
         clock: settings.clock ?? systemClock,
         cache: new Map(),
         queue: [],
+        retryDeadlines: new Map(),
+        wake: null,
         active: null,
         closed: false,
     };
@@ -85,7 +122,9 @@ export function prObserver(settings) {
         const key = JSON.stringify(identity);
         const known = state.cache.get(key);
         if (state.closed || !needsRead(known, state.clock.now()))
-            return known?.result ?? null;
+            return known === undefined
+                ? { status: "pending" }
+                : currentObservation(state, known);
         const entry = {
             identity,
             result: known?.result ?? null,
@@ -95,13 +134,16 @@ export function prObserver(settings) {
         state.cache.set(key, entry);
         state.queue.push(entry);
         pump(state);
-        return entry.result;
+        return currentObservation(state, entry);
     };
     return {
+        repository: settings.repository,
         observe,
         close: () => {
             state.closed = true;
             state.queue.length = 0;
+            state.wake?.();
+            state.wake = null;
             state.active?.abort();
         },
     };

package/dist/src/cli/watch-pull-request.d.ts

@@ -0,0 +1,12 @@
+import type { CiRerunNotice } from "./github-ci-progress.ts";
+import type { WatchRun } from "./watch-render.ts";
+import { type PrRepository } from "./watch-pr-identity.ts";
+export interface GithubRecords {
+    readonly started: unknown;
+    readonly result: unknown;
+    readonly ciReruns?: readonly CiRerunNotice[];
+}
+export declare function pullOf(inputs: {
+    readonly records: readonly GithubRecords[];
+    readonly repository: PrRepository | null;
+}, runId: string): Pick<WatchRun, "pullRequest" | "reviews" | "mergeCommit" | "mergeProof" | "ciReruns">;

package/dist/src/cli/watch-pull-request.js

@@ -0,0 +1,134 @@
+import { operationIdentity } from "../operation-identity.js";
+import { prIdentity, } from "./watch-pr-identity.js";
+function record(value) {
+    return typeof value === "object" && value !== null ? { ...value } : {};
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function stamp(value) {
+    return typeof value === "string" ? value : null;
+}
+function parsed(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+function count(value) {
+    return typeof value === "number" ? value : null;
+}
+function attributed(started, operation) {
+    const stage = list(operation[5]);
+    const checked = operationIdentity({
+        round: operation[1],
+        run: operation[2],
+        phase: operation[3],
+        operation: operation[4],
+        ...(operation[5] === null
+            ? {}
+            : { stage: { id: stage[0], visit: stage[1], branch: stage[2] } }),
+        ...(operation[6] === null ? {} : { key: operation[6] }),
+    });
+    return (checked.kind === "valid" &&
+        checked.value === JSON.stringify(operation) &&
+        operation[3] === "pull-request" &&
+        operation[4] === `github-${text(started["method"])}` &&
+        (started["runId"] === undefined || started["runId"] === operation[2]));
+}
+function githubOf(records) {
+    const started = record(records.started);
+    const operation = list(parsed(text(started["operationId"])));
+    const result = record(records.result);
+    const completed = result["outcome"] === "completed";
+    return {
+        runId: text(operation[2]),
+        round: Number(operation[1]),
+        method: text(started["method"]),
+        completed,
+        attributed: attributed(started, operation) && !Object.hasOwn(result, "reason"),
+        report: completed ? record(parsed(text(result["result"]))) : {},
+    };
+}
+function pullRequestOf(results) {
+    const opened = results
+        .filter((item) => item.method === "open-pr")
+        .map((item) => item.report)
+        .findLast((report) => text(report["url"]).startsWith("https://"));
+    if (opened === undefined)
+        return null;
+    return { number: Number(opened["number"]), url: text(opened["url"]) };
+}
+function reviewsOf(results) {
+    return results
+        .filter((item) => item.method === "wait-review")
+        .flatMap(({ round, report }) => {
+        const score = count(report["score"]);
+        if (score === null)
+            return [];
+        return [{ round, commit: text(report["commit"]), score }];
+    });
+}
+function mergeCommitOf(results) {
+    const merged = results
+        .filter((item) => item.method === "merge")
+        .map((item) => stamp(item.report["merged"]));
+    return merged.find((commit) => commit !== null) ?? null;
+}
+function mergeProofOf(results, context) {
+    if (context.repository === null || context.pullRequest === null)
+        return null;
+    const repository = context.repository;
+    const identity = prIdentity(repository, context.pullRequest);
+    if (identity === null)
+        return null;
+    const opened = results.filter((item) => item.method === "open-pr" && item.completed && item.attributed);
+    if (opened.length === 0 ||
+        opened.some(({ report }) => report["number"] !== identity.number ||
+            typeof report["url"] !== "string" ||
+            prIdentity(repository, {
+                number: identity.number,
+                url: report["url"],
+            }) === null))
+        return null;
+    const merged = results.filter((item) => item.method === "merge" &&
+        item.completed &&
+        item.attributed &&
+        (typeof item.report["reason"] !== "string" ||
+            Object.hasOwn(item.report, "merged")));
+    if (merged.length === 0 ||
+        merged.some(({ report }) => report["number"] !== identity.number ||
+            typeof report["merged"] !== "string" ||
+            report["merged"].trim() === "" ||
+            Object.hasOwn(report, "reason")))
+        return null;
+    return new Set(merged.map(({ report }) => report["merged"])).size === 1
+        ? identity
+        : null;
+}
+export function pullOf(inputs, runId) {
+    const results = inputs.records
+        .map(githubOf)
+        .filter((item) => item.runId === runId)
+        .toSorted((first, second) => first.round - second.round);
+    const pullRequest = pullRequestOf(results);
+    const mergeProof = mergeProofOf(results, {
+        repository: inputs.repository,
+        pullRequest,
+    });
+    const ciReruns = inputs.records
+        .filter((item) => record(item.started)["runId"] === runId)
+        .flatMap((item) => item.ciReruns ?? []);
+    return {
+        pullRequest,
+        reviews: reviewsOf(results),
+        mergeCommit: mergeCommitOf(results),
+        ...(ciReruns.length === 0 ? {} : { ciReruns }),
+        ...(mergeProof === null ? {} : { mergeProof }),
+    };
+}

package/dist/src/cli/watch-reads.d.ts

@@ -1,4 +1,7 @@
+import { type PrRepository } from "./watch-pr-identity.ts";
+import { type WorkflowStages } from "../workflow-declaration.ts";
 import { type Fields } from "../protocol.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 interface ReadStatus extends Fields {
     readonly runId: string;
     readonly latestSequence: number;
@@ -13,8 +16,11 @@ interface ReadRun {
     readonly events: readonly ReadEvent[];
 }
 export interface WatchRead {
+    readonly queue?: Fields;
     readonly service: string;
     readonly workflows: readonly string[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+    readonly workflowStages?: WorkflowStages;
     readonly summaries: readonly ReadStatus[];
     readonly runs: readonly ReadRun[];
     readonly completionCandidates: readonly ReadRun[];
@@ -24,5 +30,5 @@ export interface WatchReader {
     readonly read: (now: string) => Promise<WatchRead>;
     readonly run: (runId: string) => Promise<WatchRead>;
 }
-export declare function watchReader(runtimeDirectory: string): WatchReader;
+export declare function watchReader(runtimeDirectory: string, repository?: PrRepository | null): WatchReader;
 export {};

package/dist/src/cli/watch-reads.js

@@ -1,9 +1,13 @@
+import { establishedIssue } from "./watch-pr-identity.js";
+import { isWorkflowStages, } from "../workflow-declaration.js";
 import { record } from "../protocol.js";
 import { send } from "./client.js";
 import { activeRun, recentRun } from "./watch-board.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 const unavailable = {
     service: "down",
     workflows: [],
+    workflowRefusals: [],
     summaries: [],
     runs: [],
     completionCandidates: [],
@@ -79,15 +83,15 @@ async function creationOf(reader, runId) {
     }
     return null;
 }
-function matchingCompletion(status, ticketIds) {
-    const ticketId = status["ticketId"];
+function matchingCompletion(status, context) {
+    const issue = establishedIssue(context.repository, status["issueIdentity"]);
     return (status.state === "completed" &&
         status["workflowId"] === "develop-issue" &&
         record(status["outcome"])?.["kind"] === "handoff_requested" &&
         record(status["outcome"])?.["ticketStatus"] !== "partial" &&
         record(status["outcome"])?.["issueUpdate"] !== "failed" &&
-        typeof ticketId === "string" &&
-        ticketIds.has(ticketId));
+        issue !== null &&
+        context.issues.has(JSON.stringify(issue)));
 }
 async function completionOf(reader, search) {
     const { runId, latestSequence } = search.summary;
@@ -106,12 +110,16 @@ async function completionOf(reader, search) {
                 state: status.state,
                 workflowId: status["workflowId"],
                 ticketId: status["ticketId"],
+                issueIdentity: status["issueIdentity"],
                 outcome: status["outcome"],
             },
         };
         reader.completions.set(runId, known);
     }
-    if (!matchingCompletion(known.status, search.ticketIds))
+    if (!matchingCompletion(known.status, {
+        issues: search.issues,
+        repository: reader.repository,
+    }))
         return null;
     const creation = known.creation === undefined
         ? await creationOf(reader, runId)
@@ -119,11 +127,20 @@ async function completionOf(reader, search) {
     reader.completions.set(runId, { ...known, creation });
     return { status: known.status, events: creation === null ? [] : [creation] };
 }
+function refreshedLinks(run, status) {
+    const links = Object.fromEntries(["parentRunId", "chainId", "childRunIds"]
+        .filter((name) => Object.hasOwn(status, name))
+        .map((name) => [name, status[name]]));
+    return {
+        ...run,
+        status: { ...run.status, ...links },
+    };
+}
 async function detailed(reader, summary) {
     const { runId, latestSequence: sequence } = summary;
     const known = reader.details.get(runId);
     if (known !== undefined && known.sequence === sequence)
-        return known.value;
+        return refreshedLinks(known.value, summary);
     const shown = await asked(reader, {
         operation: "status",
         parameters: { runId },
@@ -160,10 +177,10 @@ async function decisionsOf(reader) {
     });
     return list(questions["decisions"]);
 }
-function stoppedTicketIds(runs, now) {
+function stoppedIssues(runs, context) {
     const stopped = runs
         .map((run) => run.status)
-        .filter((status) => recentRun(status.latestAt, now) &&
+        .filter((status) => recentRun(status.latestAt, context.now) &&
         status["workflowId"] === "develop-issue" &&
         (["failed", "cancelled"].includes(status.state) ||
             (status.state === "completed" &&
@@ -171,16 +188,15 @@ function stoppedTicketIds(runs, now) {
         .toSorted((first, second) => Date.parse(second.latestAt ?? "") - Date.parse(first.latestAt ?? ""))
         .slice(0, 20);
     return new Set(stopped.flatMap((status) => {
-        const ticketId = status["ticketId"];
-        return status.state === "completed" &&
-            record(status["outcome"])?.["ticketStatus"] !== "partial" &&
-            record(status["outcome"])?.["issueUpdate"] !== "failed" &&
-            typeof ticketId === "string" &&
-            ticketId !== ""
-            ? [ticketId]
+        const issue = establishedIssue(context.repository, status["issueIdentity"]);
+        return status.state === "completed" && issue !== null
+            ? [JSON.stringify(issue)]
             : [];
     }));
 }
+function stageMetadata(value) {
+    return Object.fromEntries(Object.entries(record(value) ?? {}).flatMap(([workflowId, stages]) => isWorkflowStages(stages) ? [[workflowId, stages]] : []));
+}
 async function service(reader, now) {
     const status = await asked(reader, {
         operation: "status",
@@ -194,20 +210,25 @@ async function service(reader, now) {
     const current = summaries.filter((summary) => activeRun(summary.state) || recentRun(summary.latestAt, now));
     for (const summary of current)
         runs.push(await detailed(reader, summary));
-    const ticketIds = stoppedTicketIds(runs, now);
-    const older = ticketIds.size === 0
+    const issues = stoppedIssues(runs, { now, repository: reader.repository });
+    const older = issues.size === 0
         ? []
         : summaries.filter((summary) => !recentRun(summary.latestAt, now) &&
             summary["workflowId"] === "develop-issue" &&
             summary.state === "completed");
     for (const summary of older) {
-        const candidate = await completionOf(reader, { summary, ticketIds });
+        const candidate = await completionOf(reader, { summary, issues });
         if (candidate !== null)
             completionCandidates.push(candidate);
     }
     return {
         service: "up",
+        ...(record(status["queue"]) === undefined
+            ? {}
+            : { queue: record(status["queue"]) ?? {} }),
         workflows: list(status["workflows"]).filter((value) => typeof value === "string"),
+        workflowStages: stageMetadata(status["workflowStages"]),
+        workflowRefusals: workflowRefusals(status["workflowRefusals"]),
         summaries,
         runs,
         completionCandidates,
@@ -226,7 +247,7 @@ async function singleRun(reader, runId) {
     const status = statusOf(reply.result["run"]);
     const known = reader.details.get(runId);
     const value = known !== undefined && known.sequence === status.latestSequence
-        ? known.value
+        ? refreshedLinks(known.value, status)
         : await remember(reader, status);
     return {
         ...unavailable,
@@ -235,9 +256,10 @@ async function singleRun(reader, runId) {
         decisions: await decisionsOf(reader),
     };
 }
-export function watchReader(runtimeDirectory) {
+export function watchReader(runtimeDirectory, repository = null) {
     const reader = {
         runtimeDirectory,
+        repository,
         details: new Map(),
         completions: new Map(),
     };