toolroll 0.5.0

package/dist/workspace-ui.js

@@ -0,0 +1,411 @@
+/**
+ * The workspace's ONE display projection (package 1, 2026-09-13): the
+ * words, tone, and next action a task or result wears on every surface —
+ * Work rows, the task page's status box, the focused chat's journey card,
+ * the review cockpit's chip, and the completion receipt's heading. Pure
+ * functions over facts the store already records (task state, the dispatch
+ * diagnosis, the machine's proof verdict and its reasons, an operator's
+ * acceptance, the publication row); nothing here is a second lifecycle,
+ * and nothing here reads the agent's narrative as evidence of success.
+ *
+ * The vocabulary is the truthful-status contract from the workspace plan:
+ * a saved result with a failed check says "Changes saved, but checks
+ * failed"; a missing proof says "verification needed"; agent-reported
+ * checks say so; an accepted exception stays an exception; and nothing
+ * local is ever called shipped or deployed — "PR opened" and "Merge
+ * observed" name observed publication records, and deployment is never
+ * claimed without one.
+ */
+import { GOAL_ASSESSMENT_PENDING, manualReviewOnly } from "./proof.js";
+export const WORK_VIEWS = [
+    { key: "all", label: "All", hint: "Every task in view, most urgent first.", empty: "Nothing is in progress. Describe work in chat or add a task, and it appears here." },
+    { key: "needs-you", label: "Needs you", hint: "Tasks waiting on an answer, approval, or your inspection.", empty: "Nothing needs you right now. Queued and running work continues on its own." },
+    { key: "running", label: "Running", hint: "Attempts a builder owns right now.", empty: "Nothing is building right now. Approved tasks start when a builder with capacity is connected." },
+    { key: "completed", label: "Complete", hint: "Tasks the lead or user has marked complete. Recorded check results remain available.", empty: "No tasks have been marked complete in this view." },
+];
+export function parseWorkView(raw) {
+    return raw === "needs-you" || raw === "running" || raw === "completed" ? raw : "all";
+}
+/** The review facts from the store's bounded retry projection — the same
+ * reading `diagnoseTaskDispatch` makes, so every surface starts from one
+ * record. `reviewerAlive` answers for the live attempt's runner. */
+export function reviewFactsOf(retry, reviewerAlive) {
+    if (retry === null || retry.state === "unrequested")
+        return null;
+    const current = retry.live ?? (retry.state === "queued" ? null : retry.latest);
+    return {
+        state: retry.state,
+        attempt: retry.state === "queued" ? retry.nextAttempt : current?.attempt ?? null,
+        cap: retry.cap,
+        attempts: retry.attempts.length,
+        retriesRemaining: retry.retriesRemaining,
+        latestReason: retry.latest?.reason ?? null,
+        interrupted: retry.latest !== null && (retry.latest.outcome === "interrupted" || retry.latest.reason === "interrupted"),
+        queuedBy: retry.openRequest?.requestedBy ?? null,
+        queuedOrigin: retry.openRequest?.origin ?? null,
+        reviewerAlive: retry.live !== null && reviewerAlive(retry.live.runner),
+    };
+}
+/** The tokens a review in flight wears — the dispatch codes, unchanged. */
+export const REVIEW_TOKENS = new Set(["reviewing", "review-pending", "review-failed", "review-exhausted"]);
+const retriesLeft = (count, explicit = true) => `${count}${explicit ? " explicit" : ""} ${count === 1 ? "retry" : "retries"}`;
+/**
+ * A review that is queued, running, failed with a retry left, or
+ * exhausted is the result's PRIMARY status — the machine is still
+ * deciding, and every surface must say so with the same words. A review
+ * never requested, or one that succeeded, adds nothing: the stored verdict
+ * (folded by the review where one landed) speaks. Words and tokens are
+ * the v50 dispatch contract; nothing here changes the lifecycle.
+ */
+export function reviewStatusOf(review) {
+    // Model review is retired (2026-09-21): nothing schedules, retries or
+    // waits for a reviewer, so a recorded review request or attempt is
+    // history and never the result's primary status. The stored verdict and
+    // the assignment's Ready/Complete state speak instead.
+    void review;
+    return null;
+}
+const FAILED_CHECK = /^the repository's approved verification command exited (-?[0-9]+)/;
+export function evidenceProblemOf(verdict, reasons) {
+    if (verdict === "verified" || verdict === "attested")
+        return "none";
+    if (verdict === "refuted")
+        return reasons.some(reason => FAILED_CHECK.test(reason)) ? "checks-failed" : "mismatched";
+    return "missing";
+}
+/** The exit code of the failed check, when the recorded reason names one. */
+export function failedCheckExit(reasons) {
+    for (const reason of reasons) {
+        const found = FAILED_CHECK.exec(reason);
+        if (found !== null)
+            return Number(found[1]);
+    }
+    return null;
+}
+/** The observed publication record in words. Each state is a distinct
+ * fact: a pushed branch is not a PR, an open PR is not a merge, and a
+ * merge is not a deployment — no record here ever says "deployed". The
+ * words name what was recorded or last observed and what stays
+ * unconfirmed; a missing or stale observation never proves that nothing
+ * merged or deployed, and merging is never called manual-only — an
+ * authorized mode may merge on green. */
+export function publicationStatusOf(publication) {
+    if (publication === null)
+        return null;
+    const pr = publication.prNumber === null ? "the pull request" : `PR #${publication.prNumber}`;
+    const ci = publication.lastCheckState === null || publication.lastCheckState === "none" ? "" : ` CI was last seen ${publication.lastCheckState}.`;
+    if (publication.remoteState === "MERGED") {
+        return { token: "merge-observed", label: "Merge observed", detail: `GitHub reports ${pr} merged. Deployment is not confirmed by any record here.` };
+    }
+    if (publication.remoteState === "CLOSED") {
+        return { token: "pr-closed", label: "PR closed without merging", detail: `GitHub last reported ${pr} closed without a merge. No merge or deployment is recorded here.` };
+    }
+    if (publication.state === "opened") {
+        return { token: "pr-opened", label: "PR opened", detail: `${pr} was last seen open on GitHub. No merge or deployment is recorded here.${ci}` };
+    }
+    if (publication.state === "pushed") {
+        return { token: "branch-pushed", label: "Branch pushed", detail: "The branch reached the remote; no pull request is recorded yet." };
+    }
+    if (publication.state === "failed") {
+        return { token: "publication-failed", label: "Publication failed", detail: "The last publication attempt failed; no pull request or merge is recorded here." };
+    }
+    return { token: "publication-pending", label: "Publication requested", detail: "Publishing was authorized and has not completed; no pull request or merge is recorded yet." };
+}
+/**
+ * The finished result's status — the one place the done words are chosen.
+ * Precedence: no record → scout report → operator acceptance → the machine
+ * verdict's problems (a refuted or short verdict is never masked by a
+ * no-change outcome) → a no-change conclusion, which owes no proof beyond
+ * its handoff and sealed diff → agent-attested → verified, where an
+ * observed publication names itself (a published but unverified result
+ * keeps its evidence problem as the main wording; the publication rides
+ * the detail).
+ */
+export function resultStatusOf(result, publication = null) {
+    return storedResultStatusOf(result, publication);
+}
+/** What the machine itself recorded about a result, in a clause. */
+function machineVerdictWords(result) {
+    if (result.verdict === "verified")
+        return "it verified the result before the acceptance";
+    if (result.verdict === "attested")
+        return "the checks on record are the agent's own report";
+    const problem = evidenceProblemOf(result.verdict, result.reasons);
+    if (problem === "checks-failed") {
+        const exit = failedCheckExit(result.reasons);
+        return `the approved check failed against it${exit === null ? "" : ` (exit ${exit})`}`;
+    }
+    if (problem === "mismatched")
+        return "its evidence did not match the sealed record";
+    return "its required evidence was missing";
+}
+function storedResultStatusOf(result, publication) {
+    if (result === null || result.runId === null) {
+        return {
+            token: "no-build-record",
+            label: "Marked done without a build record",
+            detail: "The task is done, but no finished attempt is recorded, so there is nothing to verify.",
+            tone: "problem",
+            action: { label: "Open the task", kind: "open-task" },
+        };
+    }
+    if (result.role === "scout") {
+        return { token: "report-ready", label: "Report ready", detail: "The research report is ready to read.", tone: "ready", action: { label: "Read the report", kind: "open-result" } };
+    }
+    const published = publicationStatusOf(publication);
+    const withPublication = (detail) => (published === null ? detail : `${detail} ${published.detail}`);
+    const humanReview = manualReviewOnly({ verdict: result.verdict ?? "", reasons: result.reasons });
+    if (result.accepted && humanReview) {
+        return { token: "accepted-exception", label: "Accepted by a person", detail: withPublication("A person accepted this result. The recorded checks are unchanged."), tone: "done", action: { label: "Open the acceptance", kind: "open-review" } };
+    }
+    if (result.accepted) {
+        return {
+            token: "accepted-exception",
+            label: "Accepted with an exception",
+            // Acceptance records a person's decision; it neither proves nor
+            // disproves anything about the checks. The machine's own verdict is
+            // restated as recorded.
+            detail: withPublication(`An approver accepted this result by hand, and the recorded exception says why. The machine's verdict is unchanged: ${machineVerdictWords(result)}.`),
+            tone: "done",
+            action: { label: "Open the recorded exception", kind: "open-review" },
+        };
+    }
+    const problem = evidenceProblemOf(result.verdict, result.reasons);
+    if (problem === "checks-failed") {
+        const exit = failedCheckExit(result.reasons);
+        return {
+            token: "checks-failed",
+            label: "Changes saved, but checks failed",
+            detail: withPublication(`The repository's approved check failed against this build${exit === null ? "" : ` (exit ${exit})`}, so the result is not verified.`),
+            tone: "problem",
+            action: { label: "Open the failed check", kind: "open-review" },
+        };
+    }
+    if (problem === "mismatched") {
+        return {
+            token: "evidence-mismatch",
+            label: "Result saved, but its record does not match",
+            // A structural refutation is settled before the approved check is
+            // weighed, so it says nothing about whether that check passed.
+            detail: withPublication("The proof's claims disagree with the sealed record. Whether the approved check passed is not settled by this verdict."),
+            tone: "problem",
+            action: { label: "Open the record", kind: "open-review" },
+        };
+    }
+    if (result.verdict === "short" && humanReview) {
+        return { token: "verification-needed", label: "Ready to inspect", detail: withPublication("The remaining requirements need a person's inspection. Open the result and record your decision."), tone: "attention", action: { label: "Inspect the result", kind: "open-review" } };
+    }
+    if (result.verdict === "short") {
+        return {
+            token: "verification-needed",
+            label: "Result saved — verification needed",
+            detail: withPublication("Required saved material is missing, so this result is not verified."),
+            tone: "problem",
+            action: { label: "See what is missing", kind: "open-review" },
+        };
+    }
+    if (result.outcome === "no-change") {
+        // A machine verdict (attested or verified) already proved the record
+        // at adjudication; only a verdict-less no-change reads its two
+        // presence facts here.
+        return result.recordComplete === false && result.verdict === null
+            ? { token: "record-incomplete", label: "No-change result, record incomplete", detail: "The build concluded nothing needed to change, but its handoff or sealed diff is missing.", tone: "problem", action: { label: "Open the record", kind: "open-run" } }
+            : { token: "no-change", label: "No changes were needed", detail: withPublication("The build concluded nothing needed to change; its handoff and sealed diff are on record."), tone: "done", action: { label: "Open the result", kind: "open-result" } };
+    }
+    if (result.verdict === null) {
+        return {
+            token: "verification-needed",
+            label: "Result saved — verification needed",
+            detail: withPublication("No verification result is recorded for this build."),
+            tone: "problem",
+            action: { label: "See what is missing", kind: "open-review" },
+        };
+    }
+    if (result.verdict === "attested") {
+        return {
+            token: "agent-attested",
+            label: "Result saved — checks reported by the agent",
+            detail: withPublication("No independent project check ran; the checks listed are the agent's own report."),
+            tone: "neutral",
+            action: { label: "Open the result", kind: "open-result" },
+        };
+    }
+    if (published !== null && (published.token === "merge-observed" || published.token === "pr-opened" || published.token === "pr-closed")) {
+        return {
+            token: published.token,
+            label: published.label,
+            detail: `The approved check passed against this result. ${published.detail}`,
+            tone: published.token === "pr-closed" ? "muted" : "done",
+            action: published.token === "merge-observed" ? { label: "Open the result", kind: "open-result" } : { label: "Open the pull request", kind: "open-pr" },
+        };
+    }
+    return {
+        token: "ready-to-review",
+        label: "Ready",
+        detail: withPublication("The approved check passed against this result."),
+        tone: "ready",
+        action: { label: "Open the result", kind: "open-result" },
+    };
+}
+/** The completion receipt's heading: what the record actually supports.
+ * Never "shipped" — local changes are saved; a PR or merge is named only
+ * from its observed record. */
+export function receiptHeadingOf(outcome, publication, role) {
+    const published = publicationStatusOf(publication);
+    if (published !== null && (published.token === "merge-observed" || published.token === "pr-opened"))
+        return published.label;
+    if (role === "scout" && (outcome === "built" || outcome === "no-change"))
+        return "Report saved";
+    if (outcome === "no-change")
+        return "No changes were needed";
+    return "Changes saved";
+}
+/** The receipt's one-line publication fact under the heading. */
+export function receiptPublicationWords(publication) {
+    const published = publicationStatusOf(publication);
+    return published === null ? "Saved on the build branch. No publication, merge, or deployment is recorded here." : published.detail;
+}
+/** These dispatch states may yield the headline to an unanswered
+ * question. Failure, uncertain process ownership, holds, approvals and
+ * stop settlement deliberately do not yield. This never alters dispatch. */
+const QUESTION_FIRST = new Set([
+    "running", "waiting-decision", "no-worker-online", "no-worker-registered",
+    "worker-at-capacity", "ready", "planning-ready", "scouting-ready",
+]);
+/** Needs you: the existing diagnosis semantics — waiting on a person with a
+ * concrete act — never every queued task indiscriminately. */
+export function needsPerson(dispatch) {
+    if (dispatch === null || dispatch.action === null)
+        return false;
+    // A failed task is terminal for the scheduler and still a person's act
+    // (retry); every other terminal answer (complete, cancelled) is not.
+    return dispatch.condition === "waiting" || dispatch.code === "failed";
+}
+/** Navigation labels describe the available help, not a mutation: opening
+ * a hold or pause must never promise that the task has already resumed. */
+const DISPATCH_ACTION_LABELS = {
+    "open-result": "Open the result",
+    "retry-task": "Review and retry",
+    "place-task": "Choose a project",
+    "write-scope": "Define the task",
+    "select-agent": "Choose an agent",
+    "approve-scope": "Review plan",
+    "answer-decision": "Answer the question",
+    unhold: "Review hold",
+    "inspect-hold": "Review hold",
+    "repair-dependency": "Review required task",
+    "repair-capability": "Review missing requirement",
+    "start-worker": "Check connection",
+    "retry-review": "Review retry options",
+    "resume-run": "Review pause",
+};
+export function dispatchActionLabel(dispatch) {
+    return dispatch?.action == null ? "View task details" : DISPATCH_ACTION_LABELS[dispatch.action];
+}
+export function workStatusOf(facts, resultDisplay) {
+    const dispatch = facts.dispatch;
+    const result = facts.state === "done" ? resultDisplay ?? resultStatusOf(facts.result, facts.publication) : null;
+    const running = facts.liveRunId !== null || (dispatch?.condition === "running" && !REVIEW_TOKENS.has(dispatch.code));
+    const question = (facts.state === "queued" || facts.state === "running" || facts.state === "done") ? facts.openDecision ?? null : null;
+    const needs = (dispatch !== null && !REVIEW_TOKENS.has(dispatch.code) && needsPerson(dispatch)) || question !== null;
+    const views = ["all"];
+    if (needs)
+        views.push("needs-you");
+    if (running)
+        views.push("running");
+    if (facts.state === "done")
+        views.push("completed");
+    const dispatchWords = (tone, rank, action) => ({
+        token: dispatch?.code ?? "unknown",
+        label: dispatch?.summary ?? "Status unknown",
+        detail: dispatch?.detail ?? "Refresh this task before relying on its status.",
+        tone,
+        action,
+        views,
+        rank,
+    });
+    // The control projection knows whether a stop has actually settled.
+    // A still-live claim alone cannot distinguish Running from Stopping.
+    if (facts.control?.kind === "stopping") {
+        return { token: "stopping", label: "Stopping…", detail: facts.control.detail ?? "The attempt is ending. Its work is preserved; resume becomes available after its processes exit.", tone: "attention", action: { label: "View stop details", kind: "open-task" }, views, rank: 0 };
+    }
+    if (facts.control?.kind === "paused") {
+        return { token: "stopped", label: "Paused", detail: "The stopped attempt's work is preserved. Resuming requires confirmation and checks the current approval again.", tone: "attention", action: { label: "Review pause", kind: "open-task" }, views, rank: 0 };
+    }
+    if (facts.state === "done" && result !== null) {
+        // A saved result or an ongoing review cannot answer a question. Keep
+        // failures primary; the shared summary retains the answer action too.
+        if (question !== null && result.tone !== "problem") {
+            return { token: "waiting-decision", label: "Waiting on your answer", detail: question.question,
+                tone: "attention", action: { label: "Answer question", kind: "open-task" }, views, rank: 0,
+                diagnostics: [{ token: result.token, label: result.label, detail: result.detail, tone: result.tone }] };
+        }
+        return { ...result, views, rank: needs ? 0 : 3 };
+    }
+    if (facts.state === "cancelled") {
+        return { token: "cancelled", label: "Cancelled", detail: dispatch?.detail ?? "Nothing else will run for this task.", tone: "muted", action: null, views, rank: 4 };
+    }
+    if (question !== null && facts.state !== "failed" && dispatch !== null && QUESTION_FIRST.has(dispatch.code)) {
+        return {
+            token: "waiting-decision", label: "Waiting on your answer", detail: question.question,
+            tone: "attention", action: { label: "Answer question", kind: "open-task" }, views, rank: 0,
+            ...(dispatch.code === "waiting-decision" ? {} : {
+                diagnostics: [{ token: dispatch.code, label: dispatch.summary, detail: dispatch.detail, tone: dispatch.condition === "running" ? "live" : "attention" }],
+            }),
+        };
+    }
+    if (running) {
+        return dispatchWords("live", 1, { label: "Watch the build", kind: facts.liveRunId === null ? "open-task" : "open-run" });
+    }
+    if (facts.state === "failed") {
+        return dispatchWords("problem", 0, { label: "Review and retry", kind: "open-task" });
+    }
+    if (needs) {
+        return dispatchWords("attention", 0, { label: dispatchActionLabel(dispatch), kind: "open-task" });
+    }
+    const details = { label: "View task details", kind: "open-task" };
+    if (dispatch === null)
+        return dispatchWords("neutral", 2, details);
+    return dispatchWords(dispatch.condition === "retrying" ? "neutral" : "muted", 2, details);
+}
+/** The counts each view tab wears — from the same rows the page lists. */
+export function workCounts(rows) {
+    const counts = { all: 0, "needs-you": 0, running: 0, completed: 0 };
+    for (const row of rows)
+        for (const view of row.views)
+            counts[view] += 1;
+    return counts;
+}
+/** All's order: rank, then most recently updated. */
+export function compareWorkRows(a, b) {
+    return a.rank - b.rank || (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0);
+}
+const WORK_KEYS = new Set(["inbox", "board", "queue", "work", "done", "activity", "review", "tasks", "runs", "workbench", "routines", "recipes", "ledger"]);
+const SETTINGS_KEYS = new Set(["fleet", "caps", "people", "mode", "system", "settings"]);
+export function primaryDestinationOf(active) {
+    if (active === "chat")
+        return "chat";
+    if (active === "projects")
+        return "projects";
+    if (active === "flows")
+        return "flows";
+    if (WORK_KEYS.has(active))
+        return "work";
+    if (SETTINGS_KEYS.has(active))
+        return "settings";
+    return null;
+}
+/** Learning stays in Settings and a useful, closed result disclosure. */
+export function learningHtml(view, csrf, canManage, source) {
+    const e = (x) => String(x).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+    const fields = (values) => Object.entries(values).map(([k, v]) => `<input type="hidden" name="${e(k)}" value="${e(v)}">`).join('');
+    const base = { csrf, repo: view.repo, identity: view.identity, revision: view.revision };
+    const act = (action, label, lesson) => canManage && csrf ? `<form method="post" action="/settings/learning/change">${fields({ ...base, action, ...(lesson ? { lesson: lesson.id, version: lesson.version, sha: lesson.sha } : {}) })}<button type="submit">${label}</button></form>` : '';
+    const evidence = (list, run) => list.map(one => `<li><a href="/r/${one.runId ?? run}/evidence/${one.artifactId}">Source #${one.artifactId}</a><blockquote>${e(one.excerpt)}</blockquote><code>${e(one.sha256)}</code></li>`).join('');
+    const lessons = view.lessons.filter(l => source === undefined || l.source === source);
+    const cards = lessons.map(l => `<article class="card" data-lesson="${l.id}"><p><strong>${e(l.payload.observation)}</strong></p><p>${e(l.payload.action)}</p><p class="meta">${l.payload.kind === 'system' ? 'System suggestion · No change applied' : e(l.status === 'adopted' ? 'Adopted advice' : l.status === 'disabled' ? 'Disabled' : 'Proposed lesson')}</p><details><summary>Source and use</summary><p><a href="/r/${l.source}">Result #${l.source}</a> · <a href="/r/${l.reviewer}">Review #${l.reviewer}</a></p><p>${e(l.payload.paths.join(', '))} · ${e(l.payload.phases.join(', '))} · ${e({ darwin: "macOS", win32: "Windows", linux: "Linux" }[l.payload.platform] ?? l.payload.platform)}</p><ul>${evidence(l.payload.evidence, l.source)}</ul>${l.payload.kind !== 'project' ? '' : `<p class="meta">${l.status === 'proposed' ? 'Save permits advisory reuse when enabled and applicable. It does not prove a remedy works.' : 'Disabling affects future runs. Active snapshots, code and approvals stay unchanged.'}</p>${l.status === 'proposed' ? act('adopt', 'Save lesson', l) : ''}`}</details>${l.payload.kind === 'project' && l.status === 'adopted' ? act('disable', 'Disable lesson', l) : ''}</article>`).join('');
+    if (source !== undefined)
+        return lessons.length ? `<details class="learning result-learning"><summary>Learned from this task</summary>${cards}<a href="/settings/learning?repo=${encodeURIComponent(view.repo)}">Learning settings</a></details>` : '';
+    const history = view.events.map(ev => `<article class="card" data-learning-event="${e(ev.action)}"><p><strong>${e({ assessment: { propose: 'Learning suggested', none: 'No lesson needed', unassessed: 'Learning not assessed', invalid: 'Learning assessment invalid' }[ev.after] ?? 'Learning not assessed', proposal: 'Suggestion recorded', adopt: 'Lesson adopted', disable: 'Lesson disabled', reset: 'Learning reset', enable: 'Reuse enabled', pause: 'Reuse paused', reuse: 'Run context saved', failure: 'Learning issue', capture: 'Capture finished' }[ev.action] ?? ev.action)}</strong>${ev.action === "reuse" ? ` · ${e(ev.after)}` : ""}</p><p class="meta"><time datetime="${e(ev.at)}">${e(ev.at.replace("T", " ").replace(/\.\d+Z$/, " UTC"))}</time> · ${e(ev.actor)}${ev.run === null ? '' : ` · <a href="/r/${ev.run}">Run #${ev.run}</a>${ev.outcome === null ? "" : ` · ${e(ev.outcome)}`}`}</p><details><summary>Details</summary><p>${e(ev.before)} → ${e(ev.after)}</p><p>${e(ev.reason)}</p>${ev.lesson === null ? '' : `<p>Lesson #${ev.lesson}</p>`}<ul>${evidence(ev.evidence, ev.run)}</ul>${ev.snapshot === null ? "" : `<details><summary>Exact context</summary><pre>${e(ev.snapshot)}</pre></details>`}</details></article>`).join('');
+    return `<section class="learning">${view.damaged ? '<p class="problem" role="alert">Some lessons no longer verify and are excluded from reuse.</p>' : ''}<p>${view.enabled ? 'Use adopted lessons: on' : 'Use adopted lessons: off'}</p>${act(view.enabled ? 'pause' : 'enable', view.enabled ? 'Pause reuse' : 'Enable reuse')}${cards || '<p>No lessons yet. Reviews may suggest useful advice here.</p>'}<details><summary>Reset learning</summary><p>Disable all adopted lessons and future reuse. Keep history, code, approvals and active run snapshots.</p>${act('reset', 'Reset learning')}</details><h2>Changes</h2>${history || '<p>No learning changes yet.</p>'}${view.next === null ? '' : `<a class="button-link" href="/settings/learning?repo=${encodeURIComponent(view.repo)}&before=${view.next}">Older changes</a>`}</section>`;
+}

package/dist/worktree-notices.d.ts

@@ -0,0 +1,13 @@
+/** One announcement for a reconciliation batch. The complete path inventory
+ * stays in worktree rows and reconcile's result; this grants no reuse/deletion
+ * authority and performs no filesystem or database changes. */
+export declare function worktreeAdoptionNotice(repo: string, adopted: readonly string[], now: Date): {
+    source: {
+        project: string;
+    };
+    dedupeKey: string;
+    kind: string;
+    subject: string;
+    body: string;
+    link: string;
+} | null;

package/dist/worktree-notices.js

@@ -0,0 +1,17 @@
+import { createHash } from "node:crypto";
+/** One announcement for a reconciliation batch. The complete path inventory
+ * stays in worktree rows and reconcile's result; this grants no reuse/deletion
+ * authority and performs no filesystem or database changes. */
+export function worktreeAdoptionNotice(repo, adopted, now) {
+    const paths = [...new Set(adopted)].sort();
+    if (paths.length === 0)
+        return null;
+    const count = paths.length, plural = count !== 1;
+    const digest = createHash("sha256").update(JSON.stringify([repo, paths, now.toISOString()])).digest("hex");
+    return {
+        source: { project: repo }, dedupeKey: `worktree-adoption:${digest}`, kind: "worktree-adopted",
+        subject: `${count} worktree${plural ? "s" : ""} need${plural ? "" : "s"} review`,
+        body: `${count} existing worktree${plural ? "s were" : " was"} added to the inventory as released and unverified. Review before reusing or deleting ${plural ? "them" : "it"}.`,
+        link: `/system?project=${encodeURIComponent(repo)}`,
+    };
+}