@bompus/house-rules 0.11.0 → 0.14.0

package/skills/hr-usage-report/scripts/usage-by-model.ts

@@ -0,0 +1,499 @@
+#!/usr/bin/env bun
+// Where did model usage go? Totals local transcript usage per provider, model and
+// role (main session, subagent, advisor) over a window, priced at models.dev list
+// rates, and reports context size per request and at session start.
+//
+//   bun usage-by-model.ts [--days N | --since ISO] [--providers claude,codex,opencode]
+//                         [--prices models-dev.json] [--json]
+//
+// List price stands in for subscription quota; providers do not publish the
+// conversion. Read the shares beside the provider's live quota readings, not as an
+// invoice. Method and report shape: ../SKILL.md.
+import { Database } from "bun:sqlite";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export type Tokens = { fresh: number; output: number; cacheRead: number; cacheWrite: number };
+export type Request = Tokens & {
+  provider: string;
+  priceProvider?: string;
+  model: string;
+  role: string;
+  session: string;
+  t: number;
+};
+type Rate = { input: number; output: number; cache_read?: number; cache_write?: number };
+type PriceEntry = Rate & { tiers?: (Rate & { tier: { type: string; size: number } })[] };
+export type Prices = Record<string, { models?: Record<string, { cost?: PriceEntry }> }>;
+
+const PRICE_ORDER = ["anthropic", "openai", "google", "xai", "opencode", "opencode-go"];
+
+/** models.dev entry for a model id, trying the recorded provider first, then known vendors. */
+export function priceFor(prices: Prices, model: string, provider?: string): PriceEntry | undefined {
+  const id = model.replace(/\[.*\]$/, "").replace(/-\d{8}$/, "");
+  for (const p of [provider, ...PRICE_ORDER]) {
+    const cost = p ? prices[p]?.models?.[id]?.cost : undefined;
+    if (cost) {
+      return cost;
+    }
+  }
+  return undefined;
+}
+
+/** List cost of one request; long-context tiers apply when the request's context exceeds their size. */
+export function requestCost(price: PriceEntry, r: Tokens): number {
+  const ctx = r.fresh + r.cacheRead + r.cacheWrite;
+  let rate: Rate = price;
+  // The largest exceeded tier applies, whatever order the price list gives.
+  let size = -1;
+  for (const tier of price.tiers ?? []) {
+    if (tier.tier.type === "context" && ctx > tier.tier.size && tier.tier.size > size) {
+      rate = tier;
+      size = tier.tier.size;
+    }
+  }
+  const cr = rate.cache_read ?? rate.input * 0.1;
+  const cw = rate.cache_write ?? rate.input * 1.25;
+  return (
+    (r.fresh * rate.input + r.output * rate.output + r.cacheRead * cr + r.cacheWrite * cw) / 1e6
+  );
+}
+
+function* jsonlFiles(dir: string, since: number): Generator<string> {
+  if (!existsSync(dir)) {
+    return;
+  }
+  for (const name of readdirSync(dir)) {
+    const path = join(dir, name);
+    const st = statSync(path);
+    if (st.isDirectory()) {
+      yield* jsonlFiles(path, since);
+    } else if (name.endsWith(".jsonl") && st.mtimeMs >= since) {
+      yield path;
+    }
+  }
+}
+
+function lines(path: string): unknown[] {
+  const out: unknown[] = [];
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    if (!line.includes("usage")) {
+      continue;
+    }
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      // A partially written last line is skipped.
+    }
+  }
+  return out;
+}
+
+type ClaudeUsage = {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+  iterations?: (ClaudeUsage & { type?: string; model?: string })[];
+};
+type ClaudeEntry = {
+  timestamp?: string;
+  requestId?: string;
+  isSidechain?: boolean;
+  sessionId?: string;
+  message?: { id?: string; model?: string; usage?: ClaudeUsage };
+};
+
+const claudeTokens = (u: ClaudeUsage): Tokens => ({
+  fresh: u.input_tokens ?? 0,
+  output: u.output_tokens ?? 0,
+  cacheRead: u.cache_read_input_tokens ?? 0,
+  cacheWrite: u.cache_creation_input_tokens ?? 0,
+});
+
+/**
+ * Claude Code transcript roots under a home directory: the default `~/.claude/projects` and the
+ * `projects` directory of every other `~/.claude*` configuration directory, such as a separate
+ * `CLAUDE_CONFIG_DIR` used for a gateway. A directory reached through a link counts once.
+ */
+export function claudeProjectRoots(home: string): string[] {
+  const roots = new Map<string, string>();
+  for (const name of readdirSync(home).sort()) {
+    if (name !== ".claude" && !name.startsWith(".claude_") && !name.startsWith(".claude-")) {
+      continue;
+    }
+    const root = join(home, name, "projects");
+    if (existsSync(root)) {
+      roots.set(realpathSync(root), root);
+    }
+  }
+  return [...roots.values()];
+}
+
+type ClaudeMessage = NonNullable<ClaudeEntry["message"]>;
+
+/**
+ * Claude Code transcripts: one row per API response, advisor calls split out. A response is
+ * written once per streamed block: the first line carries the usage at the start of the stream
+ * (a few output tokens, no advisor iterations) and later lines carry the final figures, so the
+ * line with the most output tokens is kept, and advisor iterations from whichever line has them.
+ */
+export function claudeRequests(roots: string | string[], since: number): Request[] {
+  type Seen = {
+    model: string;
+    role: string;
+    session: string;
+    t: number;
+    usage: ClaudeUsage;
+    iterations: NonNullable<ClaudeUsage["iterations"]>;
+  };
+  const responses = new Map<string, Seen>();
+  const files = (Array.isArray(roots) ? roots : [roots]).flatMap((root) =>
+    Array.from(jsonlFiles(root, since)),
+  );
+  for (const file of files) {
+    const fileRole = file.includes("/subagents/") ? "subagent" : "main";
+    for (const raw of lines(file)) {
+      const e = raw as ClaudeEntry;
+      const m: ClaudeMessage | undefined = e.message;
+      const t = Date.parse(e.timestamp ?? "");
+      // `<synthetic>` marks Claude Code's locally generated replies; they carry no usage.
+      if (!m?.id || !m.usage || !m.model || m.model === "<synthetic>" || !(t >= since)) {
+        continue;
+      }
+      const key = `${m.id}|${e.requestId ?? ""}`;
+      const seen = responses.get(key);
+      const iterations = m.usage.iterations ?? [];
+      if (!seen) {
+        responses.set(key, {
+          model: m.model,
+          role: e.isSidechain ? "subagent" : fileRole,
+          session: e.sessionId ?? file,
+          t,
+          usage: m.usage,
+          iterations,
+        });
+        continue;
+      }
+      if ((m.usage.output_tokens ?? 0) > (seen.usage.output_tokens ?? 0)) {
+        seen.usage = m.usage;
+      }
+      if (iterations.length > 0) {
+        seen.iterations = iterations;
+      }
+    }
+  }
+  const out: Request[] = [];
+  for (const r of responses.values()) {
+    out.push({
+      provider: "claude",
+      priceProvider: "anthropic",
+      model: r.model,
+      role: r.role,
+      session: r.session,
+      t: r.t,
+      ...claudeTokens(r.usage),
+    });
+    for (const it of r.iterations) {
+      if (it.type !== "advisor_message" || !it.model) {
+        continue;
+      }
+      out.push({
+        provider: "claude",
+        priceProvider: "anthropic",
+        model: it.model,
+        role: "advisor",
+        session: r.session,
+        t: r.t,
+        ...claudeTokens(it),
+      });
+    }
+  }
+  return out;
+}
+
+type CodexUsage = {
+  input_tokens?: number;
+  cached_input_tokens?: number;
+  cache_write_input_tokens?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+};
+type CodexLine = {
+  type?: string;
+  timestamp?: string;
+  payload?: {
+    type?: string;
+    model?: string;
+    usage?: CodexUsage;
+    info?: { last_token_usage?: CodexUsage; total_token_usage?: CodexUsage } | null;
+    source?: unknown;
+    id?: string;
+  };
+};
+
+/** Codex rollouts: one row per response record; input tokens include the cached ones. */
+// Codex writes one token_usage_record per response. Builds without it still write
+// token_count events, which repeat when only rate limits change; those count only
+// when the session's running total advances, and only for files with no records.
+export function codexRequests(root: string, since: number): Request[] {
+  const out: Request[] = [];
+  for (const file of jsonlFiles(root, since)) {
+    let model = "unknown";
+    let role = "main";
+    let session = file;
+    let total = 0;
+    const records: Request[] = [];
+    const events: Request[] = [];
+    const request = (u: CodexUsage, t: number): Request => {
+      const cached = u.cached_input_tokens ?? 0;
+      return {
+        provider: "codex",
+        priceProvider: "openai",
+        model,
+        role,
+        session,
+        t,
+        fresh: Math.max(0, (u.input_tokens ?? 0) - cached),
+        cacheRead: cached,
+        cacheWrite: u.cache_write_input_tokens ?? 0,
+        output: u.output_tokens ?? 0,
+      };
+    };
+    for (const raw of readFileSync(file, "utf8").split("\n")) {
+      if (!raw) {
+        continue;
+      }
+      let e: CodexLine;
+      try {
+        e = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      const p = e.payload ?? {};
+      const t = Date.parse(e.timestamp ?? "");
+      if (e.type === "session_meta") {
+        session = p.id ?? file;
+        if (p.source && typeof p.source === "object" && "subagent" in p.source) {
+          role = "subagent";
+        }
+      } else if (e.type === "turn_context" && p.model) {
+        model = p.model;
+      } else if (e.type === "token_usage_record" && p.usage) {
+        if (t >= since) {
+          records.push(request(p.usage, t));
+        }
+      } else if (e.type === "event_msg" && p.type === "token_count" && p.info?.last_token_usage) {
+        const running = p.info.total_token_usage?.total_tokens ?? 0;
+        if (running > total) {
+          total = running;
+          if (t >= since) {
+            events.push(request(p.info.last_token_usage, t));
+          }
+        }
+      }
+    }
+    out.push(...(records.length ? records : events));
+  }
+  return out;
+}
+
+type OpenCodeData = {
+  role?: string;
+  modelID?: string;
+  providerID?: string;
+  tokens?: {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: { read?: number; write?: number };
+  };
+};
+
+/** OpenCode's database: assistant messages; a session with a parent is a subagent. */
+export function opencodeRequests(dbPath: string, since: number): Request[] {
+  if (!existsSync(dbPath)) {
+    return [];
+  }
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const rows = db
+      .query(
+        "select m.session_id as s, m.time_created as t, m.data as d, s.parent_id as parent from message m join session s on s.id = m.session_id where m.time_created >= ?",
+      )
+      .all(since) as { s: string; t: number; d: string; parent: string | null }[];
+    const out: Request[] = [];
+    for (const row of rows) {
+      const d = JSON.parse(row.d) as OpenCodeData;
+      if (d.role !== "assistant" || !d.modelID || !d.tokens) {
+        continue;
+      }
+      out.push({
+        provider: "opencode",
+        priceProvider: d.providerID,
+        model: d.modelID,
+        role: row.parent ? "subagent" : "main",
+        session: row.s,
+        t: row.t,
+        fresh: d.tokens.input ?? 0,
+        output: (d.tokens.output ?? 0) + (d.tokens.reasoning ?? 0),
+        cacheRead: d.tokens.cache?.read ?? 0,
+        cacheWrite: d.tokens.cache?.write ?? 0,
+      });
+    }
+    return out;
+  } finally {
+    db.close();
+  }
+}
+
+const quantile = (xs: number[], q: number) =>
+  xs.length ? (xs[Math.min(xs.length - 1, Math.floor(q * xs.length))] ?? 0) : 0;
+
+export function summarize(reqs: Request[], prices: Prices) {
+  const groups = new Map<
+    string,
+    Tokens & {
+      provider: string;
+      model: string;
+      role: string;
+      requests: number;
+      cost: number | null;
+    }
+  >();
+  const unpriced = new Set<string>();
+  for (const r of reqs) {
+    const key = `${r.provider}|${r.model}|${r.role}`;
+    const g = groups.get(key) ?? {
+      provider: r.provider,
+      model: r.model,
+      role: r.role,
+      requests: 0,
+      fresh: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      cost: 0,
+    };
+    g.requests += 1;
+    g.fresh += r.fresh;
+    g.output += r.output;
+    g.cacheRead += r.cacheRead;
+    g.cacheWrite += r.cacheWrite;
+    const price = priceFor(prices, r.model, r.priceProvider);
+    if (price && g.cost !== null) {
+      g.cost += requestCost(price, r);
+    } else if (!price) {
+      g.cost = null;
+      unpriced.add(r.model);
+    }
+    groups.set(key, g);
+  }
+  const total = [...groups.values()].reduce((s, g) => s + (g.cost ?? 0), 0);
+  const rows = [...groups.values()]
+    .map((g) => ({
+      ...g,
+      cost: g.cost === null ? null : Math.round(g.cost * 100) / 100,
+      sharePct: g.cost === null || !total ? null : Math.round((1000 * g.cost) / total) / 10,
+    }))
+    .sort((a, b) => (b.cost ?? -1) - (a.cost ?? -1));
+  const context: Record<
+    string,
+    { requestP50: number; requestP90: number; sessionStartP50: number; sessions: number }
+  > = {};
+  for (const provider of new Set(reqs.map((r) => r.provider))) {
+    const main = reqs
+      .filter((r) => r.provider === provider && r.role === "main")
+      .sort((a, b) => a.t - b.t);
+    const ctx = main.map((r) => r.fresh + r.cacheRead + r.cacheWrite).sort((a, b) => a - b);
+    const first = new Map<string, number>();
+    for (const r of main) {
+      if (!first.has(r.session)) {
+        first.set(r.session, r.fresh + r.cacheRead + r.cacheWrite);
+      }
+    }
+    const starts = [...first.values()].sort((a, b) => a - b);
+    context[provider] = {
+      requestP50: quantile(ctx, 0.5),
+      requestP90: quantile(ctx, 0.9),
+      sessionStartP50: quantile(starts, 0.5),
+      sessions: starts.length,
+    };
+  }
+  return { listCostTotal: Math.round(total * 100) / 100, rows, context, unpriced: [...unpriced] };
+}
+
+function arg(args: string[], name: string): string | undefined {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+}
+
+async function fetchPrices(): Promise<unknown> {
+  const res = await fetch("https://models.dev/api.json");
+  if (!res.ok) {
+    throw new Error(`models.dev price list returned ${res.status}; pass --prices <file>`);
+  }
+  return res.json();
+}
+
+async function main(args: string[]) {
+  const since = arg(args, "--since")
+    ? Date.parse(arg(args, "--since")!)
+    : Date.now() - Number(arg(args, "--days") ?? 7) * 86_400_000;
+  if (!Number.isFinite(since)) {
+    throw new Error("--since needs an ISO time; --days a number");
+  }
+  const providers = (arg(args, "--providers") ?? "claude,codex,opencode").split(",");
+  const pricePath = arg(args, "--prices");
+  const prices = (
+    pricePath ? JSON.parse(readFileSync(pricePath, "utf8")) : await fetchPrices()
+  ) as Prices;
+  const home = homedir();
+  const reqs = [
+    ...(providers.includes("claude")
+      ? claudeRequests(
+          arg(args, "--claude-projects")?.split(",") ?? claudeProjectRoots(home),
+          since,
+        )
+      : []),
+    ...(providers.includes("codex") ? codexRequests(join(home, ".codex", "sessions"), since) : []),
+    ...(providers.includes("opencode")
+      ? opencodeRequests(join(home, ".local", "share", "opencode", "opencode.db"), since)
+      : []),
+  ];
+  const report = {
+    since: new Date(since).toISOString(),
+    providers,
+    requests: reqs.length,
+    ...summarize(reqs, prices),
+  };
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(report, null, 1));
+    return;
+  }
+  const M = (n: number) => (n / 1e6).toFixed(2);
+  console.log(
+    `since ${report.since}; ${report.requests} requests; list total $${report.listCostTotal}`,
+  );
+  console.log(
+    "provider  model                          role      reqs   fresh(M) out(M) cacheR(M) cacheW(M)   list$  share",
+  );
+  for (const r of report.rows) {
+    console.log(
+      `${r.provider.padEnd(9)} ${r.model.slice(0, 30).padEnd(30)} ${r.role.padEnd(9)} ${String(r.requests).padStart(6)} ${M(r.fresh).padStart(9)} ${M(r.output).padStart(6)} ${M(r.cacheRead).padStart(9)} ${M(r.cacheWrite).padStart(9)} ${String(r.cost ?? "n/a").padStart(8)} ${r.sharePct === null ? "  n/a" : `${r.sharePct}%`.padStart(6)}`,
+    );
+  }
+  for (const [p, c] of Object.entries(report.context)) {
+    console.log(
+      `${p}: main-request context p50 ${c.requestP50}, p90 ${c.requestP90}; session start p50 ${c.sessionStartP50} over ${c.sessions} sessions`,
+    );
+  }
+  if (report.unpriced.length) {
+    console.log(`no models.dev price: ${report.unpriced.join(", ")}`);
+  }
+}
+
+if (import.meta.main) {
+  await main(process.argv.slice(2));
+}

package/skills/hr-what-next/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: hr-what-next
-description: "Reconcile remaining work and recommend priorities. Use for next, next?, what's next, what remains, backlog reviews, full-session audits of tasks and unanswered or past questions, and equivalent requests. Do not use for go or continue, which retain their acceptance/continuation meaning, or progress/ETA-only requests."
+description: "Reconcile remaining work and recommend priorities. Use for next, next?, what's next, what remains, backlog reviews, walk-throughs of the backlog item by item, full-session audits of tasks and unanswered or past questions, and equivalent requests. Do not use for go or continue, which retain their acceptance/continuation meaning, or progress/ETA-only requests."
 ---
 
 # What next
@@ -17,25 +17,55 @@ completed state before the completion message; a report alone does not do so.
 1. Choose the review scope from the request and its context. For a short
    "next?", check the current task, its ledger and latest results, plus this
    floor whatever the scope: every question from an earlier offer in this
-   conversation that the user has not answered, every owned uncommitted file,
-   unpushed commit or held checkout, and the number of other live ledger items
-   (deferred, unselected, blocked or follow-up) with a link to the ledger.
+   conversation that the user has not answered, every item deferred with only the
+   user's selection as its trigger, every owned uncommitted file, unpushed commit
+   or held checkout, and the number of other live ledger items (deferred,
+   awaiting selection, blocked or follow-up) with a link to the ledger.
+   When the session keeps a plan file, `scripts/check-open-work.mjs <plan>`
+   computes this floor (add `--checkout <path>` for each checkout touched, or
+   `--app-managed <path>` for one an app retires, which is reported but not a
+   finding): run it and quote its result instead of recalling the ledger. Its
+   "awaiting your yes/no" group lists the user-trigger deferrals by a text match.
+   Its "possibly finished" group lists items whose named pull requests or
+   issues are all merged or closed (add `--repo <owner/repo>` for bare numbers),
+   unless a named commit sits outside a `--checkout`'s default branch,
+   and "re-check due" lists `recheck:` dates that are past or within a week.
+   Look at each before reporting it as done or still waiting.
+   It also prints `unanswered offers: N`, the number of offer IDs ("Offer
+   ABC-12") on open ledger lines that no line records as answered, dropped or
+   superseded, and warns at three. Plans that number offers without an ID are
+   not counted.
+   When the plan's header has a `Project: <name>` line, it also warns when that
+   project's last `hr-forgotten-work-audit` record is missing or over 30 days
+   old; offer the audit then.
    Report each floor item, or state that the floor is empty. While any floor
    item remains, do not say that nothing is left or that nothing needs the
-   user; re-present the unanswered questions as an offer instead. When asked
+   user; re-present the unanswered questions and ask the undecided items (step 6). When three
+   or more offers from this conversation are open and unanswered, do not
+   re-present them one by one: start a walk-through over them. When asked
    for all current and past items, review the available session transcript,
    relevant plans, task lists, handoffs and linked follow-ups. Name source
    ranges and missing, inaccessible or truncated records. Sweep other
    sessions' records only within the requested project and scope.
 2. Trace requests, unanswered questions, commitments, offered alternatives
-   and findings to their latest disposition. Reconcile duplicate, superseded
+   and findings to what was last decided or done about them. Reconcile duplicate, superseded
    and stale rows with completion or replacement evidence. Keep owners,
    deferred triggers and other sessions' context visible. An old task
    description alone does not establish current activity or ownership.
 3. Preserve the latest selected scope and valid unanswered offer in the
-   durable ledger. Distinguish done, authorized unfinished, unselected,
+   durable ledger. Distinguish done, authorized unfinished, awaiting selection, dropped,
    blocked, deferred and other-owner items. A completed implementation does
-   not complete required checks or landing; deferral does not mean done.
+   not complete required checks or landing; deferral does not mean done. A
+   deferral is not a yes or no: an item deferred with only the user's selection
+   as its trigger is undecided, so it sorts under needs your decision.
+   Sort every open item by what it waits on: **actionable now** (this session
+   can advance it under existing authority), **needs your decision** (a
+   selection or answer only the user can give) or **waiting on others** (an
+   external release, issue or pull request, another project or owner, a date,
+   or an app that retires it). Keep each waiting item's trigger and owner. A
+   waiting item stays in the ledger and in the report with its trigger, but it
+   is not work this session can do yet: do not recommend it as a next step
+   before its trigger fires.
 4. Rank remaining items toward the current goal and explicit priorities.
    Explain the objective and weigh expected impact, next-decision value,
    urgency, dependencies, effort and evidence confidence. Keep priority,
@@ -47,15 +77,75 @@ completed state before the completion message; a report alone does not do so.
    For a full audit, put the full individual table in a durable report
    and link it beside the immediate decisions. Answer whether items are
    accounted for separately from whether selected work is complete.
+   Where the user's rules have a backlog view (§ Backlog view, an optional
+   rule), show it beside the table whenever any item remains, in the format that
+   rule gives. Without one, the table alone is the report. The offer itself
+   follows the offer rules, which make an offer visual only when the user asks
+   for one.
 6. Continue work that can advance under existing authorization. Ask only for
-   unresolved choices using the governing offer format. Preserve schedules
+   unresolved choices using the governing offer format. Invoking this skill is
+   asking for the backlog (§ Session purpose), so present every needs-your-decision
+   item as an offer, or as a walk-through when three or more questions are open,
+   instead of only counting it. Record each answer as yes, no
+   (dropped) or defer with a trigger other than the user's selection, so the
+   item is not asked again on every run. A no is dropped, even when it names
+   what would make the user reconsider. Defer only work the user wants done later. Items waiting on others stay listed
+   with their trigger and are not asked. Preserve schedules
    and ownership; this audit grants no authority to start, transfer, publish
    or clean up work merely because it appears in the inventory.
 
+## Walk-through
+
+When the user asks to go through the backlog item by item, or three or more
+offers are open and unanswered, run it in groups:
+
+1. Rank and save the report as above. Where the user's rules have a backlog
+   view (§ Backlog view), show it for the whole ranked backlog with the
+   current group marked and placed last among the decisions. The decisions
+   stay in the text offer. When
+   stacked offers start the walk-through, mark each superseded in the ledger,
+   keep its option text, and queue its questions as groups.
+2. Put items in one group when one answer can cover them: the same owner, the
+   same action or one dependency. Ask one group per reply, one numbered
+   question per item with one combined acceptance line. Ask first the group
+   whose answers change or unblock the others, then one with a date, then the
+   rest; a decision whose prerequisite is still open waits for a later group.
+   Say how many groups remain and name the next.
+3. Before asking a group, look up what one read-only call can answer (why a
+   run failed, whether a setting already exists) and show the finding beside
+   the question. Ask the user only the decision.
+4. Record each answer in the ledger before acting, then close that group's
+   offer. Show the backlog view again, when there is one, with the next group
+   marked before asking it.
+   `go` selects the recommendation in the latest open group only. A result or
+   handoff that brings its own offer while the queue is open joins the queue
+   with one line; it does not become another standalone offer.
+5. Stop when no decision remains that the user can make now. Record each
+   leftover with the condition that would reopen it. Say what closed in the
+   text, and show the backlog view, when there is one, with what still waits;
+   the view lists open items only.
+
 For a full audit, save a mapping from reviewed source records to items or
-reviewed context-only dispositions. If `hr-handoff` and its reconciliation
+reviewed records kept only as context. When the report rebuilds a ledger or
+inventory from an earlier one, treat the earlier one as a source. Carry each of
+its open or deferred lines over as an item, marked done with its outcome when it
+has closed. Several lines may share one item only when the same next action
+and completion evidence satisfy every line. A summary row such as "the rest,
+reopen only if asked" loses those lines. If `hr-handoff` and its reconciliation
 resources are available, reuse its `references/reconciliation.md` procedure
 and `scripts/check-reconciliation.mjs` checker. Otherwise retain the mapping
 and coverage gaps without claiming a mechanical check. A passing checker
 accounts for supplied records; it does not prove every promise was understood
 or that unavailable history contains no other work.
+
+## Machine reconciliation
+
+For a host that checks the reply boundary, add `--json --session <id> --turn <id>`
+to the existing floor command. It emits a bound `reconciliation` receipt alongside
+the usual report. An invalid plan exits `1`, even when displayed groups are empty.
+Exit `2` reports open work or findings and does not classify readiness or authority.
+
+The house-rules repository's `evals/end-of-reply/README.md`, Adapter migration,
+defines version-2 records, exact item coverage and adapter migration. The floor
+only supplies snapshot identities; the producer must explicitly classify each
+item. Source availability does not establish host enforcement.