tickmarkr 1.30.0 → 1.33.1

package/README.md

@@ -13,8 +13,7 @@ Green tasks consolidate onto a `tickmarkr/<runId>` **consolidation** branch; **s
 your mainline) is always the Partner's call, never the engine's. A fully green engagement is an
 **unqualified opinion** — every assertion independently ticked.
 
-> The package ships `tickmarkr` as the primary bin, plus `drovr` and a `drover` bin alias for
-> backward compatibility — all three invoke the same entry. New installs should call `tickmarkr`.
+> The package ships `tickmarkr` and `tkr` only; `tkr` is the short alias.
 
 ## Vocabulary
 
@@ -53,34 +52,76 @@ These are law; the codebase fails closed around them:
 - worker/judge/review/consult prompts end with machine-parseable trailers
   (`DROVR_RESULT` / JSON verdicts); parse defensively, fail closed
 
-## Install
+Any agent (or human) operating this repo must respect the same five rules above — they are not
+merely internal implementation details, they are the contract the gates enforce.
 
-Requirements: Node ≥ 20, git, and at least one agent CLI on PATH (`claude`, `codex`, `cursor-agent`,
-`opencode`, `grok`, or `pi`) authenticated through its own login.
+## Install
 
 ```bash
-npm install
-npm run build
-npm link        # exposes the `tickmarkr` bin (and the `drovr` / `drover` compat alias)
+npm i -g tickmarkr
 ```
 
+This installs two identical bins: `tickmarkr` and its short alias `tkr` — use whichever you
+prefer, every example below works with either.
+
+**Requirements:**
+
+- **macOS or Linux.** Every command shells out through `bash`, so native Windows is not
+  supported — use WSL (untested).
+- Node ≥ 20 and `git` on PATH.
+- At least one agent CLI on PATH (`claude`, `codex`, `cursor-agent`, `opencode`, `grok`, or
+  `pi`), authenticated through its own login. tickmarkr never handles vendor API keys itself.
+
 Then verify your fleet:
 
 ```bash
 tickmarkr doctor   # probes installed adapters, herdr, auth; prints the capability matrix
 ```
 
-## Quickstart
+**Expect `doctor` (and `init`, which runs it) to take a while on first run:** auth detection is
+one real, short LLM call per configured model per installed CLI — honest, but not instant. A
+machine with three CLIs and several models each can take a minute or more; each probe is capped
+at 30s.
+
+## Quickstart (5 minutes)
 
 ```bash
-tickmarkr init                 # guided setup + doctor; scaffolds .drovr/config.yaml and drovr.spec.md
-# edit drovr.spec.md            # the native spec template, marked <!-- drovr:spec -->
-tickmarkr compile drovr.spec.md # spec → .drovr/graph.json (fails without acceptance criteria)
+tickmarkr init                 # guided setup + doctor; scaffolds .drovr/config.yaml and tickmarkr.spec.md
+# edit tickmarkr.spec.md        # the native spec template, marked <!-- drovr:spec -->
+tickmarkr compile tickmarkr.spec.md # spec → .drovr/graph.json (fails without acceptance criteria)
 tickmarkr plan                 # dry-run routing table + cost estimate + floor lints
 tickmarkr run                  # execute the graph (--concurrency N --driver herdr|subprocess --route-strict)
 tickmarkr report <runId> --md  # engagement record in Markdown
 ```
 
+That's the whole loop: `init` scaffolds, you write the spec's tasks and `acceptance[]`, `compile`
+turns it into a task graph, `plan` shows you the routing/cost dry run, `run` dispatches field teams
+and gates every result, and `report` writes the engagement record. Nothing merges to your mainline
+without your sign-off.
+
+## Agent-ready repos: `tickmarkr init --agent`
+
+`tickmarkr init --agent` composes with the base `init` above and additionally installs the
+consumer-facing skills (`tickmarkr-loop`, `tickmarkr-auto`) that ship in the npm tarball, so a
+coding agent working in your repo knows how to drive tickmarkr without reading its source:
+
+```bash
+tickmarkr init --agent            # installs .claude/skills/tickmarkr-{loop,auto}, offers CLAUDE.md/AGENTS.md notes
+tickmarkr init --agent --force    # also overwrite skill files that already exist
+tickmarkr init --agent --docs     # also append the agent-docs section without an interactive prompt
+```
+
+Consent rules — every write is additive, never destructive:
+
+- an existing `.claude/skills/tickmarkr-{loop,auto}/SKILL.md` is left untouched unless you answer
+  yes to a per-file prompt, or pass `--force`
+- a short "tickmarkr" section (the loop commands + the invariants above) is appended to `CLAUDE.md`
+  — or `AGENTS.md` if that exists and `CLAUDE.md` doesn't — only after you say yes, or pass `--docs`;
+  it's wrapped in `<!-- tickmarkr:agent-docs begin/end -->` markers and never inserted twice
+- declining a prompt still lets the rest of `init` complete
+- non-interactive shells (no TTY) never prompt: missing skills are installed, everything else is
+  skipped, and the summary names exactly what was skipped and which flag would enable it
+
 Supervise and finish:
 
 ```bash
@@ -282,11 +323,11 @@ produced the graph. Upstream, these front-ends exist:
 
 | Spec source | Support | How |
 |---|---|---|
-| **drovr spec** (native format) | Native/default | `tickmarkr init` template with the `<!-- drovr:spec -->` marker |
+| **tickmarkr spec** (native format) | Native/default | `tickmarkr init` template with the `<!-- drovr:spec -->` marker |
 | **Spec Kit** feature dir | Native | dir containing `tasks.md` |
 | **GSD** phase dir | Native | dir containing `*-PLAN.md` |
 | **Markdown PRD** | Native (universal adapter) | any `.md` with tasks + acceptance criteria |
-| OpenSpec, BMAD, Superpowers, others | Not yet | render to a drovr spec (the `<!-- drovr:spec -->` marker plus the full Task surface), or contribute a front-end: one parser module behind `src/compile/index.ts`, same pattern as `gsd.ts` |
+| OpenSpec, BMAD, Superpowers, others | Not yet | render to a tickmarkr spec (the `<!-- drovr:spec -->` marker plus the full Task surface), or contribute a front-end: one parser module behind `src/compile/index.ts`, same pattern as `gsd.ts` |
 
 Compile fails loudly on anything it can't recognize (`--type native|speckit|prd|gsd` to force).
 
@@ -323,8 +364,8 @@ Untyped acceptance strings in existing specs compile as `oracle: judge` + warnin
 
 Cloning this repo gives Claude Code project skills under `.claude/skills/`:
 
-- **`/drovr-loop`** — the SDD-agnostic loop: compile one spec, read the plan, run from the journal, merge green work, and commit only the Markdown execution record beside that spec. For GSD bookkeeping, use `/drovr-auto`.
-- **`/drovr-auto`** — the **GSD binding**: run remaining GSD milestone phases autonomously with tickmarkr as the
+- **`/tickmarkr-loop`** — the SDD-agnostic loop: compile one spec, read the plan, run from the journal, merge green work, and commit only the Markdown execution record beside that spec. For GSD bookkeeping, use `/tickmarkr-auto`.
+- **`/tickmarkr-auto`** — the **GSD binding**: run remaining GSD milestone phases autonomously with tickmarkr as the
   executor (plans → compile → dry-run → run → merge → sync-back). Bindings are per-SDD by nature — the
   sync-back writes that methodology's artifacts; other SDDs need their own thin binding, not this one.
 - **`/overseer`** — supervise an autonomous tickmarkr engagement from a Herdr workspace: two-tier visible hierarchy,
@@ -332,14 +373,65 @@ Cloning this repo gives Claude Code project skills under `.claude/skills/`:
 
 Repo-scoped: available automatically in Claude Code sessions inside this repo; not installed by npm.
 
-## Development
+## Contributing
+
+### Dev setup
 
 ```bash
-npm test               # vitest unit+integration — zero tokens, fake adapter only
-npm run test:coverage  # coverage floors enforced on core dirs
-npm run e2e            # real-CLI end-to-end (spends tokens; needs ≥1 agent CLI)
+git clone <your fork>
+cd tickmarkr
+npm install
+npm run build   # tsc → dist/; the only enforced static check
+npm link        # exposes the tickmarkr/tkr bins from your checkout
 ```
 
+### Tests are zero-token by design
+
+```bash
+npm test               # vitest unit+integration — fake adapter only, spends no tokens, ever
+npm run test:coverage  # same suite, coverage floors enforced (see below)
+npm run e2e            # opt-in real-CLI end-to-end — DOES spend tokens, needs ≥1 agent CLI installed
+```
+
+`npm test` and `npm run test:coverage` must never call a real agent CLI or spend tokens — that's
+what `DROVR_FAKE_SCRIPT` and the `FakeAdapter` (`src/adapters/fake.ts`) exist for. If a change
+needs a real CLI to verify, that test belongs under `npm run e2e` (`tests/e2e/`), gated behind
+`DROVR_E2E=1`, never in the default suite.
+
+Coverage floor: `src/{graph,route,gates,run}/**` must stay at lines 80% / functions 80% /
+branches 70% — this is the CLAUDE.md invariant, enforced verbatim in `vitest.config.ts`.
+`src/compile/**`, `src/adapters/**`, and `src/drivers/**` carry their own (higher) measured
+thresholds in the same file.
+
+### The spec-driven workflow — the gates are the review
+
+Changes to tickmarkr itself land the same way tickmarkr expects consumer changes to land: write a
+native spec (`specs/<version>-<name>.spec.md`, marked `<!-- tickmarkr:spec -->`), give every task
+real `acceptance[]` criteria, then compile/plan/run it and let the gates (baseline, evidence, scope,
+acceptance-judge, cross-vendor review) independently verify the diff before it merges. PRs are
+welcome, but a PR that only "looks right" isn't the bar — a green, gated engagement is. If you're
+proposing a non-trivial change, sketch it as a spec first; small fixes and docs can go straight to
+a PR.
+
+### Adding a worker adapter
+
+Support for a new agent CLI is one new file implementing `WorkerAdapter`
+(`src/adapters/types.ts`) — `id`, `vendor`, `probe()`, `channels()`, `headlessCommand()`,
+`interactiveCommand()`, `invoke()`, `parse()`, plus the optional `listModels`/`resumeCommand`
+capabilities other adapters use when the CLI supports them. Use an existing adapter as the
+template (`src/adapters/codex.ts` is a good starting shape), then register it with one line in
+`src/adapters/registry.ts`'s `allAdapters()` — append it, don't insert it in the middle, since
+same-tier routing ties resolve by discovery order. No other file needs to know a new adapter
+exists.
+
+### Filing defects
+
+Abnormalities found during a real engagement (not routine bugs — surprising or systemic
+behavior) are logged as a numbered entry (`OBS-NN`) in `.planning/OBSERVATIONS.md`, with a status
+(`OPEN` / `CLOSED-FIXED` / `CLOSED-MITIGATED`) and, once fixed, the spec/commit that closed it.
+That file is the standing abnormality ledger for this repo — read it before assuming a rough edge
+is new.
+
 Design spec: `docs/superpowers/specs/2026-07-07-drover-design.md`.
 
 ## License

package/dist/adapters/cursor-agent.js

@@ -49,7 +49,7 @@ export const cursorAgent = {
     // print-only). Doctor names the dialog; the daemon auto-answers it via trustDialog once per slot.
     trust: () => ({
         status: "action-required",
-        command: 'accept the cursor-agent "Workspace Trust Required" dialog (Enter) — drovr auto-answers once per slot',
+        command: 'accept the cursor-agent "Workspace Trust Required" dialog (Enter) — tickmarkr auto-answers once per slot',
     }),
     trustDialog: CURSOR_TRUST_DIALOG,
     // v1.5 MODEL-01: fail OPEN to [] (advisory detection, unlike gates). --list-models may touch the

package/dist/adapters/model-lints.js

@@ -1,7 +1,7 @@
 import { MODEL_ID_RE } from "./types.js";
 // date the tiers seeds were last live-verified (Phase 6/7 reseed) — surfaced when an adapter has no list surface.
 export const SEED_STAMPED = "2026-07-09";
-// knowledge past this age gets a "rerun drovr doctor" nudge (BLOCKED_POLL_MS-style named constant).
+// knowledge past this age gets a "rerun tickmarkr doctor" nudge (BLOCKED_POLL_MS-style named constant).
 export const MODEL_STALE_DAYS = 30;
 const DAY_MS = 86400000;
 // cursor-agent 2026.07.08 reports 193 mostly-parameterized ids (e.g. gpt-5.3-codex-high-fast); filter the `auto`
@@ -26,7 +26,7 @@ export function modelLints(cfg, health, adapters) {
         const detected = h?.models ?? []; // MANDATORY default: pre-v1.5 files lack a populated models array
         if (detected.length === 0) {
             if (h?.installed)
-                lints.push(`${id}: no detection data — run drovr doctor`);
+                lints.push(`${id}: no detection data — run tickmarkr doctor`);
             continue; // no data to diff or age
         }
         const configured = Object.keys(cfg.tiers[id].models);
@@ -45,7 +45,7 @@ export function modelLints(cfg, health, adapters) {
         if (at) {
             const days = Math.floor((Date.now() - Date.parse(at)) / DAY_MS); // completed days — never overstate age
             if (days >= MODEL_STALE_DAYS)
-                lints.push(`${id}: model knowledge is ${days} days old — rerun drovr doctor`);
+                lints.push(`${id}: model knowledge is ${days} days old — rerun tickmarkr doctor`);
         }
     }
     return lints;

package/dist/adapters/prompt.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { renderAcceptanceItem } from "../graph/schema.js";
 export function buildTaskPrompt(task, feedback = "", nonce = "") {
     const list = (xs) => xs.map((x) => `- ${x}`).join("\n");
-    return `You are an autonomous coding worker dispatched by drovr into an isolated git worktree.
+    return `You are an autonomous coding worker dispatched by tickmarkr into an isolated git worktree.
 
 ## Task ${task.id}: ${task.title}
 Goal: ${task.goal}

package/dist/cli/commands/approve.js

@@ -40,7 +40,7 @@ export async function approve(argv, cwd = process.cwd()) {
         via: "cli",
         ...(capPark ? { release: ATTEMPT_CAP_RELEASE } : {}),
     });
-    return `approved ${taskId} in ${runId} — by ${by}; run \`drovr resume ${runId}\` to dispatch it`;
+    return `approved ${taskId} in ${runId} — by ${by}; run \`tickmarkr resume ${runId}\` to dispatch it`;
 }
 // hand-parsed argv — no CLI framework (house style). Flags --by <name> and --reason <text>; positionals
 // are runId then taskId. Throws usage on missing positionals (mirrors resume.ts/unlock.ts).
@@ -53,12 +53,12 @@ function parseArgs(argv) {
         if (a === "--by") {
             by = argv[++i];
             if (!by)
-                throw new Error("usage: drovr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
+                throw new Error("usage: tickmarkr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
         }
         else if (a === "--reason") {
             reason = argv[++i];
             if (!reason)
-                throw new Error("usage: drovr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
+                throw new Error("usage: tickmarkr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
         }
         else {
             positionals.push(a);
@@ -66,7 +66,7 @@ function parseArgs(argv) {
     }
     const [runId, taskId] = positionals;
     if (!runId || !taskId) {
-        throw new Error("usage: drovr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
+        throw new Error("usage: tickmarkr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
     }
     return { runId, taskId, by: by ?? userInfo().username, reason };
 }

package/dist/cli/commands/compile.js

@@ -11,7 +11,7 @@ export async function compile(argv, cwd = process.cwd()) {
     });
     const src = positionals[0];
     if (!src)
-        throw new Error("usage: drovr compile <spec-dir-or-md> [--type speckit|prd|gsd|native]");
+        throw new Error("usage: tickmarkr compile <spec-dir-or-md> [--type speckit|prd|gsd|native]");
     // resolve against the target repo, not the process cwd (the CLI test passes a tmp repo)
     const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd);
     // HARD-01: a compile clobbering a running daemon's graph.json is the same last-write-wins race

package/dist/cli/commands/doctor.js

@@ -1,10 +1,40 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { allAdapters, probeAll, probeModels, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { drovrDir } from "../../graph/graph.js";
 import { modelLints, suggestOverlay } from "../../adapters/model-lints.js";
 import { loadConfig } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
+// same gate + palette as status's audit-ledger frame: styled only on a real TTY, plain otherwise
+const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const color = (text, code) => `\x1b[${code}m${text}\x1b[0m`;
+// TTY-only line pass: color the verdict symbols, dim the chrome (section titles, parentheticals,
+// n/a rows). Padding is untouched — every rewrite swaps equal-width text or wraps it in ANSI.
+function stylize(out) {
+    if (!visual())
+        return out;
+    const rule = color("─".repeat(Math.min(process.stdout.columns ?? 80, 100)), 2);
+    return out.split("\n").map((line) => {
+        if (line.startsWith("tickmarkr doctor"))
+            return ` ${color("✓", 32)} ${color("tickmarkr", 1)} doctor ${color("· capability matrix", 2)}\n${rule}`;
+        if (/^(workspace trust|model status|model drift)/.test(line))
+            return color(line, 2);
+        return line
+            .replace(/^(\s+)✓ /, (_, s) => `${s}${color("✓", 32)} `)
+            .replace(/^(\s+)✗ /, (_, s) => `${s}${color("✗", 31)} `)
+            .replace(/^(\s+)! /, (_, s) => `${s}${color("!", 33)} `)
+            .replace(/^(\s+)= (.*)$/, (_, s, rest) => `${s}${color(`= ${rest}`, 2)}`)
+            .replace(/(\(auth assumed; verified at dispatch \(failover on auth\/quota errors\)\))/, (m) => color(m, 2))
+            .replace(/\bauthed\b(?!:)/, color("authed", 32))
+            .replace(/\bunauthed:/, color("unauthed:", 33));
+    }).join("\n");
+}
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters()) {
     const cfg = loadConfig(cwd);
+    // stderr, live: auth probes are real LLM calls (up to 30s per configured model) and the CLI
+    // otherwise prints nothing until the end — silence here reads as a hang (v1.33.1)
+    console.error("probing installed agent CLIs — one short LLM call per configured model, may take a minute...");
     const health = await probeAll(adapters);
     // MODEL-02: detect models where the adapter exposes a list surface, BEFORE writing doctor.json (write once, below).
     // Fail OPEN — the inverse of gates' fail-closed: detection is advisory, so a broken list surface NEVER fails doctor.
@@ -67,8 +97,20 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     if (servable.length)
         rows.push(`  ! ${servabilityLine(servable)}`);
     // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, drovr NEVER applies it.
+    // TTY gets a one-line summary + the fragment as a file (the full dump drowned everything else,
+    // v1.33.1 onboarding); machine/CI surface keeps the inline dump — layout is pinned by tests.
     const frag = suggestOverlay(cfg, health, adapters);
-    const drift = frag ? `\nmodel drift — paste-ready overlay (advisory; drovr never applies):\n${frag}` : "";
+    let drift = "";
+    if (frag) {
+        if (visual()) {
+            const overlayPath = join(drovrDir(cwd), "doctor-overlay.yaml");
+            writeFileSync(overlayPath, frag);
+            drift = `\nmodel drift: unclassified models detected — paste-ready overlay written to ${overlayPath} (advisory; tickmarkr never applies it)`;
+        }
+        else {
+            drift = `\nmodel drift — paste-ready overlay (advisory; tickmarkr never applies):\n${frag}`;
+        }
+    }
     // T4: model-status table — one row per CLASSIFIED model (tiers config) with tier, auth verdict
     // (reason + date when unauthed), operator-deny flag, and prefer rank across the routing map.
     // Unclassified listed models (detected via listModels but never tiered) compress to one count line
@@ -99,5 +141,5 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         return rows;
     });
     const modelSummary = modelStatus.length ? `\nmodel status:\n${modelStatus.join("\n")}` : "";
-    return `drovr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote .drovr/doctor.json`;
+    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote .drovr/doctor.json`);
 }

package/dist/cli/commands/init.js

@@ -1,12 +1,78 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { configTemplate, globalConfigDir } from "../../config/config.js";
 import { specTemplate } from "../../compile/native.js";
 import { drovrDir } from "../../graph/graph.js";
 import { doctor } from "./doctor.js";
+const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto"];
+const DOCS_BEGIN = "<!-- tickmarkr:agent-docs begin -->";
+const DOCS_END = "<!-- tickmarkr:agent-docs end -->";
+const AGENT_DOCS = `${DOCS_BEGIN}
+## tickmarkr
+
+tickmarkr turns repository specs into isolated, independently verified agent work. Use \`/tickmarkr-loop\` for one spec or \`/tickmarkr-auto\` for several.
+
+Loop: \`tickmarkr compile <spec>\` → \`tickmarkr plan\` → \`tickmarkr run\` → \`tickmarkr report <runId> --md\`.
+
+- Never run two tickmarkr runs in the same repository concurrently.
+- Never merge tickmarkr work directly to main; new runs consolidate on \`tickmarkr/<runId>\`.
+- Fix source specs instead of editing generated graphs.
+- Never trust a worker's completion claim; gates independently verify the work.
+- Treat missing or unparseable results as failures.
+${DOCS_END}
+`;
+async function installAgentFiles(cwd, force, docs, notes) {
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    let prompt;
+    const confirm = async (question) => {
+        if (!interactive)
+            return false;
+        prompt ??= createInterface({ input: process.stdin, output: process.stdout });
+        return /^(?:y|yes)$/i.test((await prompt.question(`${question} [y/N] `)).trim());
+    };
+    try {
+        for (const skill of AGENT_SKILLS) {
+            const dest = join(cwd, ".claude", "skills", skill, "SKILL.md");
+            const exists = existsSync(dest);
+            if (exists && !force && !(await confirm(`Overwrite ${dest}?`))) {
+                notes.push(`skipped existing ${dest}; pass --force to overwrite it`);
+                continue;
+            }
+            mkdirSync(join(cwd, ".claude", "skills", skill), { recursive: true });
+            writeFileSync(dest, readFileSync(new URL(`../../../skills/${skill}/SKILL.md`, import.meta.url)), exists ? undefined : { flag: "wx" });
+            notes.push(`${exists ? "overwrote" : "wrote"} ${dest}`);
+        }
+        const claude = join(cwd, "CLAUDE.md");
+        const agents = join(cwd, "AGENTS.md");
+        const docPath = existsSync(claude) || !existsSync(agents) ? claude : agents;
+        const current = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
+        if (current.includes(DOCS_BEGIN) || current.includes(DOCS_END)) {
+            notes.push(`kept existing tickmarkr agent docs in ${docPath}`);
+        }
+        else if (docs || await confirm(`Append tickmarkr agent docs to ${docPath}?`)) {
+            appendFileSync(docPath, `${current ? current.endsWith("\n") ? "\n" : "\n\n" : ""}${AGENT_DOCS}`);
+            notes.push(`appended tickmarkr agent docs to ${docPath}`);
+        }
+        else {
+            notes.push(`skipped agent docs for ${docPath}; pass --docs to append them`);
+        }
+    }
+    finally {
+        prompt?.close();
+    }
+}
 export async function init(argv, cwd = process.cwd()) {
-    const { values } = parseArgs({ args: argv, options: { "global-dir": { type: "string" } } });
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            "global-dir": { type: "string" },
+            agent: { type: "boolean" },
+            force: { type: "boolean" },
+            docs: { type: "boolean" },
+        },
+    });
     const gdir = values["global-dir"] ?? globalConfigDir();
     mkdirSync(gdir, { recursive: true });
     const notes = [];
@@ -19,14 +85,19 @@ export async function init(argv, cwd = process.cwd()) {
             notes.push(`kept existing ${p}`);
         }
     }
-    const specPath = join(cwd, "drovr.spec.md");
-    if (!existsSync(specPath)) {
-        writeFileSync(specPath, specTemplate());
-        notes.push(`wrote ${specPath}`);
+    const specPath = join(cwd, "tickmarkr.spec.md");
+    if (existsSync(specPath)) {
+        notes.push(`kept existing ${specPath}`);
+    }
+    else if (existsSync(join(cwd, "drovr.spec.md"))) {
+        notes.push(`kept existing ${join(cwd, "drovr.spec.md")}`);
     }
     else {
-        notes.push(`kept existing ${specPath}`);
+        writeFileSync(specPath, specTemplate());
+        notes.push(`wrote ${specPath}`);
     }
+    if (values.agent)
+        await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
     const doc = await doctor([], cwd);
-    return `${notes.join("\n")}\n${doc}\nnext: edit drovr.spec.md, then drovr compile drovr.spec.md && drovr plan && drovr run`;
+    return `${notes.join("\n")}\n${doc}\nnext: edit tickmarkr.spec.md, then tickmarkr compile tickmarkr.spec.md && tickmarkr plan && tickmarkr run`;
 }

package/dist/cli/commands/plan.js

@@ -21,7 +21,7 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     // output byte-identical to today.
     const profile = loadRoutingProfile(cwd, cfg, { preview: true });
     let deviations = 0;
-    const lines = [`drovr plan — dry run (${channels.length} channels available)`, ""];
+    const lines = [`tickmarkr plan — dry run (${channels.length} channels available)`, ""];
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         lines.push(exclusionLine(excluded), "");
@@ -38,7 +38,7 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     if (cached) {
         const age = doctorAgeMs(cwd);
         if (age !== null && age > DOCTOR_STALE_MS) {
-            lines.push(`doctor.json is ${Math.floor(age / 3_600_000)}h old — run 'drovr doctor' to refresh (servability/auth may have changed)`, "");
+            lines.push(`doctor.json is ${Math.floor(age / 3_600_000)}h old — run 'tickmarkr doctor' to refresh (servability/auth may have changed)`, "");
         }
     }
     // HYG-07(a)/T2 pin honesty: append the drop reason when a pin/miss message names a filtered channel —

package/dist/cli/commands/profile.js

@@ -32,7 +32,7 @@ function show(cwd) {
     const cursor = readProfileCursor(cwd);
     const p = loadRoutingProfile(cwd, cfg, { preview: true });
     const header = [
-        `drovr profile`,
+        `tickmarkr profile`,
         `  routing.learned: ${cfg.routing.learned}${cfg.routing.learned === "off" ? " (preview — routing is inert)" : ""}`,
         `  runs window: ${RUNS_WINDOW}`,
         ...(cursor ? [`  reset cursor: ${cursor}`] : []),

package/dist/cli/commands/report.js

@@ -293,9 +293,9 @@ export async function report(argv, cwd = process.cwd()) {
         options: { md: { type: "boolean" } },
         allowPositionals: true,
     });
-    const runId = positionals[0] ?? Journal.latestRunId(cwd);
+    const runId = positionals[0] ?? Journal.latestRunId(cwd, { withJournal: true });
     if (!runId)
-        throw new Error("no runs found — usage: drovr report <run-id> [--md]");
+        throw new Error("no runs found — usage: tickmarkr report <run-id> [--md]");
     const j = Journal.open(cwd, runId);
     const events = j.read();
     if (values.md) {

package/dist/cli/commands/resume.js

@@ -5,7 +5,7 @@ import { formatJournalNarration } from "../../run/journal.js";
 export async function resume(argv, cwd = process.cwd()) {
     const runId = argv[0];
     if (!runId)
-        throw new Error("usage: drovr resume <run-id>");
+        throw new Error("usage: tickmarkr resume <run-id>");
     const s = await runDaemon(cwd, { runId, resume: true, driver: pickDriver(loadConfig(cwd)), narrate: (event) => console.log(formatJournalNarration(event)) });
     return `resumed ${s.runId} — ${formatSummary(s)}`;
 }

package/dist/cli/commands/scope.js

@@ -10,7 +10,7 @@ export async function scope(argv, cwd = process.cwd(), adapters = allAdapters(),
         allowPositionals: true,
     });
     if (positionals.length !== 1)
-        throw new Error("usage: drovr scope <intent-file> [--force]");
+        throw new Error("usage: tickmarkr scope <intent-file> [--force]");
     const source = positionals[0];
     const intentFile = isAbsolute(source) ? source : join(cwd, source);
     const result = await scopeIntent(intentFile, cwd, {

package/dist/cli/commands/status.d.ts

@@ -1,9 +1,5 @@
-import { type Task } from "../../graph/schema.js";
-import { type JournalEvent } from "../../run/journal.js";
 export type StatusOpts = {
     iterations?: number;
     sleep?: (ms: number) => Promise<void>;
 };
-/** Derive the live phase column for one task. Counts only that task's events since its last dispatch/escalation. */
-export declare const derivePhase: (task: Task, events: JournalEvent[], channel?: string) => string;
 export declare function status(argv: string[], cwd?: string, opts?: StatusOpts): Promise<string>;