atris 3.45.1 → 3.46.1

package/AGENTS.md

@@ -86,7 +86,8 @@ Human accept      -> task Done + AgentXP awarded
 ```
 
 Always-on agents should move proof-backed work to Review, complete their native
-goal, then continue the mission loop with the next goal. They must not run
+goal, then stop that task. The next goal or recurring monitor starts in a new
+dedicated task. They must not run
 `atris task accept` or claim AgentXP themselves; acceptance comes from a human
 or from the owner's standing `atris autoland` policy, never from the agent.
 
@@ -100,8 +101,8 @@ falling back to manual task/worktree flow.
 
 Codex agents with native goal tools should run `atris mission goal --json`
 before choosing work. If the payload includes `goal.visible_goal`, mirror
-`goal.objective` into the visible chat goal when the current goal is empty,
-complete, or already matching; never complete unrelated active goals just to
+`goal.objective` when this active task has no goal yet or its goal already
+matches; never reuse a completed task or complete unrelated active goals just to
 make room.
 
 ## Workflow
@@ -230,6 +231,21 @@ Purpose: optimize for decision-speed; lead with the move, then use descriptions
 Shape: `<operator>, today is about <move>` -> `I picked this because <why now>` -> `Ready: <draft/proof/context>` -> `Go deeper: <paths>`.
 Definitions: operator = current person or agent; move = one concrete high-leverage workflow; why now = business reason; ready = prepared action or proof; paths = 2-4 optional deeper views.
 
+Keep this voice beside every reply:
+<!-- ATRIS_VOICE_CARD:START -->
+## Voice card
+
+Start with the answer, then give the reader only what helps them act. Name the exact thing in plain words, like you are talking to a person.
+
+Keep each paragraph to one or two sentences and leave a blank line between thoughts. Use a comma or period instead of an em dash.
+
+Status example:
+The reply check is built. I am running the final checks now, so the result is not ready yet.
+
+Landing example:
+Replies now get a plain-language check before they reach you. The checks passed, and the change is ready.
+<!-- ATRIS_VOICE_CARD:END -->
+
 Re-run after meaningful work:
 `atris brain compile --root .`
 <!-- ATRIS_BRAIN_COMPILE:END -->

package/FOR_AGENTS.md

@@ -50,6 +50,11 @@ atris task ready <id> --proof "command that passed"
 
 **Never** `atris task accept` unless a human approved. That's their gate, not yours.
 
+Every task starts with three plain sentences: what changes, why it matters, and
+what done looks like. Keep the exact title, files, commands, requirements,
+events, proof, and approval rules available underneath. Offer the existing
+approve-or-change actions without weakening any proof or human approval gate.
+
 ---
 
 ## Rules that make you trustworthy

package/README.md

@@ -217,7 +217,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris play` | Enter the AgentXP player loop for one proof-backed mission |
 | `atris gm` | Enter AgentXP General Manager mode for player missions and review queues |
 | `atris xp` | Show the local AgentXP card and sync eligible proof to the hosted leaderboard |
-| `atris codex-goal` | Inspect or clear a completed native Codex thread goal after writing a backup, row dump, and receipt |
+| `atris codex-goal` | Inspect native Codex task goals and keep completed tasks closed |
 | `atris learn` | Manage structured learnings |
 | `atris ingest` | Stage raw evidence into `atris/context/` and compile into `atris/wiki/` |
 | `atris loop` | Refresh wiki health, stale/orphan signals, and next ingest candidates |
@@ -238,7 +238,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 - `atris loop` refreshes `atris/wiki/STATUS.md` and `atris/wiki/log.md`, flags stale/orphan pages, and suggests the next ingest
 - `atris activate` loads the current wiki status so the next session starts with project memory, not just tasks
 - `atris member` keeps team-member identity and learning local-first: `MEMBER.md` is the role contract, `goals.json` is the machine-readable goal/experiment state, `goals.md` is the human readout, and `logs/YYYY-MM-DD.md` records what happened. Use `atris member goal`, `tick`, `status`, `block`, and `review --value 1..5` to test whether a member is making useful progress or needs the operator/orchestrator.
-- `atris codex-goal` is the guarded bridge for native Codex `/goal`: `status` reads `~/.codex/state_5.sqlite`, while `reset --thread <id> --confirm-complete-goal-reset` backs up the DB, dumps the exact completed `thread_goals` row, deletes only that completed row, and writes a receipt. The next native goal must still be created by the live Codex thread; Atris Mission/member goals remain the durable loop state.
+- `atris codex-goal` is the read-only bridge for native Codex `/goal`: `status` inspects the live goal database, while the legacy `reset` command now refuses every mutation. Active tasks continue in place; completed tasks retain their final goal, and new work or recurring monitors use a new dedicated Codex task.
 - `atris task` keeps durable local task state and append-only events for agents; `atris/TODO.md` is just a regenerated readable board. Run the loop with `atris task new`, `delegate "..." --to <owner>`, `next`, `say`, and `ready <id> --proof "..."`; human approval is `atris task accept <id>` (moves to Done, awards Career XP) or `revise <id> --note "..."`. Final task transitions also append the general daily log and, when a real `atris/team/<member>/MEMBER.md` matches the task owner, that member's daily log. Add `--json` for headless agents, `atris task serve` for the local board, and `atris task show <ref>` / `events --all` for the full ledger. Commands accept semantic refs (`OBL-18`), full IDs, or any unique prefix. In cloud business workspaces, Supabase `tasks` is the source of truth and Swarlo the live claim layer.
 - `atris mission` is the durable autonomy layer: start with an owner, verifier, runner, and stop condition; record bounded work with `mission tick`; close with `mission complete` only after proof. Runners include `manual`, `claude`, `atris2`, and `codex_goal`.
 - `atris pulse` is the OS-cron heartbeat for overnight self-improvement. Use `atris pulse status`, `tick`, `run`, `install --cadence "<cron>" --days 7 --verify "npm test" --model claude-opus-4-8`, and `uninstall`.

package/atris/AGENTS.md

@@ -56,13 +56,14 @@ Human accept      -> task Done + Career XP awarded
 ```
 
 Always-on agents should move proof-backed work to Review, complete their native
-goal, then continue the mission loop with the next goal. They must not run
+goal, then stop that task. The next goal or recurring monitor starts in a new
+dedicated task. They must not run
 `atris task accept` or claim Career XP unless a human approved the proof.
 
 Codex agents with native goal tools should run `atris mission goal --json`
 before choosing work. If the payload includes `goal.visible_goal`, mirror
-`goal.objective` into the visible chat goal when the current goal is empty,
-complete, or already matching; never complete unrelated active goals just to
+`goal.objective` when this active task has no goal yet or its goal already
+matches; never reuse a completed task or complete unrelated active goals just to
 make room.
 
 Default to the current checkout for small, clean, single-agent fixes. Use

package/atris/CLAUDE.md

@@ -48,7 +48,7 @@ Agent proof ready -> native goal can complete
 Human accept      -> task Done + AgentXP awarded
 ```
 
-Always-on agents should complete their native goal after proof is in Review, then continue the mission loop with the next goal. They must not run `atris task accept` or claim AgentXP unless a human approved the proof.
+Always-on agents should complete their native goal after proof is in Review, then stop that task. The next goal or recurring monitor starts in a new dedicated task. They must not run `atris task accept` or claim AgentXP unless a human approved the proof.
 
 Do not write new operating doctrine here first. Add it to Atris policy, skills, wiki, or `atris/atris.md`, then regenerate this adapter if needed.
 

package/atris/atris.md

@@ -96,7 +96,10 @@ Core loop:
 
 ```bash
 atris task list
-atris task delegate "<title>" --to <functional-member> --tag <tag>
+atris task delegate "<title>" --to <functional-member> --tag <tag> \
+  --what-changes "<plain change>" \
+  --why-it-matters "<plain reason>" \
+  --done-looks-like "<observable finish>"
 atris task delegate "<title>" --to <functional-member> --executed-by <engine> --via swarlo --tag <tag>
 atris task day
 atris task next
@@ -108,6 +111,9 @@ atris task review <id> --lesson "<what improved>" --next "<next task>"
 
 `atris task ready` carries `--result`, the day-one PM sentence of what the human gained; the CLI refuses agent-speak.
 
+One purpose lives in one task. Once a native Codex task is complete, keep its
+final state intact; new work and recurring monitors start in a dedicated task.
+
 Headless agents should add `--json` where available and read
 `.atris/state/tasks.projection.json` for a compact board view.
 
@@ -122,6 +128,9 @@ task row/event stream remains the durable source of truth.
 Every task record should carry:
 
 ```
+What changes: <plain sentence a new teammate understands>
+Why it matters: <plain human or business reason>
+Done looks like: <observable finish, without command syntax>
 Title: <small work packet>
 Owner: <functional or feature member, not an engine>
 Objective: <why this matters>
@@ -131,6 +140,17 @@ Verify: <shell command or concrete proof>
 Next: <suggested follow-up task>
 ```
 
+The three plain fields are the default face on every task view. The exact
+title, context, requirements, files, events, proof, and verifier stay beneath
+them unchanged and inspectable. If a creator omits a plain field, the shared
+task model derives an honest fallback from the existing task and says when no
+reason was recorded; it never invents a benefit.
+
+A planned task shows two clear actions: approve the complete plan through the
+existing Plan -> Do gate, or ask for a change. Completed work shows approve
+only when the existing proof and human-accept gates allow it, plus revise for
+requested changes. The plain layer never bypasses a verifier or approval rule.
+
 Task planning preview and landing:
 
 ```

package/atris/skills/atris/SKILL.md

@@ -32,6 +32,9 @@ Key behaviors:
 - Read PERSONA.md (3-4 sentences, ASCII visuals)
 - Check MAP.md for file:line refs
 - Use `atris task` for claims, proof, ready, and accept
+- Give every task a plain first layer: what changes, why it matters, and what
+  done looks like. Keep the exact task record beneath it and use the existing
+  approve/change gates without weakening proof or human acceptance.
 - Use functional/feature members as task owners; record engines only as `executed_by`
 - Treat TODO.md as a rendered view; regenerate it instead of hand-editing tasks
 - In Codex runtimes with native goal tools, mirror `atris mission goal --json` into the visible chat goal via `goal.visible_goal`
@@ -67,9 +70,10 @@ If it returns `action: codex_goal_candidate` or `codex_goal_heartbeat` with
 
 1. Call `get_goal` when the runtime exposes it.
 2. If the active goal already equals `goal.objective`, keep working.
-3. If there is no active goal or the prior goal is complete, call `create_goal` with `goal.objective`.
-4. If a different active goal is still in progress, do not complete it just to make room; report that `goal.visible_goal.status` is waiting for the visible goal slot.
-5. After proof is ready, call `update_goal({ status: "complete" })`, rerun `atris mission goal --json`, then create the next visible goal candidate when a slot is available.
+3. If this active task has no goal yet, call `create_goal` with `goal.objective`.
+4. If this task's prior goal is complete, stop. Create a new dedicated Codex task for the next objective or recurring monitor; never reset or reuse the completed task.
+5. If a different active goal is still in progress, do not complete it just to make room; report that `goal.visible_goal.status` is waiting for the visible goal slot.
+6. After proof is ready, call `update_goal({ status: "complete" })` and stop this task. Read the next candidate only from its own new Codex task.
 
 Native goal completion is not task acceptance. Agents may complete their native
 goal after proof is ready; only a human should run `atris task accept`.

package/atris/skills/loop/SKILL.md

@@ -19,6 +19,7 @@ Schedules the recurring autopilot heartbeat. One tick fires roughly every 13–1
 2. The cron prompt first invokes `atris mission run --due --max-ticks 1 --complete-on-pass`; if no mission is due, it invokes `/autopilot`
 3. Returns the cron job id so the user can stop it later with `CronDelete`
 4. Lists the active cron jobs via `CronList` so the user can see the heartbeat is alive
+5. Runs from a dedicated active task for this loop; a completed task is never reused as the scheduler host
 
 ## How to invoke
 
@@ -26,13 +27,14 @@ User says "run /loop", "start the loop", "kick off autonomous mode", or "make au
 
 The agent then:
 
-1. Calls `CronCreate` with these args (use whatever off-clock minute you land on, do not pin to :00 or :30):
+1. Checks that the current task is active and dedicated to this loop. If it is complete or belongs to other work, stop and create a new dedicated task before scheduling.
+2. Calls `CronCreate` with these args (use whatever off-clock minute you land on, do not pin to :00 or :30):
    - `cron`: `"*/13 * * * *"` (every 13 min) for tight loops, or `"7 * * * *"` (hourly at :07) for slow loops
    - `prompt`: `"First run: atris mission run --due --max-ticks 1 --complete-on-pass. If it reports no_due_mission, run /autopilot for one tick. One bounded goal only, then stop. Do not start a conversation."`
    - `recurring`: `true`
    - `durable`: `false` (in-memory only, gone when this Claude session ends)
-2. After creating, calls `CronList` and shows the user the active cron jobs.
-3. Tells the user: "loop is alive. job id <X>. fires roughly every <N> minutes. say 'stop the loop' to kill it. auto-expires after 7 days."
+3. After creating, calls `CronList` and shows the user the active cron jobs.
+4. Tells the user: "loop is alive. job id <X>. fires roughly every <N> minutes. say 'stop the loop' to kill it. auto-expires after 7 days."
 
 ## Stopping the loop
 
@@ -43,6 +45,7 @@ If the user says "kill all loops", call `CronList`, then `CronDelete` for every
 ## Rules
 
 - One tick at a time. Never schedule a cron that fires more than once per 10 min.
+- One recurring monitor per dedicated active task. Never attach a new monitor to a completed task.
 - Always pick an off-clock minute (avoid :00 and :30) to prevent the global fleet from hammering the API at the same instant.
 - Use `durable: false` by default. Only use `durable: true` if the user explicitly says "make this survive restarts" or "persist this".
 - Auto-expires after 7 days. Tell the user.

package/atris.md

@@ -139,7 +139,10 @@ Core loop:
 
 ```bash
 atris task list
-atris task delegate "<title>" --to <functional-member> --tag <tag>
+atris task delegate "<title>" --to <functional-member> --tag <tag> \
+  --what-changes "<plain change>" \
+  --why-it-matters "<plain reason>" \
+  --done-looks-like "<observable finish>"
 atris task delegate "<title>" --to <functional-member> --executed-by <engine> --via swarlo --tag <tag>
 atris task day
 atris task next
@@ -163,6 +166,9 @@ task row/event stream remains the durable source of truth.
 Every task record should carry:
 
 ```
+What changes: <plain sentence a new teammate understands>
+Why it matters: <plain human or business reason>
+Done looks like: <observable finish, without command syntax>
 Title: <small work packet>
 Owner: <functional or feature member, not an engine>
 Objective: <why this matters>
@@ -172,6 +178,17 @@ Verify: <shell command or concrete proof>
 Next: <suggested follow-up task>
 ```
 
+The three plain fields are the default face on every task view. The exact
+title, context, requirements, files, events, proof, and verifier stay beneath
+them unchanged and inspectable. If a creator omits a plain field, the shared
+task model derives an honest fallback from the existing task and says when no
+reason was recorded; it never invents a benefit.
+
+A planned task shows two clear actions: approve the complete plan through the
+existing Plan -> Do gate, or ask for a change. Completed work shows approve
+only when the existing proof and human-accept gates allow it, plus revise for
+requested changes. The plain layer never bypasses a verifier or approval rule.
+
 Task planning preview and landing:
 
 ```

package/bin/atris.js

@@ -565,6 +565,7 @@ function showHelp() {
   console.log('  drive      - One self-driving tick: mission doctor -> auto-fix -> count disengagements');
   console.log(`  autoland   - Approve the policy once; ${require('../lib/autoland').certifiedWorkLandsPhrase(process.cwd())}, you keep irreversible calls`);
   console.log('  engine     - engine registry, answer validation, dispatch flights, and live progress');
+  console.log('  ci         - run github actions jobs locally with runs-on: atris');
   console.log('  router     - inspect ax lane outcomes and promote gated reflex overrides');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
@@ -2619,6 +2620,10 @@ if (command === 'init') {
   require('../commands/game').gameCommand(process.argv.slice(3))
     .then((status) => process.exit(status === 1 ? 1 : 0))
     .catch((err) => { console.error(`✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'ci') {
+  Promise.resolve(require('../commands/ci').ciCommand(process.argv.slice(3)))
+    .then((status) => process.exit(status || 0))
+    .catch((err) => { console.error(String(err.message || err).replace(/\s+/g, ' ').toLowerCase()); process.exit(1); });
 } else if (command === 'github') {
   const status = require('../commands/github').githubCommand(process.argv.slice(3));
   process.exit(status);

package/commands/autoland.js

@@ -9,6 +9,7 @@ const autoland = require('../lib/autoland');
 const { gateForHuman, plainLandingReason } = require('../lib/voice-gate');
 const { evaluateAutoAccept } = require('../lib/auto-accept-certified');
 const { sweepEngineAskReceipts } = require('../lib/engine-receipt-sweep');
+const { validateRecentAskReceipts } = require('../lib/engine-validate');
 const { operatorReady, hasAgentJargon, explainResult } = autoland;
 const MISSION_AUTO_VERIFY_STATUSES = new Set(['planning', 'paused', 'ready']);
 const CLOSED_TASK_STATUSES = new Set(['done', 'archived']);
@@ -640,7 +641,7 @@ function pidAlive(pid) {
   }
 }
 
-function runTick(root, args) {
+async function runTick(root, args) {
   const json = args.includes('--json');
   const policy = autoland.readPolicy(root);
   const receipt = { at: new Date().toISOString(), landed: [], alarms: 0, digest_due: false, digest_sent: false, enabled: Boolean(policy && policy.enabled) };
@@ -670,7 +671,7 @@ function runTick(root, args) {
     fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, at: Date.now() }));
   } catch {}
   try {
-    return runTickBody(root, { json, policy, receipt });
+    return await runTickBody(root, { json, policy, receipt });
   } finally {
     try { fs.unlinkSync(lockPath); } catch {}
   }
@@ -720,7 +721,22 @@ function engineReceiptSweepNote(receipt) {
   return `, finalized ${finalized} stale engine receipt${finalized === 1 ? '' : 's'} as presumed dead`;
 }
 
-function runTickBody(root, { json, policy, receipt }) {
+async function runEngineAnswerValidation(root, receipt, deps = {}) {
+  try {
+    receipt.engine_answer_validation = await validateRecentAskReceipts(root, deps);
+  } catch (err) {
+    receipt.engine_answer_validation_error = String((err && err.message) || err).slice(0, 200);
+  }
+  return receipt.engine_answer_validation || null;
+}
+
+function engineAnswerValidationLine(receipt) {
+  const graded = Number(receipt.engine_answer_validation?.graded_answers) || 0;
+  if (!graded) return '';
+  return `graded ${graded} engine answer${graded === 1 ? '' : 's'}, scoreboard updated`;
+}
+
+async function runTickBody(root, { json, policy, receipt, engineValidationDeps = {} }) {
 
   try {
     receipt.engine_receipt_sweep = sweepEngineAskReceipts(root);
@@ -728,6 +744,8 @@ function runTickBody(root, { json, policy, receipt }) {
     receipt.engine_receipt_sweep_error = String((err && err.message) || err).slice(0, 200);
   }
 
+  await runEngineAnswerValidation(root, receipt, engineValidationDeps);
+
   // 1. certify and land in one task process. Keeping both phases together lets
   // the landing gate reuse the live certification verifier result without
   // persisting trust across heartbeats. Denied lanes and check-less proofs wait.
@@ -1004,6 +1022,8 @@ function runTickBody(root, { json, policy, receipt }) {
     // gate and still did not land — that is the shape of a stuck loop.
     const stuckNote = stuckBacklogNote(receipt);
     const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${engineSweepNote}${receiptNote}`;
+    const validationLine = engineAnswerValidationLine(receipt);
+    if (validationLine) console.log(validationLine);
     console.log(gateForHuman(summary).text);
     for (const fulfilled of receipt.wish_dispatch?.fulfilled_results || []) {
       if (fulfilled.review_ask) console.log(fulfilled.review_ask);
@@ -1064,10 +1084,12 @@ module.exports = {
   digestNextMoves,
   digestStoryRows,
   digestTickStatus,
+  engineAnswerValidationLine,
   explainResult,
   operatorReady,
   readAcceptedTaskHistory,
   hasAgentJargon,
+  runEngineAnswerValidation,
   runTickBody,
   sweepLanding,
   verifyClosedTaskMissions,

package/commands/brain.js

@@ -5,6 +5,11 @@ const { spawnSync } = require('child_process');
 const { refreshNowFile } = require('./now');
 const escapeRegExp = require('../lib/escape-regexp');
 const { hasRenderedSections, isOpenSection, isDoneSection } = require('../lib/todo-sections');
+const {
+  renderVoiceCardBlock,
+  upsertCursorVoiceCard,
+  voiceCardForRoot,
+} = require('../lib/voice-card');
 
 const GENERATED_START = '<!-- ATRIS_BRAIN_COMPILE:START -->';
 const GENERATED_END = '<!-- ATRIS_BRAIN_COMPILE:END -->';
@@ -1424,7 +1429,7 @@ ${nextMove(state)}
 `;
 }
 
-function generatedBootBlock(state) {
+function generatedBootBlock(state, voiceCard = voiceCardForRoot(state.root)) {
   return `${GENERATED_START}
 ## Atris Brain Compile
 
@@ -1441,6 +1446,9 @@ Purpose: optimize for decision-speed; lead with the move, then use descriptions
 Shape: \`<operator>, today is about <move>\` -> \`I picked this because <why now>\` -> \`Ready: <draft/proof/context>\` -> \`Go deeper: <paths>\`.
 Definitions: operator = current person or agent; move = one concrete high-leverage workflow; why now = business reason; ready = prepared action or proof; paths = 2-4 optional deeper views.
 
+Keep this voice beside every reply:
+${renderVoiceCardBlock(voiceCard)}
+
 Re-run after meaningful work:
 \`atris brain compile --root .\`
 ${GENERATED_END}
@@ -1475,10 +1483,13 @@ function writeBrain(state) {
   fs.writeFileSync(ledgerPath, renderLedger(state), 'utf8');
   fs.writeFileSync(jsonPath, JSON.stringify(state, null, 2) + '\n', 'utf8');
 
-  const bootBlock = generatedBootBlock(state);
+  const voiceCard = voiceCardForRoot(state.root);
+  const bootBlock = generatedBootBlock(state, voiceCard);
   for (const fileName of ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md']) {
     upsertGeneratedBlock(path.join(state.root, fileName), fileName.replace(/\.md$/, ''), bootBlock);
   }
+  const cursorVoicePath = path.join(state.root, '.cursor', 'rules', 'atris-voice.mdc');
+  upsertCursorVoiceCard(cursorVoicePath, voiceCard);
 
   const wikiStatusPath = path.join(state.root, 'atris', 'wiki', 'STATUS.md');
   if (fs.existsSync(wikiStatusPath)) {
@@ -1495,7 +1506,7 @@ function writeBrain(state) {
 `);
   }
 
-  return { statusPath, ledgerPath, jsonPath };
+  return { statusPath, ledgerPath, jsonPath, cursorVoicePath };
 }
 
 function verifyBrain(root) {

package/commands/ci.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const {
+  formatUsageSummary,
+  parseRunnerArgs,
+  parseUsageArgs,
+  readUsageRecords,
+  runCiRunner,
+  summarizeUsage,
+  usageFilePath,
+} = require('../lib/ci-runner');
+
+function showCiHelp() {
+  console.log('atris ci runs github actions jobs on this machine with a warm local work folder.');
+  console.log('change runs-on: ubuntu-latest to runs-on: atris.');
+  console.log('a GITHUB_TOKEN or an authenticated gh cli is required.');
+  console.log('usage: atris ci runner --repo <owner/name> [--label <name>] [--once]');
+  console.log('       atris ci usage [--repo <owner/name>]');
+}
+
+async function ciCommand(argv, dependencies = {}) {
+  if (argv.length === 0 || argv[0] === 'help' || argv.includes('--help') || argv.includes('-h')) {
+    showCiHelp();
+    return 0;
+  }
+  if (argv[0] === 'usage') {
+    const options = parseUsageArgs(argv.slice(1));
+    const records = (dependencies.readUsageRecords || readUsageRecords)(
+      dependencies.usagePath || usageFilePath(),
+      dependencies.readFile,
+    );
+    const clock = dependencies.clock || (() => new Date());
+    const log = dependencies.log || console.log;
+    log(formatUsageSummary(summarizeUsage(records, { ...options, now: clock() })));
+    return 0;
+  }
+  if (argv[0] === 'runner') {
+    await runCiRunner(parseRunnerArgs(argv.slice(1)), dependencies);
+    return 0;
+  }
+  throw new Error(`unknown ci subcommand: ${argv[0]}`);
+}
+
+module.exports = { ciCommand, showCiHelp };