toolroll 0.9.84 → 0.9.85

package/dist/project-activity.js

@@ -0,0 +1,23 @@
+export const activityAge = (ms) => ms === null ? 'Unknown' : ms < 3600000 ? `${Math.floor(ms / 60000)}m` : ms < 86400000 ? `${(ms / 3600000).toFixed(1)}h` : `${(ms / 86400000).toFixed(1)}d`;
+export const activityMoney = (usd) => usd === null ? 'Unknown' : `$${usd.toFixed(2)}`;
+export const ACTIVITY_ACTORS = { human: 'Human', lead: 'Lead', landed: 'Automatically landed', 'machine-or-unknown': 'Machine or unknown' };
+export const activityScope = (report) => `Current Ready backlog; completions in the last ${report.days} days. Completion does not mean checks passed or work deployed.`;
+export const activityLimit = (report) => `Partial report: only the ${report.limit} most recently updated eligible families are included. Counts and coverage below describe this sample.`;
+export function activityMetrics(report) {
+    const ready = report.families.filter(one => one.state === 'ready');
+    const complete = report.families.filter(one => one.state === 'completed');
+    const metrics = [
+        { label: 'Ready', value: report.ready.count === 0 ? '0' : `${report.ready.count} · Oldest ${activityAge(report.ready.oldestFinishedAgeMs)}`,
+            detail: `Age is measured from the latest result finishing, a proxy for Ready entry. ${report.ready.dated}/${report.ready.count} have usable timestamps.`, rows: ready },
+        { label: 'Finished to decision', value: report.completed.count === 0 ? 'No completed families' : `${activityAge(report.finishedToDecision.meanMs)} average`,
+            detail: `${report.finishedToDecision.samples}/${report.completed.count} completed families have usable timestamps. Elapsed time to the saved completion decision, not human work time.`, rows: complete },
+        { label: 'Explicit revisions', value: report.revisions.perCompletedFamily === null ? 'No completed families' : `${report.revisions.perCompletedFamily.toFixed(1)} per completed family`,
+            detail: `${report.revisions.count} revisions across ${report.revisions.samples} completed families. Retries are attempts, not revisions.`, rows: complete },
+        { label: 'Recorded spend', value: report.completed.count === 0 ? 'No completed families' : `${activityMoney(report.cost.recordedPerCompletedFamilyUsd)} per completed family · ${report.cost.knownRuns}/${report.cost.runs} costs known`,
+            detail: `${activityMoney(report.cost.recordedUsd)} in API charges across ${report.cost.families} completed families; ${report.cost.fullyCostedFamilies}/${report.cost.families} fully costed.${report.cost.subscriptionRuns > 0 ? ` ${report.cost.subscriptionRuns} subscription runs are plan usage, not charges${report.cost.subscriptionReportedUsd === null ? '' : ` (${activityMoney(report.cost.subscriptionReportedUsd)} reported)`}.` : ''} Missing or unreported costs are unknown. All family attempts count once, including planning and retries.`, rows: complete },
+        { label: 'Completed families', value: String(report.completed.count),
+            detail: `${Object.entries(report.completed.actors).map(([key, count]) => `${ACTIVITY_ACTORS[key]}: ${count}`).join(' · ')}. Scouts: ${report.completed.scouts}. Failed checks: ${report.completed.failedChecks}.`, rows: complete },
+        ...(report.incompleteHistory > 0 ? [{ label: 'Incomplete history', value: String(report.incompleteHistory), detail: 'Excluded from completion averages; their family relationships cannot be established.', rows: report.families.filter(one => one.state === 'history-unavailable') }] : []),
+    ];
+    return report.completed.count === 0 ? metrics.filter(one => one.label === 'Ready' || one.label === 'Completed families' || one.label === 'Incomplete history') : metrics;
+}

package/dist/project-cli.d.ts

@@ -12,6 +12,7 @@ export declare function runProjectCommand(positional: readonly string[], flags:
     write: (line: string) => void;
     json: boolean;
     registryFile?: string;
+    now?: Date;
 }): Promise<number>;
 /** Only known credential-aware adapters consume the remembered reference.
  * Explicit credentials always win; no legacy action gains implicit authority. */

package/dist/project-cli.js

@@ -8,6 +8,7 @@ import { configPath, loadRepos } from './repos.js';
 import { authenticateCoordinator } from './coordinator.js';
 import { canonicalProject } from './project.js';
 import { envelopeJson } from './envelope.js';
+import { projectOutcomes } from './project-outcomes.js';
 export const projectProfilePath = (databaseFile) => join(dirname(databaseFile), 'cli-project.json');
 export function readProjectProfile(databaseFile) {
     const file = projectProfilePath(databaseFile);
@@ -25,11 +26,29 @@ export function readProjectProfile(databaseFile) {
         throw new Error('The saved CLI project is invalid. Select it again with project use.');
     return { version: 1, repo: p['repo'], tokenFile: p['tokenFile'] };
 }
+function scopedCredentialRefusal(store, tokenFile, repo) {
+    let token;
+    try {
+        const info = statSync(tokenFile);
+        if (!info.isFile() || info.size > 16_384)
+            return { reason: 'unauthenticated', message: 'The scoped credential file is unavailable.' };
+        token = readFileSync(tokenFile, 'utf8').trim();
+    }
+    catch {
+        return { reason: 'unauthenticated', message: 'The scoped credential file is unavailable.' };
+    }
+    const auth = authenticateCoordinator(store, token);
+    if (!auth.ok)
+        return { reason: 'unauthenticated', message: 'The scoped credential is invalid or revoked.' };
+    if (!auth.who.repos.includes(repo))
+        return { reason: 'not-found', message: 'That project is unavailable to this credential.' };
+    return null;
+}
 export async function runProjectCommand(positional, flags, context) {
     const action = positional[0] ?? 'show', command = `project ${action}`;
     const fail = (reason, message) => { context.write(context.json ? envelopeJson({ ok: false, command, reason, message }) : message); return reason === 'usage' ? 2 : 3; };
-    if (!['use', 'show'].includes(action) || positional.length > (action === 'use' ? 2 : 1))
-        return fail('usage', 'Use project use <saved checkout path> [--token-file PATH], or project show.');
+    if (!['use', 'show', 'activity'].includes(action) || positional.length > (action === 'use' ? 2 : 1))
+        return fail('usage', 'Use project use <saved checkout path> [--token-file PATH], project show, or project activity [--json].');
     const allowed = new Set(['db', 'json', ...(action === 'use' ? ['token-file'] : [])]);
     for (const name of flags.keys())
         if (!allowed.has(name))
@@ -57,23 +76,9 @@ export async function runProjectCommand(positional, flags, context) {
         if (credential !== undefined && (typeof credential !== 'string' || !credential || /[\x00-\x1f]/.test(credential)))
             return fail('usage', '--token-file requires a path.');
         const tokenFile = typeof credential === 'string' ? resolve(credential) : null;
-        if (tokenFile !== null) {
-            let token;
-            try {
-                const info = statSync(tokenFile);
-                if (!info.isFile() || info.size > 16_384)
-                    return fail('unauthenticated', 'The scoped credential file is unavailable.');
-                token = readFileSync(tokenFile, 'utf8').trim();
-            }
-            catch {
-                return fail('unauthenticated', 'The scoped credential file is unavailable.');
-            }
-            const auth = authenticateCoordinator(context.store, token);
-            if (!auth.ok)
-                return fail('unauthenticated', 'The scoped credential is invalid or revoked.');
-            if (!auth.who.repos.includes(repo))
-                return fail('not-found', 'That project is unavailable to this credential.');
-        }
+        const refused = tokenFile === null ? null : scopedCredentialRefusal(context.store, tokenFile, repo);
+        if (refused)
+            return fail(refused.reason, refused.message);
         profile = { version: 1, repo, tokenFile };
         const file = projectProfilePath(context.databaseFile), temp = `${file}.${randomBytes(6).toString('hex')}.tmp`;
         mkdirSync(dirname(file), { recursive: true });
@@ -82,6 +87,18 @@ export async function runProjectCommand(positional, flags, context) {
     }
     else
         profile = readProjectProfile(context.databaseFile);
+    if (action === 'activity') {
+        if (profile === null || !repos.includes(profile.repo))
+            return fail('not-found', 'Select a saved project with project use first.');
+        const refused = profile.tokenFile === null ? null : scopedCredentialRefusal(context.store, profile.tokenFile, profile.repo);
+        if (refused)
+            return fail(refused.reason, refused.message);
+        // Like assignment brief, an uncredentialed local database read has the
+        // local operator's access. A saved scoped credential is always re-proved.
+        const result = projectOutcomes(context.store, profile.repo, context.now ?? new Date(), { principal: 'operator', repos: [profile.repo] });
+        context.write(context.json ? envelopeJson({ ok: true, command, result }) : JSON.stringify(result, null, 2));
+        return 0;
+    }
     const result = { profile, saved: profile !== null && repos.includes(profile.repo) };
     context.write(context.json ? envelopeJson({ ok: true, command, result }) : profile === null ? 'No project selected. Use project use <saved checkout path>.' : `${profile.repo}${result.saved ? '' : ' (no longer saved)'}\n${profile.tokenFile === null ? 'Uses your existing local sign-in for operator actions.' : `Scoped credential reference: ${profile.tokenFile}`}`);
     return 0;

package/dist/project-knowledge.d.ts

@@ -23,17 +23,18 @@ export declare function knowledgeVersion(store: Store, repo: string, actor: stri
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
     title?: never;
+    content?: never;
     revision: number;
     stale: boolean;
     notice: string;
     decision?: never;
-    content?: never;
     history?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
 } | {
     title?: never;
+    content?: never;
     stale?: never;
     decision: {
         repo: string;
@@ -50,7 +51,6 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
         id: number;
     };
     notice: string;
-    content?: never;
     revision?: never;
     history?: never;
     instructions?: never;
@@ -69,9 +69,9 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     decisions?: never;
 } | {
     title?: never;
+    content?: never;
     stale?: never;
     decision?: never;
-    content?: never;
     revision: number;
     history: {
         revision: number;

package/dist/project-outcomes.d.ts

@@ -0,0 +1,119 @@
+import type { Store } from './store.js';
+import type { WorkSummaryAccess } from './work-summary.js';
+export declare const ACTIVITY_DAYS = 60;
+export declare const ACTIVITY_LIMIT = 500;
+export type CompletionActor = 'human' | 'lead' | 'landed' | 'machine-or-unknown';
+export type ActivityFamily = {
+    root: string;
+    task: string;
+    title: string;
+    run: number | null;
+    href: string;
+    state: 'ready' | 'completed' | 'history-unavailable';
+    kind: string;
+    finishedAt: string | null;
+    completedAt: string | null;
+    actor: CompletionActor | null;
+    checks: string;
+    revisions: number | null;
+    elapsedMs: number | null;
+    runs: number;
+    /** Runs whose amount is known (reported-usage.ts runAmountOf): API dollars or subscription usage. */
+    knownCostRuns: number;
+    subscriptionRuns: number;
+    /** API dollars only; subscription usage is never added to them. */
+    recordedUsd: number | null;
+    subscriptionReportedUsd: number | null;
+    /** Every attempt billed in known API dollars; otherwise the family's dollar total is unknown. */
+    totalUsd: number | null;
+};
+export type ProjectOutcomes = {
+    asOf: string;
+    since: string;
+    days: number;
+    limit: number;
+    truncated: boolean;
+    ready: {
+        count: number;
+        oldestFinishedAgeMs: number | null;
+        dated: number;
+    };
+    completed: {
+        count: number;
+        actors: Record<CompletionActor, number>;
+        scouts: number;
+        failedChecks: number;
+    };
+    finishedToDecision: {
+        meanMs: number | null;
+        samples: number;
+    };
+    revisions: {
+        count: number;
+        perCompletedFamily: number | null;
+        samples: number;
+    };
+    cost: {
+        recordedUsd: number | null;
+        recordedPerCompletedFamilyUsd: number | null;
+        runs: number;
+        knownRuns: number;
+        subscriptionRuns: number;
+        subscriptionReportedUsd: number | null;
+        fullyCostedFamilies: number;
+        families: number;
+    };
+    incompleteHistory: number;
+    families: ActivityFamily[];
+};
+/** Callers supply their current authenticated ceiling. A path alone grants no access. */
+export declare function projectOutcomes(store: Store, project: string, now: Date, access: WorkSummaryAccess): ProjectOutcomes;
+/** The lead's page of one report: every aggregate unchanged, family rows in pages bounded by count AND by their
+ * serialized size, so the reply always fits the tool-result cap (lead.ts, converse.ts LEAD_TOOL_RESULT_CAP_BYTES) and
+ * the lead reads further with nextOffset. Long ids and titles are shortened; an over-long link is left out. */
+export declare const ACTIVITY_LEAD_PAGE = 10;
+export declare const ACTIVITY_LEAD_PAGE_BYTES = 12000;
+export declare function projectOutcomesPage(report: ProjectOutcomes, offset?: number): {
+    asOf: string;
+    since: string;
+    days: number;
+    limit: number;
+    truncated: boolean;
+    ready: {
+        count: number;
+        oldestFinishedAgeMs: number | null;
+        dated: number;
+    };
+    completed: {
+        count: number;
+        actors: Record<CompletionActor, number>;
+        scouts: number;
+        failedChecks: number;
+    };
+    finishedToDecision: {
+        meanMs: number | null;
+        samples: number;
+    };
+    revisions: {
+        count: number;
+        perCompletedFamily: number | null;
+        samples: number;
+    };
+    cost: {
+        recordedUsd: number | null;
+        recordedPerCompletedFamilyUsd: number | null;
+        runs: number;
+        knownRuns: number;
+        subscriptionRuns: number;
+        subscriptionReportedUsd: number | null;
+        fullyCostedFamilies: number;
+        families: number;
+    };
+    incompleteHistory: number;
+    families: (Omit<ActivityFamily, "href"> & {
+        href: string | null;
+    })[];
+    familiesTotal: number;
+    familiesOffset: number;
+    nextOffset: number | null;
+};

package/dist/project-outcomes.js

@@ -0,0 +1,79 @@
+/** Read-only Activity. A completion is a saved decision, never a claim of
+ * passing checks, deployment, review labor, or improved productivity. */
+import { chatResultHref } from './chat-controls.js';
+import { workOutcomeRows } from './work-index.js';
+import { COMPLETION_BY_PERSON, LANDED_ACTOR } from './result-completion.js';
+export const ACTIVITY_DAYS = 60;
+export const ACTIVITY_LIMIT = 500;
+const text = (value) => value == null ? null : String(value);
+const duration = (from, to) => {
+    const delta = from === null ? NaN : Date.parse(to) - Date.parse(from);
+    return Number.isFinite(delta) && delta >= 0 ? delta : null;
+};
+const actorOf = (actor, detail, byLead) => actor === LANDED_ACTOR ? 'landed'
+    : byLead || actor?.startsWith('lead:') ? 'lead'
+        : actor?.startsWith('operator:') && detail === COMPLETION_BY_PERSON ? 'human' : 'machine-or-unknown';
+/** Callers supply their current authenticated ceiling. A path alone grants no access. */
+export function projectOutcomes(store, project, now, access) {
+    if (access.repos !== null && !access.repos.includes(project))
+        throw new Error('Project activity is outside your access.');
+    const asOf = now.toISOString(), since = new Date(now.getTime() - ACTIVITY_DAYS * 86400000).toISOString();
+    const rows = workOutcomeRows(store, now, access, project, since, ACTIVITY_LIMIT);
+    const families = rows.slice(0, ACTIVITY_LIMIT).map(row => {
+        const state = row['code'] === 'complete' ? 'completed' : row['code'] === 'ready-to-check' ? 'ready' : 'history-unavailable';
+        const finishedAt = text(row['finished_at']), completedAt = text(row['checked_at']);
+        const runs = Number(row['runs']), apiRuns = Number(row['api_runs']), subscriptionRuns = Number(row['subscription_runs']);
+        const recordedUsd = apiRuns > 0 && Number.isFinite(Number(row['api_microusd'])) ? Number(row['api_microusd']) / 1_000_000 : null;
+        const subscriptionReportedUsd = row['subscription_usd'] != null && Number.isFinite(Number(row['subscription_usd'])) ? Number(row['subscription_usd']) : null;
+        const knownCostRuns = apiRuns + subscriptionRuns;
+        const task = String(row['task_id']);
+        return { root: String(row['root_id']), task, title: String(row['title']), run: row['result_id'] == null ? null : Number(row['result_id']),
+            href: row['result_id'] == null ? `/t/${encodeURIComponent(task)}` : chatResultHref(task, Number(row['result_id'])), state, kind: text(row['result_role']) ?? 'unknown',
+            finishedAt, completedAt, actor: state === 'completed' ? actorOf(text(row['checked_actor']), text(row['checked_detail']), Number(row['completed_by_lead']) === 1) : null,
+            checks: text(row['check_status']) ?? 'not-recorded', revisions: state === 'history-unavailable' ? null : Number(row['version_count']) - 1,
+            elapsedMs: duration(finishedAt, completedAt ?? asOf), runs, knownCostRuns, subscriptionRuns, recordedUsd, subscriptionReportedUsd,
+            totalUsd: runs > 0 && runs === apiRuns ? recordedUsd : null };
+    });
+    const ready = families.filter(one => one.state === 'ready'), completed = families.filter(one => one.state === 'completed');
+    const times = completed.flatMap(one => one.elapsedMs === null ? [] : [one.elapsedMs]);
+    const ages = ready.flatMap(one => one.elapsedMs === null ? [] : [one.elapsedMs]);
+    const actors = { human: 0, lead: 0, landed: 0, 'machine-or-unknown': 0 };
+    for (const one of completed)
+        actors[one.actor]++;
+    const knownRuns = completed.reduce((sum, one) => sum + one.knownCostRuns, 0);
+    const recordedUsd = completed.some(one => one.recordedUsd !== null) ? completed.reduce((sum, one) => sum + (one.recordedUsd ?? 0), 0) : null;
+    const subscriptionRuns = completed.reduce((sum, one) => sum + one.subscriptionRuns, 0);
+    const subscriptionReportedUsd = completed.some(one => one.subscriptionReportedUsd !== null) ? completed.reduce((sum, one) => sum + (one.subscriptionReportedUsd ?? 0), 0) : null;
+    const revisions = completed.reduce((sum, one) => sum + (one.revisions ?? 0), 0);
+    return { asOf, since, days: ACTIVITY_DAYS, limit: ACTIVITY_LIMIT, truncated: rows.length > ACTIVITY_LIMIT,
+        ready: { count: ready.length, oldestFinishedAgeMs: ages.length ? Math.max(...ages) : null, dated: ages.length },
+        completed: { count: completed.length, actors, scouts: completed.filter(one => one.kind === 'scout').length, failedChecks: completed.filter(one => one.checks === 'failed').length },
+        finishedToDecision: { meanMs: times.length ? times.reduce((a, b) => a + b, 0) / times.length : null, samples: times.length },
+        revisions: { count: revisions, perCompletedFamily: completed.length ? revisions / completed.length : null, samples: completed.length },
+        cost: { recordedUsd, recordedPerCompletedFamilyUsd: completed.length && recordedUsd !== null ? recordedUsd / completed.length : null,
+            runs: completed.reduce((sum, one) => sum + one.runs, 0), knownRuns, subscriptionRuns, subscriptionReportedUsd, fullyCostedFamilies: completed.filter(one => one.totalUsd !== null).length, families: completed.length },
+        incompleteHistory: families.filter(one => one.state === 'history-unavailable').length, families };
+}
+/** The lead's page of one report: every aggregate unchanged, family rows in pages bounded by count AND by their
+ * serialized size, so the reply always fits the tool-result cap (lead.ts, converse.ts LEAD_TOOL_RESULT_CAP_BYTES) and
+ * the lead reads further with nextOffset. Long ids and titles are shortened; an over-long link is left out. */
+export const ACTIVITY_LEAD_PAGE = 10;
+export const ACTIVITY_LEAD_PAGE_BYTES = 12_000;
+const shorten = (value, max) => [...value].length > max ? `${[...value].slice(0, max - 1).join('')}…` : value;
+const embeddedBytes = (value) => Buffer.byteLength(JSON.stringify(JSON.stringify(value)), 'utf8');
+export function projectOutcomesPage(report, offset = 0) {
+    const start = Math.max(0, Math.min(Number.isSafeInteger(offset) ? offset : 0, report.families.length));
+    const page = [];
+    const base = { ...report, families: page, familiesTotal: report.families.length, familiesOffset: start, nextOffset: null };
+    for (const one of report.families.slice(start, start + ACTIVITY_LEAD_PAGE)) {
+        const row = { ...one, root: shorten(one.root, 200), task: shorten(one.task, 200), title: shorten(one.title, 80), href: Buffer.byteLength(one.href) > 512 ? null : one.href };
+        page.push(row);
+        if (page.length > 1 && embeddedBytes(base) > ACTIVITY_LEAD_PAGE_BYTES) {
+            page.pop();
+            break;
+        }
+    }
+    const next = start + page.length;
+    base.nextOffset = next < report.families.length ? next : null;
+    return base;
+}

package/dist/result-actions.d.ts

@@ -1,4 +1,5 @@
 import type { Store } from "./store.js";
+import { type FeedbackImage } from "./result-review.js";
 export type RevisionResult = {
     ok: true;
     id: string;
@@ -8,6 +9,8 @@ export type RevisionResult = {
     message: string;
 };
 type RevisionInput = Parameters<typeof createResultRevision>[2];
+/** Re-prove image custody and current result at each write. No file paths supplied by callers. */
+export declare function feedbackImageProblem(store: Store, root: string, runId: number, image: FeedbackImage | null | undefined): string | null;
 /** One user action: add the typed change and seal exactly the displayed
  * saved notes. A refusal rolls back the note; a replay returns the same task. */
 export declare function requestResultChanges(store: Store, evidenceRoot: string, input: RevisionInput & {
@@ -15,6 +18,7 @@ export declare function requestResultChanges(store: Store, evidenceRoot: string,
     path: string;
     line: string;
     request: string | null;
+    image?: FeedbackImage | null;
 }, now: Date): RevisionResult;
 export declare function createResultRevision(store: Store, evidenceRoot: string, input: {
     run: number;

package/dist/result-actions.js

@@ -1,13 +1,33 @@
+import { verifyResultImage } from "./chat-evidence.js";
 /** Shared result-to-revision action for the result form and chat.
  * The caller authenticates; this service checks project access and the exact
  * displayed note batch, then uses the existing atomic revision/approval boundary.
  */
 import { createHash, randomBytes } from "node:crypto";
 import { EVIDENCE_CAPS, readVerifiedArtifact, writeEvidenceFile } from "./evidence.js";
-import { isRevisionFeedback, parseRevisionBatch, revisionSourceOf, commentSourceKey, REQUEST_TOKEN } from "./result-review.js";
+import { parseFeedbackImage, sameFeedbackImage, isRevisionFeedback, parseRevisionBatch, revisionSourceOf, commentSourceKey, REQUEST_TOKEN } from "./result-review.js";
 import { validateNote, hasForbiddenControls } from "./decision.js";
 import { TASK_TEXT_LIMITS, validateTaskText } from "./task-text.js";
 import { modeFilingCoverage } from "./scope.js";
+/** Re-prove image custody and current result at each write. No file paths supplied by callers. */
+export function feedbackImageProblem(store, root, runId, image) {
+    if (image == null)
+        return null;
+    const parsed = parseFeedbackImage(image);
+    if (!parsed || image.run !== runId)
+        return "Choose a screenshot from this result. Your draft is unchanged.";
+    const run = store.getRun(runId);
+    const task = run === null ? null : store.externalIdFor(run.taskRef);
+    const repo = run === null ? null : store.refById(run.taskRef)?.repo;
+    if (!task || !repo)
+        return "This screenshot is no longer available. Your draft is unchanged.";
+    const family = store.taskFamilyOf(task, [repo], false);
+    const latest = store.runsFor(run.taskRef).find(one => ["builder", "repair", "scout"].includes(one.role) && one.outcome !== null);
+    if (family?.problem !== null || family.current.id !== task || latest?.id !== runId)
+        return "A newer result is current. Open it before commenting on a screenshot. Your draft is unchanged.";
+    const verified = verifyResultImage(store, root, [repo], { taskId: task, ...image });
+    return verified.ok ? null : "This screenshot is unavailable or changed. Restore it or remove it from your feedback. Your draft is unchanged.";
+}
 /** One user action: add the typed change and seal exactly the displayed
  * saved notes. A refusal rolls back the note; a replay returns the same task. */
 export function requestResultChanges(store, evidenceRoot, input, now) {
@@ -15,8 +35,8 @@ export function requestResultChanges(store, evidenceRoot, input, now) {
         return store.transact(() => store.savepoint(() => {
             const fail = (status, message) => { throw new ChangeRequestRefusal(status, message); };
             if (!input.note.trim()) {
-                if (input.path.trim() || input.line.trim())
-                    return fail(400, "Describe the change before attaching a file or line.");
+                if (input.path.trim() || input.line.trim() || input.image != null)
+                    return fail(400, "Describe the change before attaching an image, file or line.");
                 if (!input.batch)
                     return fail(400, "Describe a change or use a saved note.");
                 return createResultRevision(store, evidenceRoot, input, now);
@@ -43,13 +63,19 @@ export function requestResultChanges(store, evidenceRoot, input, now) {
             if (!artifact || !readVerifiedArtifact(evidenceRoot, artifact).ok)
                 return fail(409, "The saved changes could not be verified. Restore the result before requesting changes.");
             const sourceKey = commentSourceKey(input.actor, input.request);
-            let noteId = store.addDiffComment({ artifactId: artifact.id, runId: run.id, path, line, note: valid.note, author: input.actor, sourceKey }, now);
-            if (noteId === null) {
-                const earlier = store.diffCommentBySourceKey(sourceKey);
-                if (!earlier || earlier.run !== run.id || earlier.path !== path || earlier.line !== line || earlier.note !== valid.note)
-                    return fail(409, "This submission already saved different feedback. Reopen the result and try again.");
-                noteId = earlier.id;
+            const earlier = store.diffCommentBySourceKey(sourceKey);
+            if (earlier && (earlier.run !== run.id || earlier.path !== path || earlier.line !== line || earlier.note !== valid.note || !sameFeedbackImage(earlier.image, input.image)))
+                return fail(409, "This submission already saved different feedback. Reopen the result and try again.");
+            // An exact consumed replay only returns its existing revision. Every new
+            // use proves the image before insertion, so malformed targets refuse cleanly.
+            if (earlier?.consumedBy == null) {
+                const problem = feedbackImageProblem(store, evidenceRoot, run.id, input.image);
+                if (problem !== null)
+                    return fail(409, problem);
             }
+            const noteId = earlier?.id ?? store.addDiffComment({ artifactId: artifact.id, runId: run.id, path, line, note: valid.note, author: input.actor, sourceKey, image: input.image ?? null }, now);
+            if (noteId === null)
+                return fail(409, "This feedback changed while saving. Your draft is unchanged; reopen the result.");
             const result = createResultRevision(store, evidenceRoot, { ...input, batch: [...new Set([...batch, noteId])].sort((a, b) => a - b).join(",") }, now);
             if (!result.ok)
                 return fail(result.status, result.message);
@@ -141,6 +167,11 @@ export function createResultRevision(store, evidenceRoot, input, now) {
         }
         if (batch.some(one => !isRevisionFeedback(one)))
             return fail(409, "Review observations are not requested changes. Use Request change to add your feedback first.");
+        for (const one of batch) {
+            const problem = feedbackImageProblem(store, evidenceRoot, id, one.image);
+            if (problem !== null)
+                return fail(409, problem);
+        }
         const comments = batch;
         // Keep the subject recognizable, including when revising a revision.
         // Reserve the suffix before truncating, at whole grapheme boundaries.
@@ -180,6 +211,7 @@ export function createResultRevision(store, evidenceRoot, input, now) {
                 note: one.note,
                 author: one.author,
                 createdAt: one.createdAt,
+                ...(one.image == null ? {} : { image: one.image }),
             })),
         };
         const briefBytes = Buffer.from(JSON.stringify(brief, null, 2), "utf8");

package/dist/result-review.d.ts

@@ -19,6 +19,14 @@
  * selected tab, and the reading position in this tab's sessionStorage,
  * keyed by the server-named account, the task, and the run. */
 import { type ResultFacts, type PublicationFacts, type DisplayStatus } from "./workspace-ui.js";
+/** Optional context for feedback. The sealed diff remains the revision authority. */
+export type FeedbackImage = {
+    run: number;
+    artifact: number;
+    sha256: string;
+};
+export declare function parseFeedbackImage(value: unknown): FeedbackImage | null | false;
+export declare function sameFeedbackImage(a: FeedbackImage | null | undefined, b: FeedbackImage | null | undefined): boolean;
 /** Add re-read evidence health to the existing result/review projection.
  * This is presentation only: the recorded verdict and acceptance stay intact. */
 export declare function evidenceResultStatusOf(result: ResultFacts, publication: PublicationFacts, evidence: EvidenceHealth): DisplayStatus;
@@ -49,6 +57,7 @@ export type ResultScreenshot = {
     path: string;
     caption: string;
     artifactId: number;
+    sha256?: string;
     problem: string | null;
 };
 export type ResultEvidenceInput = {

package/dist/result-review.js

@@ -19,6 +19,26 @@
  * selected tab, and the reading position in this tab's sessionStorage,
  * keyed by the server-named account, the task, and the run. */
 import { resultStatusOf } from "./workspace-ui.js";
+export function parseFeedbackImage(value) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    try {
+        const image = typeof value === "string" ? JSON.parse(value) : value;
+        if (image === null || typeof image !== "object" || Array.isArray(image)
+            || !Number.isSafeInteger(image.run) || image.run < 1
+            || !Number.isSafeInteger(image.artifact) || image.artifact < 1
+            || typeof image.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(image.sha256)
+            || Object.keys(image).some(key => !["run", "artifact", "sha256"].includes(key)))
+            return false;
+        return { run: image.run, artifact: image.artifact, sha256: image.sha256 };
+    }
+    catch {
+        return false;
+    }
+}
+export function sameFeedbackImage(a, b) {
+    return (a == null && b == null) || (a != null && b != null && a.run === b.run && a.artifact === b.artifact && a.sha256 === b.sha256);
+}
 /** Add re-read evidence health to the existing result/review projection.
  * This is presentation only: the recorded verdict and acceptance stay intact. */
 export function evidenceResultStatusOf(result, publication, evidence) {
@@ -155,6 +175,8 @@ export function resultFactsFromHtml(html) {
  * page. Matched exactly — never a bare open redirect. */
 export function resultReturnTarget(raw, runId, tasks = []) {
     if (raw !== null && raw !== undefined) {
+        if (raw === `/r/${runId}?record=1`)
+            return raw;
         const review = /^\/review\?result=[A-Za-z0-9._~%-]{1,200}(?:&run=([0-9]{1,15}))?(?:&tab=(?:summary|changes|checks))?$/.exec(raw);
         if (review !== null && (review[1] === undefined || Number(review[1]) === runId))
             return raw;
@@ -299,6 +321,22 @@ export const RESULT_REVIEW_SCRIPT = String.raw `
   document.addEventListener('click',function(ev){var link=ev.target&&ev.target.closest?ev.target.closest('a[href="#request-changes"]'):null;if(link)openForm();});
   if(form){
     var noteBox=form.querySelector('[name=note]'),pathBox=form.querySelector('[name=path]'),lineBox=form.querySelector('[name=line]'),pin=form.querySelector('details.result-pin');
+    var imageBox=form.querySelector('[name=image]'),imagePreview=form.querySelector('[data-feedback-image]');
+    function showImage(){
+      if(!imageBox||!imagePreview)return;
+      imagePreview.hidden=!imageBox.value;
+      var img=imagePreview.querySelector('img'),caption=imagePreview.querySelector('figcaption'),selected=null;
+      document.querySelectorAll('[data-comment-image]').forEach(function(button){if(button.getAttribute('data-comment-image')===imageBox.value)selected=button;});
+      img.hidden=!selected;
+      if(selected){var identity=JSON.parse(imageBox.value);img.src='/r/'+identity.run+'/evidence/'+identity.artifact;img.alt=selected.getAttribute('data-image-caption');caption.textContent=img.alt+' · Screenshot '+identity.artifact;}
+      else{img.removeAttribute('src');caption.textContent='This screenshot is unavailable. Restore it or remove it from your feedback.';}
+    }
+    document.addEventListener('click',function(event){
+      var button=event.target&&event.target.closest?event.target.closest('[data-comment-image],[data-remove-image]'):null;
+      if(!button||!imageBox)return;
+      event.preventDefault();imageBox.value=button.getAttribute('data-comment-image')||'';showImage();openForm();save();
+      if(noteBox){noteBox.dispatchEvent(new Event('input',{bubbles:true}));noteBox.scrollIntoView({block:'center',behavior:'instant'});noteBox.focus();}
+    });
     var limit=document.getElementById('comment-note-limit'),requestBox=form.querySelector('[name=request]');
     function updateActions(){
       var typed=!!(noteBox&&noteBox.value.trim()),batch=form.querySelector('[name=batch]');
@@ -333,7 +371,7 @@ export const RESULT_REVIEW_SCRIPT = String.raw `
     // A fresh request identity: 16 random bytes as hex, the server's own shape.
     function mint(){var bytes=new Uint8Array(16);try{crypto.getRandomValues(bytes);}catch(e){for(var i=0;i<16;i++)bytes[i]=Math.floor(Math.random()*256);}
       var hex='';for(var j=0;j<16;j++)hex+=(bytes[j]<16?'0':'')+bytes[j].toString(16);return hex;}
-    function payload(){return JSON.stringify([noteBox?noteBox.value:'',pathBox?pathBox.value:'',lineBox?lineBox.value:'']);}
+    function payload(){return JSON.stringify([noteBox?noteBox.value:'',pathBox?pathBox.value:'',lineBox?lineBox.value:'',imageBox?imageBox.value:'']);}
     // What the current token was last submitted with; null = never sent.
     var sent=null,bound=null;
     // The server refused this token for a different note or another result:
@@ -347,7 +385,7 @@ export const RESULT_REVIEW_SCRIPT = String.raw `
       var focusNote=function(){setTimeout(function(){noteBox.focus({preventScroll:true});},0);};
       if(document.readyState==='complete')focusNote();else window.addEventListener('load',focusNote);
     }
-    if(saved&&typeof saved.note==='string'&&saved.note.length<=2000){
+    if(saved&&typeof saved.note==='string'&&saved.note.length<=(noteBox?noteBox.maxLength:4000)){
       if(noteBox&&!noteBox.value)noteBox.value=saved.note;
       if(saved.note)openForm();
       if(pathBox&&!pathBox.value&&typeof saved.path==='string')pathBox.value=saved.path;
@@ -355,7 +393,9 @@ export const RESULT_REVIEW_SCRIPT = String.raw `
       if(pin&&(pathBox&&pathBox.value||lineBox&&lineBox.value))pin.open=true;
       if(typeof saved.request==='string'&&/^[a-f0-9]{32}$/.test(saved.request)&&requestBox)requestBox.value=saved.request;
       if(typeof saved.sent==='string')sent=saved.sent;
-      bound=JSON.stringify([saved.note,saved.path||'',saved.line||'']);
+      if(imageBox&&typeof saved.image==='string'&&saved.image.length<250)imageBox.value=saved.image;
+      showImage();
+      bound=JSON.stringify([saved.note,saved.path||'',saved.line||'',saved.image||'']);
       if(noteBox)noteBox.dispatchEvent(new Event('input'));
     }
     function save(){
@@ -365,8 +405,8 @@ export const RESULT_REVIEW_SCRIPT = String.raw `
       var current=payload();
       if((bound!==null&&current!==bound)||(sent!==null&&current!==sent)){sent=null;if(requestBox)requestBox.value=mint();}
       bound=current;
-      if(!note&&!path&&!line){write(draftKey,null);return;}
-      write(draftKey,{note:note,path:path,line:line,request:requestBox?requestBox.value:'',sent:sent,at:Date.now()});
+      if(!note&&!path&&!line&&!(imageBox&&imageBox.value)){write(draftKey,null);return;}
+      write(draftKey,{note:note,path:path,line:line,image:imageBox?imageBox.value:'',request:requestBox?requestBox.value:'',sent:sent,at:Date.now()});
       if(!storage&&limit)limit.textContent='Draft stays on this page only. Browser storage is unavailable.';
     }
     form.addEventListener('input',save);

package/dist/server/console.css

@@ -2730,3 +2730,15 @@ html.so-swap::view-transition-old(*):only-child { animation: so-card-out 160ms e
   html.so-swap::view-transition-group(*), html.so-swap::view-transition-new(*), html.so-swap::view-transition-old(*) { animation: none !important; }
   .worker.flash { animation: none; }
 }
+
+/* Exact-image feedback shares the existing comment form. */
+.result-image { margin: 0; min-width: 0; }
+.result-image > button { margin-top: .5rem; min-height: 44px; white-space: nowrap; }
+.feedback-image { display: flex; align-items: center; flex-wrap: wrap; gap: .75rem; margin: .5rem 0; min-width: 0; }
+.feedback-image[hidden], .feedback-image img[hidden] { display: none; }
+.feedback-image img { width: 5rem; max-height: 5rem; object-fit: contain; border: 1px solid var(--border); border-radius: var(--radius); }
+.feedback-image figcaption { flex: 1 1 12rem; overflow-wrap: anywhere; font-size: .875rem; }
+.feedback-image button { min-height: 44px; white-space: nowrap; }
+
+.result-feedback-actions { display: flex; flex-wrap: wrap; gap: .5rem; }
+.result-feedback-actions button { min-height: 44px; white-space: nowrap; }

package/dist/server/pages.js

@@ -1,3 +1,4 @@
+import { projectOutcomes } from '../project-outcomes.js';
 import { steerControlsFor } from "../steer-controls.js";
 import { canReveal, cdCommandOf, localCheckoutOf } from "../checkout-proof.js";
 import { instanceHttpAnswer } from "../console-instance.js";
@@ -967,7 +968,16 @@ export function createPagesHandlers(runtime) {
             peeks[one.path] = peekOf(one.path);
         for (const path of candidates)
             peeks[path] = peekOf(path);
-        return sendScreen(response, status, projectsPage(chromeFor(open, "projects"), recent, [...candidates], open, problem, !restricted() && unscopedMode, !restricted() && (ceiling.roots.length > 0 || unscopedMode), onboardState, peeks, returnTo, who.via === "cookie" ? (path) => publishingOf(store, path).on : undefined, who.via === "cookie" ? (path) => projectCheckLevel(store, path).level : undefined));
+        let activity;
+        if (open !== null && !returnTo.startsWith("/tasks/new") && visible(open) && store.accountCanAccess(who.name, open)) {
+            try {
+                activity = { project: projectName(open), report: projectOutcomes(store, open, now, { principal: 'operator', repos: [open] }) };
+            }
+            catch {
+                activity = { project: projectName(open), report: null };
+            }
+        }
+        return sendScreen(response, status, projectsPage(chromeFor(open, "projects"), recent, [...candidates], open, problem, !restricted() && unscopedMode, !restricted() && (ceiling.roots.length > 0 || unscopedMode), onboardState, peeks, returnTo, who.via === "cookie" ? (path) => publishingOf(store, path).on : undefined, who.via === "cookie" ? (path) => projectCheckLevel(store, path).level : undefined, activity));
     }
     async function instanceEdge(ctx) {
         const { request, response, url } = ctx;