tickmarkr 1.97.0 → 2.0.0

package/dist/brand.d.ts

@@ -48,6 +48,34 @@ export declare const TOKENS: {
     readonly dim: (s: string) => string;
     readonly bold: (s: string) => string;
 };
+/** Exact operator-approved live colours. Values stay hex so the authority is inspectable. */
+export declare const LIVE_PALETTE: {
+    /** muted teal — brand identity and pass */
+    readonly brand: "#90C4A4";
+    /** cornflower blue — running state and information */
+    readonly running: "#5A76AE";
+    /** ice — primary text */
+    readonly text: "#E6FDFF";
+    /** cloud — chrome and secondary text */
+    readonly chrome: "#D9D7DD";
+    /** amethyst — attention and failure */
+    readonly attention: "#B07BAC";
+};
+export type LiveRole = keyof typeof LIVE_PALETTE;
+/** Semantic live tokens. Aliases are intentional; no token introduces a sixth colour. */
+export declare const LIVE: {
+    readonly brand: (s: string) => string;
+    readonly pass: (s: string) => string;
+    readonly running: (s: string) => string;
+    readonly information: (s: string) => string;
+    readonly text: (s: string) => string;
+    readonly primaryText: (s: string) => string;
+    readonly chrome: (s: string) => string;
+    readonly secondaryText: (s: string) => string;
+    readonly attention: (s: string) => string;
+    readonly failure: (s: string) => string;
+    readonly chip: (s: string) => string;
+};
 /**
  * The glyph vocabulary — plain characters only; color layers on via tokens so
  * shape survives NO_COLOR. Bracket toggles ([x]/[ ]) are forbidden on every surface.

package/dist/brand.js

@@ -122,6 +122,47 @@ export const dim = sgr("2");
 export const bold = sgr("1");
 /** Every semantic color token, for sweeps: each is TTY-gated and NO_COLOR-aware. */
 export const TOKENS = { brand, brandChip, ok, fail, warn, dim, bold };
+// ── operator live-surface palette (v1.99) ───────────────────────────────────
+// The tokens above remain the global design system for one-shot surfaces. LIVE is the closed
+// five-colour system for long-running operator surfaces. Semantic aliases below deliberately share
+// renderers: glyphs and words retain the distinction between pass/brand, running/information,
+// chrome/secondary text, and attention/failure when colour is unavailable.
+/** Exact operator-approved live colours. Values stay hex so the authority is inspectable. */
+export const LIVE_PALETTE = {
+    /** muted teal — brand identity and pass */
+    brand: "#90C4A4",
+    /** cornflower blue — running state and information */
+    running: "#5A76AE",
+    /** ice — primary text */
+    text: "#E6FDFF",
+    /** cloud — chrome and secondary text */
+    chrome: "#D9D7DD",
+    /** amethyst — attention and failure */
+    attention: "#B07BAC",
+};
+const liveSgr = (hex) => {
+    const channels = hex.slice(1).match(/.{2}/gu).map((channel) => Number.parseInt(channel, 16));
+    return sgr(`38;2;${channels.join(";")}`);
+};
+const liveBrand = liveSgr(LIVE_PALETTE.brand);
+const liveRunning = liveSgr(LIVE_PALETTE.running);
+const liveText = liveSgr(LIVE_PALETTE.text);
+const liveChrome = liveSgr(LIVE_PALETTE.chrome);
+const liveAttention = liveSgr(LIVE_PALETTE.attention);
+/** Semantic live tokens. Aliases are intentional; no token introduces a sixth colour. */
+export const LIVE = {
+    brand: liveBrand,
+    pass: liveBrand,
+    running: liveRunning,
+    information: liveRunning,
+    text: liveText,
+    primaryText: liveText,
+    chrome: liveChrome,
+    secondaryText: liveChrome,
+    attention: liveAttention,
+    failure: liveAttention,
+    chip: liveBrand,
+};
 /**
  * The glyph vocabulary — plain characters only; color layers on via tokens so
  * shape survives NO_COLOR. Bracket toggles ([x]/[ ]) are forbidden on every surface.

package/dist/cli/commands/compile.js

@@ -3,8 +3,28 @@ import { parseArgs } from "node:util";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { compileSource } from "../../compile/index.js";
 import { saveGraph, stateDirName } from "../../graph/graph.js";
+import { formatPriorFindingEvidence, readPriorRunEvidence } from "../../run/journal.js";
+import { shGit } from "../../run/git.js";
 import { acquireRunLock, releaseRunLock } from "../../run/lock.js";
 import { harnessLine, resolveHarness } from "../harness.js";
+async function mergedPendingDiagnostics(cwd, pending, merges) {
+    const head = await shGit("git rev-parse HEAD", cwd);
+    const base = head.code === 0 ? head.stdout.trim() : "";
+    if (!/^[0-9a-f]{40}$/i.test(base))
+        return [];
+    const lines = [];
+    for (const taskId of pending) {
+        const candidates = merges.filter((merge) => merge.taskId === taskId).reverse();
+        for (const merge of candidates) {
+            const ancestor = await shGit(`git merge-base --is-ancestor ${merge.commit} ${base}`, cwd);
+            if (ancestor.code !== 0)
+                continue;
+            lines.push(`${taskId}: merged in run ${merge.runId}; compiles as pending (plan not marked done) — this dispatch rebuilds it`);
+            break; // one pure-information line per pending task, newest reachable merge wins
+        }
+    }
+    return lines;
+}
 // v1.89 T4: harnessFrom is the resolver's INPUT (see plan.ts); the default is the INVOKED entrypoint
 // (`process.argv[1]`, the bin symlink), never this module's own url — that names an internal module.
 export async function compile(argv, cwd = process.cwd(), harnessFrom = process.argv[1]) {
@@ -22,6 +42,11 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
     // resolve against the target repo, not the process cwd (the CLI test passes a tmp repo)
     // Both modes reach the same pure compiler; --dry-run only removes the lock/write side effect below.
     const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd);
+    // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
+    // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
+    // remain the source compiler's answer.
+    const prior = readPriorRunEvidence(cwd, g.tasks);
+    const mergedPending = await mergedPendingDiagnostics(cwd, new Set(g.tasks.filter((task) => task.status === "pending").map((task) => task.id)), prior.merges);
     const stateDir = stateDirName(cwd);
     if (!values["dry-run"]) {
         // HARD-01 / Sol #3: hold the same link(2) run lock as the daemon around saveGraph so compile
@@ -41,5 +66,11 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
     const diagnostics = scopeLints.length
         ? `\nscope lints:\n${scopeLints.map((lint) => `  ! ${lint}`).join("\n")}`
         : "";
-    return `${harnessLine(resolveHarness(harnessFrom))}\n${summary}${diagnostics}`;
+    const priorFindings = prior.findings.length
+        ? `\nprior-run evidence:\n${prior.findings.map((finding) => `  ${formatPriorFindingEvidence(finding)}`).join("\n")}`
+        : "";
+    const mergeHistory = mergedPending.length
+        ? `\nmerge history:\n${mergedPending.map((line) => `  ${line}`).join("\n")}`
+        : "";
+    return `${harnessLine(resolveHarness(harnessFrom))}\n${summary}${diagnostics}${priorFindings}${mergeHistory}`;
 }

package/dist/cli/commands/resume.js

@@ -2,8 +2,8 @@ import { loadConfig } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
-import { formatJournalNarration } from "../../run/journal.js";
 import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
+import { narrationSink, bindNarration } from "./run.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
@@ -25,13 +25,19 @@ export async function resume(argv, cwd = process.cwd()) {
     if (collisions.length) {
         throw new Error(collisions.map(denyPreferCollisionLine).join("; "));
     }
+    const narrate = narrationSink(runId);
     const s = await runDaemon(cwd, {
         runId,
         resume: true,
         graphChanged,
         retryFailed,
-        driver: pickDriver(cfg),
-        narrate: (event) => console.log(formatJournalNarration(event)),
+        // bound to the same sink the daemon gets, so a driver-journaled recovery reaches this rail too
+        driver: bindNarration(pickDriver(cfg), narrate),
+        // v1.99 T2: the ONE narration sink — the quiet rail on a TTY, the raw journal formatter on a
+        // pipe. A resumed run meets the same surface a fresh one does; printing the raw formatter here
+        // would leave `resume` as the last place the old unfiltered dump survives. Bound to the run id
+        // the operator named, so a resumed run's lifecycle rows name THIS run and not a generic word.
+        narrate,
     });
     const out = `resumed ${s.runId} — ${formatSummary(s)}`;
     return { out, code: summaryGreen(s) ? 0 : 2 };

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

@@ -1,6 +1,66 @@
+import type { ExecutorDriver } from "../../drivers/types.js";
 import { type JournalEvent } from "../../run/journal.js";
-export declare const narrationLine: (event: JournalEvent) => string;
+/** Closed repetitive set the rail suppresses on a TTY. An ungated `phase-start` joins them below —
+ *  it is a phase counter, while a phase-start CARRYING a gate is the gate start the rail draws. */
+export declare const TTY_NOISE_EVENTS: readonly ["worker-contact", "worker-status"];
+type RailTone = "pass" | "fail" | "attention" | "active" | "neutral";
+/** Closed retained set: the short operator label and the row's default tone. Labels are the rail's
+ *  own vocabulary — a raw journal event name is what this surface exists to stop printing. A `pass`
+ *  or `ok` datum on the event overrides the default tone, so one gate row can read either way.
+ *
+ *  MEMBERSHIP RULE — the daemon journals far more than this, and an allowlist built from whatever
+ *  the tests happened to cover masks real events. An event earns a row when it changes what the run
+ *  will DO next or reports an OUTCOME of it: a routing decision, a worker result, a gate start or
+ *  verdict, a repair, an escalation, a merge, a run lifecycle step. Everything else — how the daemon
+ *  got there (worktree setup, launch mechanics, baseline and routing lints) and every poll-time
+ *  observation (contact reads, quota banners, held dead-verdicts, context samples) — stays off the
+ *  rail and on the pipe, where it is byte-identical to the raw journal.
+ *
+ *  Applying that rule is what put `graph-rehash` and the worker-nudge family here: a rehash is the
+ *  operator's audited `--graph-changed` release, journaled by the resumed run through THIS sink, and
+ *  a nudge is a decision the daemon takes on the operator's behalf (it contacts the worker and arms a
+ *  grace deadline that force-concludes the wait), whose answered/failed/expired rows are that
+ *  decision's outcome. Neither is mechanics, and both reach this process's narrate callback. */
+export declare const RAIL_ROWS: Record<string, {
+    label: string;
+    tone: RailTone;
+}>;
+/**
+ * One rail row, or null when the TTY rail suppresses this event. Never wider than `columns`: the
+ * identity and the label are clipped SEPARATELY and the detail takes only what they leave, so a row
+ * can never wrap into a second line and can never lose its meaning to a long identity.
+ */
+export declare function narrationRow(event: JournalEvent, runId: string, columns?: number): string | null;
+/** The narration line for one event of the run named by `runId`: the raw journal formatter on a pipe
+ *  (byte-identical, every event), the quiet rail on a TTY. Null means the rail suppressed it — the
+ *  caller prints nothing. */
+export declare const narrationLine: (event: JournalEvent, runId: string) => string | null;
+/**
+ * The daemon's narration sink, BOUND TO THE RUN IT NARRATES: the rail on a TTY, the raw journal
+ * formatter on a pipe, and nothing at all for an event the rail suppressed. EVERY command that drives
+ * a daemon owes its narration to this sink - a second call site that prints `formatJournalNarration`
+ * itself is a surface where the rail does not exist, and the operator meets the old unfiltered dump
+ * under the newly stacked board.
+ *
+ * The binding is what puts a real identity on the run-scoped rows: the daemon's `narrate` callback is
+ * handed one event and nothing else, and the lifecycle events carry no run id of their own, so the
+ * run id can only come from the command that owns the run. Both daemon-driving commands supply it:
+ * `run` below mints the id it then passes to the daemon, and `resume` (src/cli/commands/resume.ts)
+ * carries the id the operator named.
+ */
+export declare const narrationSink: (runId: string) => (event: JournalEvent) => void;
+/**
+ * The run's driver, BOUND to the run's narration sink.
+ *
+ * A driver journals events of its own that the daemon never sees: `dispatch-retry` is appended by
+ * HerdrDriver from inside a pane recovery, through a Journal it opens itself (src/drivers/herdr.ts).
+ * Unbound, that event lands in the file and on the pipe while the rail — the operator's only live
+ * surface — stays silent about a redispatch that already happened. Both daemon-driving commands
+ * wrap their driver here so neither can forget the binding.
+ */
+export declare function bindNarration<D extends ExecutorDriver>(driver: D, narrate: (event: JournalEvent) => void): D;
 export declare function run(argv: string[], cwd?: string): Promise<{
     out: string;
     code: number;
 }>;
+export {};