toolroll 0.9.84 → 0.9.86

package/dist/work-index.js

@@ -22,10 +22,12 @@ import { ASKS, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, processNeedOf,
 import { LEAD_CLAIM_SQL, LEAD_IDLE_MS } from './lead-voice.js';
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
-const EMPTY = { all: 0, 'needs-you': 0, running: 0, completed: 0 };
+const EMPTY = { all: 0, 'needs-you': 0, running: 0, completed: 0, archived: 0 };
 const NO_GROUPS = { decide: 0, review: 0, unblock: 0, building: 0, rest: 0 };
 const FAMILY_PROBLEM = 'Task history is unavailable or incomplete. This task is shown separately.';
-const VIEWS = ['all', 'needs-you', 'running', 'completed'];
+const VIEWS = ['all', 'needs-you', 'running', 'completed', 'archived'];
+/** The family's current version is put away (v145): it waits on nobody and only the Archived view lists it. */
+const ARCHIVED = `EXISTS(SELECT 1 FROM task_archive ta WHERE ta.task_ref=c.ref_id)`;
 const n = (row, key) => Number(row[key] ?? 0);
 const s = (row, key) => row[key] == null ? null : String(row[key]);
 /** The running agent's oldest open question (agent-board.ts), from its open newest attempt only. */
@@ -93,24 +95,25 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     (SELECT id FROM run WHERE task_ref=a.ref_id AND outcome IS NULL ORDER BY id DESC LIMIT 1) unfinished,
     CASE WHEN a.state='done' THEN (SELECT id FROM run WHERE task_ref=a.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1) END result_id,
     (SELECT h.id FROM hold h WHERE h.task_ref=a.ref_id AND (h.until IS NULL OR h.until>$now) ORDER BY h.held_at,h.id LIMIT 1) hold_id,
-    q.decision_id,${AGENT_ASK} agent_ask,(cu.task_ref IS NOT NULL OR a.ref_id IN (SELECT value FROM json_each($workspaceCustody)))
+    q.decision_id,${AGENT_ASK} agent_ask,EXISTS(SELECT 1 FROM task_archive ta WHERE ta.task_ref=a.ref_id) member_archived,(cu.task_ref IS NOT NULL OR a.ref_id IN (SELECT value FROM json_each($workspaceCustody)))
       AND a.ref_id NOT IN (SELECT value FROM json_each($settledCustody)) custody_unresolved
   FROM admitted a LEFT JOIN lineage l ON l.ref_id=a.ref_id
   LEFT JOIN questions q ON q.task_ref=a.ref_id LEFT JOIN custody cu ON cu.task_ref=a.ref_id
 ), family_heads AS MATERIALIZED (
   SELECT root_ref,COUNT(*) version_count,MAX(updated_at) family_updated,
     CAST(substr(MAX((CASE WHEN ref_id=root_ref THEN '0' ELSE '1' END)||created_at||printf('%020d',ref_id)),-20) AS INTEGER) current_ref,
-    SUM(state IN ('queued','running') OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved) active_count,
-    MIN(CASE WHEN state IN ('queued','running') OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved THEN ref_id END) first_active,
-    MAX(CASE WHEN state IN ('queued','running') OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved THEN ref_id END) last_active,
-    MAX(live_lease IS NOT NULL) family_running,MIN(decision_id) question_id
+    -- A put-away version (v145) is history: it never counts as an earlier active version or brings its question along.
+    SUM(NOT member_archived AND (state IN ('queued','running') OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved)) active_count,
+    MIN(CASE WHEN NOT member_archived AND (state IN ('queued','running') OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved) THEN ref_id END) first_active,
+    MAX(CASE WHEN NOT member_archived AND (state IN ('queued','running') OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved) THEN ref_id END) last_active,
+    MAX(live_lease IS NOT NULL) family_running,MIN(CASE WHEN NOT member_archived THEN decision_id END) question_id
   FROM members GROUP BY root_ref
 ), ordered AS MATERIALIZED (
   SELECT m.*,CASE WHEN m.ref_id=f.current_ref THEN 1 ELSE 2 END version_rank
   FROM members m JOIN family_heads f USING(root_ref)
 ), families AS MATERIALIZED (
   SELECT f.root_ref,f.version_count,f.family_updated,f.family_running,
-    f.active_count-(c.state IN ('queued','running') OR c.live_lease IS NOT NULL OR c.unfinished IS NOT NULL OR c.custody_unresolved) earlier_active,
+    f.active_count-(NOT c.member_archived AND (c.state IN ('queued','running') OR c.live_lease IS NOT NULL OR c.unfinished IS NOT NULL OR c.custody_unresolved)) earlier_active,
     earlier.id earlier_id,COALESCE(c.decision_id,f.question_id) question_id
   FROM family_heads f JOIN members c ON c.ref_id=f.current_ref
   LEFT JOIN admitted earlier ON earlier.ref_id=CASE WHEN f.first_active=f.current_ref THEN f.last_active ELSE f.first_active END
@@ -236,8 +239,9 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   SELECT c.*,CASE WHEN code IN ('cancelled','complete') THEN 0 ELSE ${LEAD_CLAIM_SQL} END lead_claim FROM classified c
 ), ranked AS MATERIALIZED (
   -- A task the person's lead is on (lead-voice.ts) waits on nobody: it leaves Needs you until the claim ends or lapses.
-  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} AND lead_claim<>1 needs,
-    code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} person_need,
+  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} AND lead_claim<>1 AND NOT ${ARCHIVED} needs,
+    code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} AND NOT ${ARCHIVED} person_need,
+    ${ARCHIVED} archived,
     CASE WHEN code='complete' THEN 3 WHEN code='cancelled' THEN 4 WHEN code='running' THEN 1
       WHEN ${CUSTODY_WAITS} OR code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
     ${ASK_RANK} ask_rank,
@@ -329,11 +333,13 @@ function parameters(now, access, options, custody) {
         $leadOf: access.principal === 'operator' && access.viewer != null && access.viewer !== '' ? `lead for ${access.viewer}` : null };
 }
 function counts(row) {
-    return { all: n(row, 'all_count'), 'needs-you': n(row, 'needs_count'), running: n(row, 'running_count'), completed: n(row, 'completed_count') };
+    return { all: n(row, 'all_count'), 'needs-you': n(row, 'needs_count'), running: n(row, 'running_count'), completed: n(row, 'completed_count'), archived: n(row, 'archived_count') };
 }
-const TOTALS = `COUNT(*) all_count,COALESCE(SUM(needs),0) needs_count,COALESCE(SUM(family_running),0) running_count,COALESCE(SUM(code='complete'),0) completed_count`;
-const GROUP_TOTALS = `COALESCE(SUM(rank=0 AND ask_rank=0),0) decide_count,COALESCE(SUM(rank=0 AND ask_rank=1),0) review_count,COALESCE(SUM(rank=0 AND ask_rank=2),0) unblock_count,`
-    + `COALESCE(SUM(rank=1),0) building_count,COALESCE(SUM(rank>1),0) rest_count`;
+// Put-away families (v145) count only as archived.
+const TOTALS = `COALESCE(SUM(archived=0),0) all_count,COALESCE(SUM(needs),0) needs_count,COALESCE(SUM(family_running AND archived=0),0) running_count,`
+    + `COALESCE(SUM(code='complete' AND archived=0),0) completed_count,COALESCE(SUM(archived),0) archived_count`;
+const GROUP_TOTALS = `COALESCE(SUM(rank=0 AND ask_rank=0 AND archived=0),0) decide_count,COALESCE(SUM(rank=0 AND ask_rank=1 AND archived=0),0) review_count,COALESCE(SUM(rank=0 AND ask_rank=2 AND archived=0),0) unblock_count,`
+    + `COALESCE(SUM(rank=1 AND archived=0),0) building_count,COALESCE(SUM(rank>1 AND archived=0),0) rest_count`;
 function groupCounts(row) {
     return { decide: n(row, 'decide_count'), review: n(row, 'review_count'), unblock: n(row, 'unblock_count'), building: n(row, 'building_count'), rest: n(row, 'rest_count') };
 }
@@ -383,18 +389,20 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     const view = VIEWS.includes(options.view ?? 'all') ? options.view ?? 'all' : 'all';
     const limit = Number.isFinite(options.limit) ? Math.max(1, Math.min(WORK_INDEX_MAX_LIMIT, Math.floor(options.limit))) : WORK_INDEX_PAGE_LIMIT;
     const scope = cursorScope(access, options, view), cursor = readCursor(options.cursor, scope);
-    const filter = view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1' : view === 'completed' ? "code='complete'" : '1';
+    const filter = view === 'archived' ? 'archived=1' : view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1 AND archived=0' : view === 'completed' ? "code='complete' AND archived=0" : 'archived=0';
     const rows = prepared(store, `${projection}, selected_page AS MATERIALIZED (
-    SELECT * FROM ranked WHERE ${filter} AND ($taskId IS NULL OR root_ref IN (SELECT root_ref FROM members WHERE id=$taskId)) AND ($roots IS NULL OR root_id IN (SELECT value FROM json_each($roots))) AND ($cursorRoot=0 OR
+    SELECT * FROM ranked WHERE ($taskId IS NOT NULL OR ${filter}) AND ($taskId IS NULL OR root_ref IN (SELECT root_ref FROM members WHERE id=$taskId)) AND ($roots IS NULL OR root_id IN (SELECT value FROM json_each($roots))) AND ($cursorRoot=0 OR
       ${ORDER}>$cursorRank OR (${ORDER}=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
     ORDER BY ${ORDER},sort_at DESC,root_ref DESC LIMIT $limit
   ), page AS (SELECT p.*,COALESCE(p.result_id,(SELECT id FROM run WHERE task_ref=p.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1)) page_result_id FROM selected_page p), totals AS (SELECT ${TOTALS},${GROUP_TOTALS} FROM ranked), project_totals AS (
-    SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0) queued,
-      SUM(state='done' AND family_running=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo
+    SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0 AND archived=0) queued,
+      SUM(state='done' AND family_running=0 AND archived=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo
   )
   SELECT 0 record_kind,totals.*,(SELECT json_group_array(json_object('repo',repo,'all_count',all_count,'needs_count',needs_count,
-    'running_count',running_count,'completed_count',completed_count,'queued',queued,'done_recently',done_recently)) FROM project_totals) row_json FROM totals
-  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,json_object('root_ref',root_ref,'root_id',root_id,'id',id,'root_title',root_title,'repo',repo,
+    'running_count',running_count,'completed_count',completed_count,'archived_count',archived_count,'queued',queued,'done_recently',done_recently)) FROM project_totals) row_json FROM totals
+  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,0,json_object('archived',archived,'archived_by',(SELECT by FROM task_archive WHERE task_ref=page.ref_id),
+    'archived_kind',(SELECT by_kind FROM task_archive WHERE task_ref=page.ref_id),'archived_reason',(SELECT reason FROM task_archive WHERE task_ref=page.ref_id),
+    'archived_at',(SELECT at FROM task_archive WHERE task_ref=page.ref_id),'root_ref',root_ref,'root_id',root_id,'id',id,'root_title',root_title,'repo',repo,
     'state',state,'created_at',created_at,'family_updated',family_updated,'version_count',version_count,'earlier_active',earlier_active,
     'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),'attempt_reason',(SELECT substr(reason,1,1000) FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
@@ -434,8 +442,8 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
 }
 export function workCountsByProject(store, now, access) {
     const projection = registerValidators(store);
-    return store.handle.prepare(`${projection} SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0) queued,
-    SUM(state='done' AND family_running=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo ORDER BY repo`)
+    return store.handle.prepare(`${projection} SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0 AND archived=0) queued,
+    SUM(state='done' AND family_running=0 AND archived=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo ORDER BY repo`)
         .all({ ...parameters(now, access, {}, custodyReadings(store)), $recent: new Date(now.getTime() - 86_400_000).toISOString() })
         .map(row => ({ repo: s(row, 'repo'), totals: counts(row), queued: n(row, 'queued'), doneRecently: n(row, 'done_recently') }));
 }
@@ -447,12 +455,44 @@ export function workStateRows(store, now, access) {
         COALESCE((SELECT created_at FROM decision WHERE id=question_id),''),COALESCE((SELECT asked_at FROM agent_question WHERE id=agent_ask),''),
         COALESCE((SELECT held_at FROM hold WHERE id=hold_id),''),COALESCE((SELECT requested_at FROM run_stop WHERE run=stop_run),'')),''),sort_at) ask_at,
       COALESCE(live_run,(SELECT run FROM decision WHERE id=question_id),(SELECT run FROM agent_question WHERE id=agent_ask)) ask_run,
-      (SELECT json_group_array(m.ref_id) FROM members m WHERE m.root_ref=ranked.root_ref) members FROM ranked`)
+      (SELECT json_group_array(m.ref_id) FROM members m WHERE m.root_ref=ranked.root_ref) members FROM ranked WHERE archived=0`)
         .all(parameters(now, access, {}, custodyReadings(store)))
         .map(row => ({ repo: s(row, 'repo'), rootId: String(row['root_id']), code: String(row['code']), needs: n(row, 'needs') === 1, personNeed: n(row, 'person_need') === 1,
         leadClaim: n(row, 'lead_claim') === 1, liveRun: row['live_run'] == null ? null : n(row, 'live_run'), unfinished: row['unfinished'] == null ? null : n(row, 'unfinished'),
         resultRun: row['result_id'] == null ? null : n(row, 'result_id'), waits: Number(row['rank']) === 2, version: String(row['version']), at: String(row['ask_at'] ?? ''), askRun: row['ask_run'] == null ? null : n(row, 'ask_run'), members: JSON.parse(String(row['members'] ?? '[]')).map(Number) }));
 }
+/** Activity uses the Tasks list's exact family admission and saved completion rules.
+ * Only the requested project enters the projection. The extra row signals truncation;
+ * attempts are aggregated in SQLite, never loaded as an unbounded history. */
+export function workOutcomeRows(store, now, access, project, since, limit) {
+    return store.handle.prepare(`${registerValidators(store)}, selected AS MATERIALIZED (
+    SELECT * FROM ranked WHERE archived=0 AND (code='ready-to-check' OR code='history-problem'
+      OR (code='complete' AND checked_at >= $since AND checked_at <= $now))
+    ORDER BY sort_at DESC,root_ref DESC LIMIT $outcomeLimit
+  ), amounts AS (
+    -- reported-usage.ts runAmountOf, row for row: only evidenced billing on a run whose cost was reported is known;
+    -- an API run counts its priced spend as dollars (a safe integer), a subscription run its reported cost as usage,
+    -- never dollars. TOTAL sums as a float, so no family's sum can overflow.
+    SELECT m.root_ref,r.cost_usd,s.microusd,
+      CASE WHEN r.billing_basis IS NOT 'evidence' OR COALESCE(r.cost_unknown,1)<>0 THEN 'unknown'
+        WHEN s.billing='subscription' THEN 'subscription'
+        WHEN s.billing='api-key' AND typeof(s.microusd)='integer' AND s.microusd>=0 AND s.microusd<=9007199254740991 THEN 'api'
+        ELSE 'unknown' END amount
+    FROM selected f JOIN members m ON m.root_ref=f.root_ref JOIN run r ON r.task_ref=m.ref_id LEFT JOIN run_spend s ON s.run=r.id
+  ), attempts AS (
+    SELECT root_ref,COUNT(*) runs,COUNT(CASE WHEN amount='api' THEN 1 END) api_runs,
+      TOTAL(CASE WHEN amount='api' THEN microusd END) api_microusd,
+      COUNT(CASE WHEN amount='subscription' THEN 1 END) subscription_runs,
+      SUM(CASE WHEN amount='subscription' AND typeof(cost_usd) IN ('integer','real') AND cost_usd>=0 THEN cost_usd END) subscription_usd
+    FROM amounts GROUP BY root_ref
+  ) SELECT f.root_id,f.id task_id,f.root_title title,f.code,f.finished_at,f.result_id,f.result_role,
+    f.version_count,f.checked_at,f.checked_actor,f.checked_detail,
+    (SELECT lead FROM task_act WHERE task_ref=f.root_ref AND act='completed' AND at=f.checked_at ORDER BY id DESC LIMIT 1) completed_by_lead,
+    (SELECT status FROM run_check WHERE run=f.result_id) check_status,
+    COALESCE(a.runs,0) runs,COALESCE(a.api_runs,0) api_runs,a.api_microusd,COALESCE(a.subscription_runs,0) subscription_runs,a.subscription_usd
+    FROM selected f LEFT JOIN attempts a ON a.root_ref=f.root_ref ORDER BY f.sort_at DESC,f.root_ref DESC`)
+        .all({ ...parameters(now, access, { project }, custodyReadings(store)), $since: since, $outcomeLimit: limit + 1 });
+}
 /** Families whose headline is Ready for review, newest first: the Tasks
  * list's own rows, so a completed family (root or any revision), a failed
  * check and a superseded version never count. */
@@ -669,12 +709,14 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
         if (asked !== null)
             detail = `The agent asks: ${asked}`;
     }
-    const views = ['all'];
-    if (need)
+    const archived = n(row, 'archived') === 1 ? { by: String(row['archived_by'] ?? ''), byKind: row['archived_kind'] === 'tidy' ? 'tidy' : 'person',
+        reason: String(row['archived_reason'] ?? ''), at: String(row['archived_at'] ?? '') } : null;
+    const views = archived !== null ? ['archived'] : ['all'];
+    if (archived === null && need)
         views.push('needs-you');
-    if (running)
+    if (archived === null && running)
         views.push('running');
-    if (code === 'complete')
+    if (archived === null && code === 'complete')
         views.push('completed');
     return { rootId: String(row['root_id']), activeTaskId: id, title: String(row['root_title']), repo: s(row, 'repo'),
         state: String(row['state']), assignmentState, createdAt: String(row['created_at']), updatedAt: String(row['sort_at']),
@@ -686,5 +728,17 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
         ask: need ? ASKS[n(row, 'ask_rank')] ?? 'unblock' : null,
         chip: need ? askChipOf({ headline: shared.headline, need: shared.need?.key ?? null, planChanged, mismatch: verdict === 'refuted' && n(row, 'proof_failed_check') !== 1, ask: ASKS[n(row, 'ask_rank')] ?? 'unblock' }) : null,
         primaryAction, completion: code === 'complete' ? { actor: String(row['checked_actor']), at: String(row['checked_at']), digest: String(row['checked_digest']), ...(landed === null ? {} : { landed }) } : null,
-        evidence: 'recorded', ...(lead === 'on-it' ? { lead: leadOnIt(leadName) } : {}) };
+        evidence: 'recorded', ...(lead === 'on-it' ? { lead: leadOnIt(leadName) } : {}), ...(archived === null ? {} : { archived }) };
+}
+export function workTidyRows(store, now, access) {
+    const projection = registerValidators(store);
+    return store.handle.prepare(`${projection} SELECT root_id,id,root_title,repo,state,code,archived,broken,family_updated,
+      (family_running OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved OR stop_run IS NOT NULL AND stop_settled IS NULL OR state='running') live,
+      (SELECT json_group_array(m.ref_id) FROM members m WHERE m.root_ref=ranked.root_ref) members,
+      (SELECT json_group_array(m.id) FROM members m WHERE m.root_ref=ranked.root_ref) member_ids FROM ranked`)
+        .all(parameters(now, access, {}, custodyReadings(store)))
+        .map(row => ({ rootId: String(row['root_id']), currentId: String(row['id']), title: String(row['root_title']), repo: s(row, 'repo'),
+        state: String(row['state']), code: String(row['code']), live: n(row, 'live') === 1, archived: n(row, 'archived') === 1, broken: n(row, 'broken') === 1,
+        updatedAt: String(row['family_updated'] ?? ''), members: JSON.parse(String(row['members'] ?? '[]')).map(Number),
+        memberIds: JSON.parse(String(row['member_ids'] ?? '[]')).map(String) }));
 }

package/dist/workspace-ui.d.ts

@@ -26,7 +26,7 @@ import { type ChecksFact } from "./task-status.js";
 import { type Html } from "./html.js";
 /** The Work destination's views — shortcuts over the same rows, never a
  * persisted state. All is the default. */
-export type WorkView = "all" | "needs-you" | "running" | "completed";
+export type WorkView = "all" | "needs-you" | "running" | "completed" | "archived";
 export declare const WORK_VIEWS: readonly {
     key: WorkView;
     label: string;

package/dist/workspace-ui.js

@@ -27,9 +27,10 @@ export const WORK_VIEWS = [
     { 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: "Building", 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." },
+    { key: "archived", label: "Archived", hint: "Tasks put away by you or by tidy. Their history and results are kept.", empty: "Nothing is put away." },
 ];
 export function parseWorkView(raw) {
-    return raw === "needs-you" || raw === "running" || raw === "completed" ? raw : "all";
+    return raw === "needs-you" || raw === "running" || raw === "completed" || raw === "archived" ? raw : "all";
 }
 /** The review facts from the store's bounded retry projection — the same
  * reading `diagnoseTaskDispatch` makes, so every surface starts from one
@@ -525,7 +526,7 @@ function workStatusWordsOf(facts, resultDisplay) {
 }
 /** 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 };
+    const counts = { all: 0, "needs-you": 0, running: 0, completed: 0, archived: 0 };
     for (const row of rows)
         for (const view of row.views)
             counts[view] += 1;

package/dist/youiyoux-intake.d.ts

@@ -0,0 +1,234 @@
+/**
+ * youiyoux change and options requests become tasks (docs/guide/getting-started.md, "Change requests from youiyoux").
+ *
+ * youiyoux is a design-system tool: in its hub a person points at a component on a screenshot of their app and asks
+ * for a change, and it saves the request as `<project>/.youi/requests/<id>.json` (`youi.request/v1`). A project that
+ * uses youiyoux (a `youi.project.json` at its root, or a `.youi/requests` folder) has this intake on with no step of
+ * its own, unless a person turned it off in Settings → Integrations.
+ *
+ * On the worker's flow pass this reads the project's main checkout — the path from Toolroll's own records, resolved
+ * with realpath — and files each open change request with a task exactly once, keyed by the project and the request
+ * id in `youiyoux_request`: never again, whatever the file says later. Everything in the folder is outside text,
+ * written by whoever can write the project's folder:
+ *
+ * - the folders and files must be real (never a link), a file a single link to itself, at most 64 KB, read without
+ *   following a link or waiting on a pipe, and at most 200 are read in one pass;
+ * - a file whose name, schema or id is wrong is counted (the integration says so) and never filed;
+ * - text that looks like a key or password is left out (recorded once, never filed), as flow triggers do;
+ * - a path the task may touch is kept only when youiyoux knew them all and every one is a plain relative path;
+ * - the task is filed through the one filing door (proposal.ts) by the "youiyoux" automation, unplanned, and waits
+ *   for a person: its provenance (`filed_via = 'youiyoux'`) keeps every seal no person looked at off it (store.ts,
+ *   the outside-request quarantine), so no operating mode, grant, schedule or automatic seal approves it. A person
+ *   approves it in Toolroll, or with their own two taps in their paired chat where they turned approving from chat
+ *   on (chat-decide.ts), bound to the exact scope the card showed.
+ *
+ * Beside each request it writes `<id>.task.json` (`youi.request-task/v1`): the task and its status, and, when the
+ * console has an address (the one the installation names, else this machine's own console where `up` serves it, on
+ * loopback), the task's link and `home`, where a person approves all waiting work. It is written when filed, whenever
+ * the status changes, and once more when that address changes. Beside an options request's options file (below), it is
+ * the only file it writes in the checkout: written whole (a temporary file in the same folder, then renamed over),
+ * refused when the folder or the target is a link, never the request itself. The status is also kept in the store;
+ * nothing Toolroll decides reads the file back.
+ *
+ * Status words (task-status.ts headline → youiyoux): Queued → queued; Planning, Building and Waiting (work going on
+ * by itself) → building; Needs you → needs-you; Ready for review → ready; Complete → done; Failed → failed;
+ * Stopped → stopped.
+ *
+ * An options request (`kind: "options"`) asks an agent for two to four options for one component, which youiyoux shows
+ * on its Screens canvas. It is filed the same way, once, waiting for a person, and only as youiyoux's contract has it:
+ * its offer names `p-<its own hex>`, that proposal's file `.youi/proposals/p-<hex>.json`, and the task may touch that
+ * one file (anything else is counted as a file that couldn't be read, and never filed). The proposal it names is kept
+ * when filed; the request is never read for it again. Then (runYouiyoux, the worker's pass):
+ *
+ * - When the task is Ready for review (or Complete), its result is read: the file at the result's commit, the commit
+ *   Toolroll recorded for the build (never the checkout the agent had, which it controls and the pool hands on), read
+ *   with the hardened git (teardown-git.ts). It must be a plain file in that commit (never a link), at most 64 KB, a
+ *   `youi.proposal/v1` file whose id is the proposal, which answers this request, still open (an agent proposes; only a
+ *   person decides), by an agent, with no key-like text. Then it is copied, byte for byte, into the project's main
+ *   checkout as `.youi/proposals/<id>.json` the way the status file is written (folders real, never through a link;
+ *   a temporary file, then linked into place, which never replaces a file already there: a person may have decided on
+ *   it). A file missing from the result, or one that isn't safe, is said in the status file and never copied; a newer
+ *   result is read again.
+ * - Only a file Toolroll copied is read for a decision: one already at that name is left as it was (a person may
+ *   have decided on it) and never read for one, unless it is byte for byte the result's (an earlier pass's copy).
+ * - When that copy says a person chose an option or dismissed them all (youiyoux's hub writes that), and it is still
+ *   the proposal copied (only its status, choice, decidedBy, decidedAt, request and updatedAt may differ), decided by
+ *   a person, at a time, the task is marked complete by Toolroll, as landed work is (result-completion.ts LANDED_ACTOR), without
+ *   merging or publishing its branch: its deliverable was the options, and youiyoux has used them. Only the exact
+ *   result whose file was copied, and only through every guard a person's completion passes (landed-cleanup.ts
+ *   completionProblem): otherwise it stays Ready for review and the ledger says why. The ledger keeps who decided
+ *   what, as youiyoux wrote it (outside text, cleaned). A decision never approves, publishes or merges anything.
+ */
+import type { Store } from "./store.js";
+import type { Headline } from "./task-status.js";
+import { type Git } from "./landed-cleanup.js";
+import { YOUIYOUX_FILED_VIA, type YouiyouxRequest, type YouiyouxRequestTask, type YouiyouxTaskStatus } from "./contracts/youiyoux-request.js";
+export { YOUIYOUX_FILED_VIA };
+/** Who files the tasks: an automation, like a flow trigger. */
+export declare const YOUIYOUX_ACTOR = "youiyoux";
+export declare const REQUEST_BYTES: number;
+export declare const REQUESTS_PER_PASS = 200;
+export declare const FILED_PER_PASS = 10;
+/** The ledger's word for a decision youiyoux's hub made on a task's options. */
+export declare const OPTIONS_DECIDED_ACTION = "youiyoux options decided";
+export declare const OPTIONS_COPIED_ACTION = "youiyoux options copied";
+/** The flow pass runs every 15 seconds; the folder is read at most this often. */
+export declare const INTAKE_EVERY_MS = 30000;
+export declare const STATUS_OF_HEADLINE: Readonly<Record<Headline, YouiyouxTaskStatus>>;
+/** Whether a project uses youiyoux: a `youi.project.json` at its root, or a `.youi` folder. Only their presence is
+ * read here (a link counts, so the integration can say it is Broken); requestsFolder decides what may be read. */
+export declare function usesYouiyoux(repo: string): boolean;
+/** The paths a request may touch: every one a plain relative path inside the project, or none at all. */
+export declare function safeTouches(touches: readonly string[]): string[] | null;
+export type RequestTask = {
+    title: string;
+    goal: string;
+    outOfScope: string | null;
+    touches: string[];
+    acceptance: {
+        id: string;
+        statement: string;
+        how: null;
+        evidence: string[];
+    }[];
+    /** Where the person pointed, for the task page: the route, the component, and `file:line` when youiyoux knew a plain one. */
+    pointed: {
+        route: string;
+        component: string;
+        at: string | null;
+    };
+};
+/** The task a request asks for, in Toolroll's terms. Text is cleaned here; whether it may be filed is decided by the caller. */
+export declare function requestTask(request: YouiyouxRequest): RequestTask;
+/** A person turns the intake off or back on for a project; the ledger keeps who. */
+export declare function setYouiyouxIntake(store: Store, repo: string, on: boolean, by: string, now: Date): void;
+export type YouiyouxState = {
+    /** The project uses youiyoux, as the worker's last pass found. */
+    uses: boolean;
+    /** Requests become tasks: it uses youiyoux and nobody turned it off. */
+    on: boolean;
+    /** A person turned it off. */
+    off: boolean;
+    /** Filed tasks not yet done, failed or stopped. */
+    queued: number;
+    filed: number;
+    invalid: number;
+    problem: string | null;
+    checkedAt: string | null;
+};
+/** How the intake stands for one project, from the store alone: a page reads it on every render, so it never reads the
+ * project's folder (one that doesn't answer must not hold the console). Whether it uses youiyoux is the last pass's. */
+export declare function youiyouxState(store: Store, repo: string): YouiyouxState;
+/** The one line `toolroll onboard` says for a project that uses youiyoux; null when it doesn't. */
+export declare function youiyouxOnboardLine(store: Store, repo: string): string | null;
+/** The console the links name: the address the installation names (CONSOLE_URL or the console-url file), else, with
+ * none named, this machine's own console where `up` serves it (loopback http only, never a guessed host); null without
+ * either. Either way http(s) with no credentials, query or fragment. */
+export declare function consoleBase(env: Record<string, string | undefined>, dir: string | null): string | null;
+/** The task's page in that console; null without one. */
+export declare function taskLink(env: Record<string, string | undefined>, dir: string | null, taskId: string): string | null;
+/**
+ * Write `<id>.task.json` beside its request, whole. The folders are checked again now (a link is refused), the request
+ * must still be a plain file, the target must be a plain file or absent, and the content goes to a fresh temporary file
+ * in the same folder (created exclusively, never through a link) that is then renamed over the target.
+ */
+export declare function writeStatusFile(repo: string, body: YouiyouxRequestTask): {
+    ok: true;
+} | {
+    ok: false;
+    problem: string;
+};
+/**
+ * Put an options file into the project's main checkout as `.youi/proposals/<id>.json`, whole, and never over a file
+ * already there (a person may have decided on it). The folders are checked as the status file's are (`.youi/proposals`
+ * is made, as a real folder, when missing), the content goes to a fresh temporary file in the same folder (created
+ * exclusively, never through a link), the folders are checked again, and the temporary file is linked into place, which
+ * fails rather than replace anything at that name, a link included. `same`: that exact content was already there;
+ * `taken`: something else was, and is left as it was.
+ */
+export declare function writeProposalFile(repo: string, id: string, text: string): {
+    ok: true;
+    made: "written" | "same" | "taken";
+} | {
+    ok: false;
+    problem: string;
+};
+/** `git`: the hardened git an options request's result is read with (landed-cleanup.ts gitOf), and `evidenceRoot`, where
+ * results' saved evidence is (a completion is bound to the receipt read with it). Without either, options wait. */
+export type YouiyouxIo = {
+    dir: string | null;
+    env: Record<string, string | undefined>;
+    git?: Git;
+    evidenceRoot?: string | null;
+};
+/** `copied`: options files that went to the hub; `decided`: decisions in the hub Toolroll acted on. */
+export type YouiyouxPass = {
+    filed: number;
+    skipped: number;
+    invalid: number;
+    updated: number;
+    copied: number;
+    decided: number;
+    problems: string[];
+};
+export declare const NO_YOUIYOUX_PASS: Readonly<YouiyouxPass>;
+/** File one request's task, exactly once: the claim and the filing are one transaction (two passes, in two processes
+ * or one, make one task). */
+export declare function fileYouiyouxRequest(store: Store, repo: string, request: YouiyouxRequest, now: Date): {
+    made: "filed";
+    taskId: string;
+} | {
+    made: "seen";
+} | {
+    made: "skipped";
+    note: string;
+};
+/**
+ * One message for what a pass filed, however many: the person's paired chats draw it as one card (chat-decide.ts) that
+ * lists each new task, with Approve all and each one's own Approve and Open, and a phone push links to what needs
+ * them. Keyed by the pass's first task, so a pass says it once; the tasks are the ones filed with it (one project, one
+ * moment: requestPassOf). Titles are cleaned outside text, as filed.
+ */
+export declare function noteYouiyouxFiled(store: Store, taskIds: readonly string[], now: Date): void;
+/** What a pass's tasks were asked for, in a word: "change request", "options request", or "request" for both. */
+export declare function requestKindWord(store: Store, taskIds: readonly string[]): string;
+/** The tasks one pass filed beside this one (one project, one moment), in request order; empty for any other task. */
+export declare function requestPassOf(store: Store, taskId: string): string[];
+/**
+ * One project's pass: read new requests and file them, then write each filed task's status where it changed (no
+ * options moved: runYouiyoux does that too). The folder read is the project in Toolroll's records that `given`
+ * resolves to; anything else is left alone.
+ */
+export declare function runYouiyouxIntake(store: Store, given: string, now: Date, io: YouiyouxIo, options?: {
+    force?: boolean;
+}): YouiyouxPass;
+/** The worker's pass for one project (flow-cadence.ts): the intake, then each options request's options, both ways. */
+export declare function runYouiyoux(store: Store, given: string, now: Date, io: YouiyouxIo, options?: {
+    force?: boolean;
+}): Promise<YouiyouxPass>;
+export type OptionsRow = {
+    request: string;
+    taskId: string;
+    proposal: string;
+    state: string | null;
+    run: number | null;
+    digest: string | null;
+};
+/** The digest of an options file apart from what a decision changes: the proposal itself, every other key included. */
+export declare function proposalIdentity(raw: unknown): string | null;
+/** Why an agent's options file can't go to the hub as it stands, or null. Toolroll checks what makes it safe to copy
+ * and this request's; youiyoux checks each option against the component's contract when it reads it. */
+export declare function proposalProblem(text: string, proposal: string, request: string): string | null;
+export type Decision = {
+    status: "chosen" | "dismissed";
+    choice: string | null;
+    label: string | null;
+    by: string | null;
+    at: string | null;
+};
+/**
+ * A person decided in the hub: mark the task complete as landed work is, bound to the exact result whose options were
+ * copied, through every guard a person's completion passes, or leave it Ready for review and say why. Once per request,
+ * in one transaction with the read. Waits (false) while the task isn't Ready, Complete or cancelled.
+ */
+export declare function actOnDecision(store: Store, repo: string, row: OptionsRow, decision: Decision, now: Date, root: string): boolean;