tickmarkr 1.68.0 → 1.69.0

package/dist/run/daemon.js

@@ -16,6 +16,7 @@ import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { cleanupRunWorktrees, gitHead, linkNodeModules, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { runInteractiveSeed } from "./interactive-seed.js";
 import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
@@ -601,17 +602,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                     : cfg.visibility.worker === "interactive" && driver.interactive
                         ? adapter.interactiveCommand(promptFile, assignment.model)
                         : null;
-                if (cfg.visibility.worker === "interactive" && icmd === null && !modeFallbackNoted) {
+                // v1.69 T6: adapters that declare interactiveSeed launch the real TUI and inject the prompt as a
+                // user turn; they do NOT need the argv-seeding surface that interactiveCommand represents.
+                const hasSeed = retryMode !== "resume" && cfg.visibility.worker === "interactive" && driver.interactive && !!adapter.interactiveSeed;
+                if (cfg.visibility.worker === "interactive" && icmd === null && !hasSeed && !modeFallbackNoted) {
                     modeFallbackNoted = true;
                     journal.append("worker-mode-fallback", t.id, { reason: driver.interactive ? "adapter" : "driver" });
                 }
-                const interactive = icmd !== null;
+                const interactive = icmd !== null || hasSeed;
                 // OBS-85 (v1.62 T1): both dispatch branches deliver ONE short script invocation — banner,
                 // adapter command, and nonce exit marker live in a per-attempt script beside the prompt
                 // artifact (the same paneDispatchCommand pattern judge/review/consult dispatches use). The
                 // delivered pane line carries no command substitution and no trailing shell text, so paste
                 // timing can never interleave a `$(…)` with what follows it (the codex corruption class).
-                const workerCmd = interactive ? icmd : adapter.invoke(t, wt, assignment, { promptFile }).command;
+                const workerCmd = interactive
+                    ? (hasSeed ? ":" : icmd)
+                    : adapter.invoke(t, wt, assignment, { promptFile }).command;
                 const dispatchScript = promptFile.replace(/\.md$/, ".sh");
                 writeFileSync(dispatchScript, [
                     "export BASH_SILENCE_DEPRECATION_WARNING=1",
@@ -659,117 +665,134 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let exitCode;
                 let timedOut = false;
                 let settleParsed;
+                let seedResult;
                 if (interactive) {
                     // v1.2 interactive: the TUI doesn't exit on completion — the trailer is the finish line.
                     // The exit wrapper still fires if the TUI dies (crash/quit): fast-fail instead of burning the timeout.
-                    await driver.run(slot, paneDispatchCommand(dispatchScript));
-                    let paged = false;
-                    // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
-                    // Any other blocked/idle dialog still pages the operator (paged latch below).
-                    let trustAnswered = false;
                     finished = false;
                     exitCode = null;
-                    output = await driver.read(slot, 1000);
-                    // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
-                    // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
-                    const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
-                    // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
-                    // trailer detection, harvest, paging, and quota checks all read the raw pane.
-                    let lastStallSnapshot = normalizeStallSnapshot(output);
-                    let lastOutputAt = Date.now();
-                    while (Date.now() - lastOutputAt < stallWindowMs) {
-                        const sliceStart = Date.now();
-                        const remaining = stallWindowMs - (sliceStart - lastOutputAt);
-                        const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
-                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
-                            // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
-                            // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
-                            // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
-                            output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
-                            finished = new RegExp(trailerPattern(nonce)).test(output);
-                            const exit = exitRe.exec(output);
-                            if (finished || exit) {
-                                exitCode = exit ? Number(exit[1]) : null; // null ⇔ the TUI is still alive
-                                await sampleContext(); // final poll-seam sample before leaving the wait
-                                break;
-                            }
-                        }
-                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
-                        if (currentStallSnapshot !== lastStallSnapshot) {
-                            lastStallSnapshot = currentStallSnapshot;
-                            lastOutputAt = Date.now();
-                        }
-                        // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
-                        await sampleContext();
-                        // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
-                        // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
-                        // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
-                        const st = paged ? "" : await driver.status(slot);
-                        if (!paged && (st === "blocked" || st === "idle")) {
-                            // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
-                            // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
-                            if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
-                                try {
-                                    const paneText = await driver.read(slot, 80);
-                                    if (matchesTrustDialog(paneText, adapter.trustDialog)) {
-                                        trustAnswered = true;
-                                        // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
-                                        // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
-                                        journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
-                                        await driver.sendKey(slot, adapter.trustDialog.key);
-                                        const spent = Date.now() - sliceStart;
-                                        if (spent < slice)
-                                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
-                                        continue; // do not page — keep waiting for the trailer
-                                    }
-                                }
-                                catch {
-                                    /* read/send failed — fall through to page the operator */
-                                }
-                            }
-                            paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
-                            const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
-                            await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
-                        }
-                        // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
-                        const spent = Date.now() - sliceStart;
-                        if (spent < slice)
-                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                    if (adapter.interactiveSeed) {
+                        // v1.69 T6: launch the real TUI without a prompt, wait for readiness, inject one seed turn,
+                        // then fall through to the normal trailer harvest. A failed seed is recorded as a finished
+                        // failure rather than allowed to race the trailer wait.
+                        seedResult = await runInteractiveSeed({ driver, slot, adapter, assignment, promptFile, taskTimeoutMinutes });
+                        output = seedResult.output;
                     }
-                    if (!finished && exitCode === null) {
-                        // timed out (or only ever saw false positives): harvest whatever the pane holds now
-                        timedOut = Date.now() - lastOutputAt >= stallWindowMs;
+                    else {
+                        await driver.run(slot, paneDispatchCommand(dispatchScript));
                         output = await driver.read(slot, 1000);
-                        finished = new RegExp(trailerPattern(nonce)).test(output);
-                        const exit = exitRe.exec(output);
-                        exitCode = exit ? Number(exit[1]) : null;
                     }
-                    if (finished) {
-                        await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
-                        output = await driver.read(slot, 1000);
+                    if (seedResult?.seedFailed) {
+                        finished = false;
                     }
-                    // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
-                    // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
-                    // the existing pane-read seam once or twice before recording a malformed-trailer cause.
-                    if (interactive) {
+                    else {
+                        let paged = false;
+                        // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
+                        // Any other blocked/idle dialog still pages the operator (paged latch below).
+                        let trustAnswered = false;
+                        finished = false;
+                        exitCode = null;
+                        // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
+                        // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
                         const stallWindowMs = taskTimeoutMinutes * 60_000;
-                        const settleDeadline = attemptStart + stallWindowMs;
-                        const settleDelayMs = 1_000;
-                        const maxSettleRetries = 2;
-                        let settleTries = 0;
-                        settleParsed = adapter.parse(output, nonce);
-                        while (settleParsed.summary === UNPARSEABLE_TRAILER_SUMMARY && settleTries < maxSettleRetries) {
-                            const remaining = settleDeadline - Date.now();
-                            if (remaining <= 0)
-                                break;
-                            await new Promise((r) => setTimeout(r, Math.min(settleDelayMs, remaining)));
+                        // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
+                        // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
+                        // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                        let lastStallSnapshot = normalizeStallSnapshot(output);
+                        let lastOutputAt = Date.now();
+                        while (Date.now() - lastOutputAt < stallWindowMs) {
+                            const sliceStart = Date.now();
+                            const remaining = stallWindowMs - (sliceStart - lastOutputAt);
+                            const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
+                                // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
+                                // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
+                                // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
+                                output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
+                                finished = new RegExp(trailerPattern(nonce)).test(output);
+                                const exit = exitRe.exec(output);
+                                if (finished || exit) {
+                                    exitCode = exit ? Number(exit[1]) : null; // null ⇔ the TUI is still alive
+                                    await sampleContext(); // final poll-seam sample before leaving the wait
+                                    break;
+                                }
+                            }
+                            const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                            if (currentStallSnapshot !== lastStallSnapshot) {
+                                lastStallSnapshot = currentStallSnapshot;
+                                lastOutputAt = Date.now();
+                            }
+                            // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
+                            await sampleContext();
+                            // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
+                            // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
+                            // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
+                            const st = paged ? "" : await driver.status(slot);
+                            if (!paged && (st === "blocked" || st === "idle")) {
+                                // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
+                                // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
+                                if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
+                                    try {
+                                        const paneText = await driver.read(slot, 80);
+                                        if (matchesTrustDialog(paneText, adapter.trustDialog)) {
+                                            trustAnswered = true;
+                                            // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
+                                            // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
+                                            journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
+                                            await driver.sendKey(slot, adapter.trustDialog.key);
+                                            const spent = Date.now() - sliceStart;
+                                            if (spent < slice)
+                                                await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                                            continue; // do not page — keep waiting for the trailer
+                                        }
+                                    }
+                                    catch {
+                                        /* read/send failed — fall through to page the operator */
+                                    }
+                                }
+                                paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
+                                const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
+                                await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
+                            }
+                            // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
+                            const spent = Date.now() - sliceStart;
+                            if (spent < slice)
+                                await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                        }
+                        if (!finished && exitCode === null) {
+                            // timed out (or only ever saw false positives): harvest whatever the pane holds now
+                            timedOut = Date.now() - lastOutputAt >= stallWindowMs;
                             output = await driver.read(slot, 1000);
-                            settleParsed = adapter.parse(output, nonce);
-                            settleTries++;
+                            finished = new RegExp(trailerPattern(nonce)).test(output);
+                            const exit = exitRe.exec(output);
+                            exitCode = exit ? Number(exit[1]) : null;
                         }
-                        if (settleParsed.summary !== UNPARSEABLE_TRAILER_SUMMARY) {
-                            finished = settleParsed.summary !== NO_TRAILER_SUMMARY;
+                        if (finished) {
+                            await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
+                            output = await driver.read(slot, 1000);
+                        }
+                        // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
+                        // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
+                        // the existing pane-read seam once or twice before recording a malformed-trailer cause.
+                        if (interactive) {
+                            const stallWindowMs = taskTimeoutMinutes * 60_000;
+                            const settleDeadline = attemptStart + stallWindowMs;
+                            const settleDelayMs = 1_000;
+                            const maxSettleRetries = 2;
+                            let settleTries = 0;
+                            settleParsed = adapter.parse(output, nonce);
+                            while (settleParsed.summary === UNPARSEABLE_TRAILER_SUMMARY && settleTries < maxSettleRetries) {
+                                const remaining = settleDeadline - Date.now();
+                                if (remaining <= 0)
+                                    break;
+                                await new Promise((r) => setTimeout(r, Math.min(settleDelayMs, remaining)));
+                                output = await driver.read(slot, 1000);
+                                settleParsed = adapter.parse(output, nonce);
+                                settleTries++;
+                            }
+                            if (settleParsed.summary !== UNPARSEABLE_TRAILER_SUMMARY) {
+                                finished = settleParsed.summary !== NO_TRAILER_SUMMARY;
+                            }
                         }
                     }
                 }

package/dist/run/interactive-seed.d.ts

@@ -0,0 +1,15 @@
+import type { Assignment, WorkerAdapter } from "../adapters/types.js";
+import type { ExecutorDriver, Slot } from "../drivers/types.js";
+export interface InteractiveSeedResult {
+    output: string;
+    seedFailed: boolean;
+    seedError?: string;
+}
+export declare function runInteractiveSeed(opts: {
+    driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;
+    slot: Slot;
+    adapter: WorkerAdapter;
+    assignment: Assignment;
+    promptFile: string;
+    taskTimeoutMinutes: number;
+}): Promise<InteractiveSeedResult>;

package/dist/run/interactive-seed.js

@@ -0,0 +1,25 @@
+// v1.69 T6: launch-then-seed handoff for adapters whose real TUI cannot be argv-seeded.
+// Both the launch command and the seed line are delivered through the driver's existing `run`
+// primitive (pane-run on herdr). After the seed line is injected we read the pane back and
+// treat a seed that is still sitting in the input box as a hard failure (OBS-105 discipline).
+export async function runInteractiveSeed(opts) {
+    const seed = opts.adapter.interactiveSeed;
+    await opts.driver.run(opts.slot, seed.launch(opts.assignment.model));
+    const ready = await opts.driver.waitOutput(opts.slot, seed.readinessMatch, opts.taskTimeoutMinutes * 60_000);
+    if (!ready) {
+        const output = await opts.driver.read(opts.slot, 1000);
+        return { output, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+    }
+    const seedText = seed.seedLine(opts.promptFile);
+    await opts.driver.run(opts.slot, seedText);
+    let output = "";
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await new Promise((r) => setTimeout(r, 200));
+        output = await opts.driver.read(opts.slot, 1000);
+        const bottom = output.trimEnd().split("\n").pop() ?? "";
+        if (!bottom.includes(seedText)) {
+            return { output, seedFailed: false };
+        }
+    }
+    return { output, seedFailed: true, seedError: "seed line never left the input box" };
+}

package/fixtures/eval/canary/solution/a.txt

@@ -0,0 +1 @@
+canary-verified

package/fixtures/eval/canary/spec.md

@@ -0,0 +1,8 @@
+<!-- tickmarkr:spec -->
+# Judge canary
+
+## T1: Canary verification marker
+- goal: The repository contains a verified canary marker
+- shape: implement
+- acceptance:
+  - judge: The file a.txt contains the exact text "canary-verified".

package/fixtures/eval/canary/start/a.txt

@@ -0,0 +1 @@
+canary-start

package/fixtures/eval/sample/solution/a.txt

@@ -0,0 +1 @@
+hello from solution

package/fixtures/eval/sample/spec.md

@@ -0,0 +1,8 @@
+<!-- tickmarkr:spec -->
+# Eval fixture sample
+
+## T1: Solution text is present
+- goal: The fixture reference content is produced
+- shape: implement
+- acceptance:
+  - command: [ "$(cat a.txt)" = "hello from solution" ]

package/fixtures/eval/sample/start/a.txt

@@ -0,0 +1 @@
+hello from start

package/fixtures/gsd-sample/07-live-check/07-01-PLAN.md

@@ -0,0 +1,42 @@
+---
+phase: 07-live-check
+plan: "01"
+type: execute
+wave: 1
+depends_on: []
+files_modified:
+  - src/**
+autonomous: true
+must_haves:
+  truths:
+    - "truth A holds in the shipped artifact"
+  artifacts:
+    - path: "src/out.js"
+      provides: "the thing"
+---
+
+<objective>
+Implement the first objective sentence. Additional prose that is not the title.
+</objective>
+
+<context>
+@.planning/PROJECT.md
+@$HOME/.claude/get-shit-done/workflows/execute-plan.md
+@~/somewhere/outside.md
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Build the widget</name>
+  <action>do the thing</action>
+  <verify>look at it</verify>
+  <done>widget builds green</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Wire the widget</name>
+  <done>widget is wired and demoed</done>
+</task>
+
+</tasks>

package/fixtures/gsd-sample/07-live-check/07-02-PLAN.md

@@ -0,0 +1,21 @@
+---
+phase: 07-live-check
+plan: "02"
+type: execute
+wave: 2
+depends_on: ["07-01"]
+files_modified:
+  - docs/**
+autonomous: true
+---
+
+<objective>
+Document the widget. Trailing sentence.
+</objective>
+
+<tasks>
+<task type="checkpoint:human-action" gate="blocking">
+  <name>Task 1: Operator reviews the docs</name>
+  <done>operator approved the docs page</done>
+</task>
+</tasks>

package/fixtures/gsd-sample/07-live-check/07-03-PLAN.md

@@ -0,0 +1,18 @@
+---
+phase: 07-live-check
+plan: "03"
+type: execute
+depends_on: ["07-02"]
+autonomous: true
+---
+
+<objective>
+Already-finished work. Done earlier.
+</objective>
+
+<tasks>
+<task type="auto">
+  <name>Task 1: old work</name>
+  <done>previously completed</done>
+</task>
+</tasks>

package/fixtures/gsd-sample/07-live-check/07-03-SUMMARY.md

@@ -0,0 +1 @@
+# done earlier

package/fixtures/missing-mandatory-gate.native.md

@@ -0,0 +1,10 @@
+<!-- tickmarkr:spec -->
+
+## T1: Missing mandatory build gate
+- gates:
+  - test
+  - lint
+  - evidence
+  - scope
+- acceptance:
+  - compilation fails loudly naming build

package/fixtures/sample-pin.prd.md

@@ -0,0 +1,18 @@
+# Sample PRD: pinned delivery
+
+## T1: Implement pinned compiler work
+- shape: implement
+- complexity: 7
+- files: src/compiler.ts, src/types.ts
+- pin: claude-code sonnet
+- acceptance:
+  - compiler returns a graph
+
+## T2: Verify pinned compiler work
+- shape: tests
+- deps: T1
+- files: tests/compiler.test.ts
+- humanGate: true
+- acceptance:
+  - tests reject malformed input
+  - reviewer approves the output

package/fixtures/sample.native.md

@@ -0,0 +1,35 @@
+<!-- drovr:spec -->
+# Native spec: compiler delivery
+
+## T1: Build the native compiler
+- goal: Compile the complete native task surface
+- shape: implement
+- deps: none
+- files: src/compile/native.ts, src/compile/index.ts
+- context: docs/native.md, src/graph/schema.ts
+- complexity: 8
+- humanGate: true
+- pin: claude-code opus
+- floor: frontier
+- gates:
+  - build
+  - test
+  - lint
+  - evidence
+  - scope
+  - acceptance
+- acceptance:
+  - every native field reaches the graph
+  - malformed fields fail loudly
+
+## T2: Test native detection
+- goal: Keep native and generic markdown routing distinct
+- shape: tests
+- deps: T1
+- files: tests/compile/native.test.ts
+- context: fixtures/sample.native.md
+- complexity: 3
+- humanGate: false
+- acceptance:
+  - marked markdown selects native
+  - marker-less markdown stays PRD

package/fixtures/sample.prd.md

@@ -0,0 +1,22 @@
+# Sample PRD: tiny greeter
+
+## T1: Implement greet(name) in src/greet.js
+- shape: implement
+- complexity: 3
+- files: src/**
+- acceptance:
+  - greet("drover") returns a string containing "drover"
+  - module exports a single function
+
+## T2: Cover greet with tests
+- deps: T1
+- files: test/**
+- acceptance:
+  - tests fail when greet drops the name
+  - npm test exits 0
+
+## T3: Document usage in README
+- deps: T1
+- humanGate: true
+- acceptance:
+  - README shows an executable example

package/fixtures/speckit-sample/tasks.md

@@ -0,0 +1,20 @@
+# Tasks: Sample Feature
+
+## Phase 1: Setup
+- [ ] T001 Create project structure in src/
+  - acceptance: src/ and tests/ directories exist with entry points
+  - files: src/**, tests/**
+  - shape: chore
+
+## Phase 2: Core
+- [ ] T002 [P] Implement token refresh in src/auth/refresh.ts
+  - acceptance: expired token triggers exactly one refresh attempt
+  - acceptance: refresh failure surfaces a typed error
+  - files: src/auth/**
+  - complexity: 7
+- [ ] T003 [P] Implement session store in src/auth/store.ts
+  - acceptance: sessions persist across restarts
+  - files: src/auth/**
+- [ ] T004 Write integration tests for auth flow
+  - acceptance: happy path and refresh-failure path covered
+  - files: tests/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.68.0",
+  "version": "1.69.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,8 @@
   "files": [
     "dist",
     "schema",
-    "skills"
+    "skills",
+    "fixtures"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",