tickmarkr 1.72.0 → 1.74.0

package/dist/run/git.js

@@ -75,6 +75,61 @@ export async function shGitOk(cmd, cwd) {
         throw new Error(`command failed (${r.code}): ${cmd}\n${r.stderr || r.stdout}`);
     return r.stdout;
 }
+const NPM_DEPENDENCY_MANIFESTS = ["package.json", "package-lock.json", "npm-shrinkwrap.json"];
+// OBS-126: compare the whole attempt (committed, staged, unstaged, or newly added manifest) with
+// the task's integration-tip baseline. A committed package.json change is invisible to `git status`,
+// while an untracked manifest is invisible to `git diff`, so both views are required.
+export async function npmDependencyManifestChanged(cwd, baselineRef) {
+    const paths = NPM_DEPENDENCY_MANIFESTS.map(shq).join(" ");
+    const diff = await shGit(`git diff --quiet ${shq(baselineRef)} -- ${paths}`, cwd);
+    if (diff.code === 1)
+        return true;
+    if (diff.code !== 0) {
+        throw new Error(`dependency manifest comparison failed (${diff.code}): ${diff.stderr || diff.stdout}`);
+    }
+    const untracked = await shGit(`git ls-files --others --exclude-standard -- ${paths}`, cwd);
+    if (untracked.code !== 0) {
+        throw new Error(`dependency manifest comparison failed (${untracked.code}): ${untracked.stderr || untracked.stdout}`);
+    }
+    return untracked.stdout.trim().length > 0;
+}
+// npm reifies a worktree's node_modules symlink as a private directory, which makes a successful
+// install disappear at worktree cleanup. Build positional specs from the attempt manifest so the
+// daemon can install them at the main repo root (the provisioned link's target) without saving them
+// into that baseline manifest. `--install-links` packs file: dependencies before the attempt is removed.
+export function npmDependencyInstallCommand(cwd) {
+    const manifestPath = join(cwd, "package.json");
+    const manifest = existsSync(manifestPath)
+        ? JSON.parse(readFileSync(manifestPath, "utf8"))
+        : {};
+    const dependencyGroups = [
+        manifest.peerDependencies,
+        manifest.devDependencies,
+        manifest.dependencies,
+        manifest.optionalDependencies,
+    ];
+    const dependencies = {};
+    for (const group of dependencyGroups) {
+        if (!group || typeof group !== "object" || Array.isArray(group))
+            continue;
+        for (const [name, spec] of Object.entries(group)) {
+            if (typeof spec === "string")
+                dependencies[name] = spec;
+        }
+    }
+    const specs = Object.entries(dependencies).map(([name, rawSpec]) => {
+        let spec = rawSpec;
+        if (spec.startsWith("file:"))
+            spec = `file:${resolve(cwd, spec.slice("file:".length))}`;
+        else if (spec.startsWith("./") || spec.startsWith("../"))
+            spec = resolve(cwd, spec);
+        return shq(`${name}@${spec}`);
+    });
+    return [
+        "npm install --no-save --no-audit --no-fund --package-lock=false --install-links",
+        ...specs,
+    ].join(" ");
+}
 export async function gitHead(cwd) {
     return (await shGitOk("git rev-parse HEAD", cwd)).trim();
 }

package/dist/run/journal.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { type Assignment } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
-import { type TaskStatus } from "../graph/schema.js";
+import { type GateName, type TaskStatus } from "../graph/schema.js";
 import { type ProfileDiscount, type RoutingProfile } from "../route/profile.js";
 export interface JournalEvent {
     ts: string;
@@ -9,6 +9,8 @@ export interface JournalEvent {
     taskId?: string;
     data: Record<string, unknown>;
 }
+export type TaskPhase = "worker" | "gates" | `gate:${GateName}` | "judge" | "review" | "merge";
+export declare function phaseForGate(gate: GateName): TaskPhase;
 export declare function formatJournalNarration({ event, taskId, data }: JournalEvent): string;
 export interface ResumeState {
     attempts: number;
@@ -18,6 +20,7 @@ export interface ResumeState {
 export declare const CHANNEL_EXCLUSION_KINDS: readonly ["dead-channel"];
 export type ChannelExclusionKind = (typeof CHANNEL_EXCLUSION_KINDS)[number];
 export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
+export declare const GATE_SATISFIED_RELEASE: "gate-satisfied";
 export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
 export type ParkKind = (typeof PARK_KINDS)[number];
 export declare const RETRY_MODES: readonly ["resume", "fresh"];
@@ -89,8 +92,22 @@ export declare const TelemetryRowSchema: z.ZodObject<{
         vacuous: "vacuous";
         skipped: "skipped";
     }>>;
+    kind: z.ZodOptional<z.ZodLiteral<"judge">>;
+    judgeOutcome: z.ZodOptional<z.ZodEnum<{
+        parseable: "parseable";
+        unparseable: "unparseable";
+    }>>;
 }, z.core.$strip>;
 export type TelemetryRow = z.infer<typeof TelemetryRowSchema>;
+export interface JudgeInvocationEvidence {
+    taskId: string;
+    channel: string;
+    outcome: "done" | "failed";
+    judgeOutcome: "parseable" | "unparseable";
+    durationMs: number;
+    transcript?: string;
+}
+export declare function withJudgeInvocationEvidence<T>(invocations: JudgeInvocationEvidence[], persist: () => Promise<T>): Promise<T>;
 export declare const SIGNAL_BASIS: readonly ["proved", "review-agree", "judge-only", "legacy", "vacuous", "skipped"];
 export type SignalBasis = (typeof SIGNAL_BASIS)[number];
 export declare const SIGNAL_QUALITY: Record<SignalBasis, 0 | 0.25 | 0.5 | 0.75 | 1>;
@@ -143,10 +160,13 @@ export declare class Journal {
     }): string | null;
     private get journalPath();
     append(event: string, taskId?: string, data?: Record<string, unknown>): void;
+    phaseStart(taskId: string, phase: TaskPhase, data?: Record<string, unknown>): void;
     read(): JournalEvent[];
     replayStatuses(): Map<string, TaskStatus>;
     replayResumeState(): Map<string, ResumeState>;
+    replaySatisfiedGates(): Map<string, GateName>;
     replayExcludedChannels(): Set<string>;
     telemetry(row: TelemetryRow): void;
     readTelemetry(): TelemetryRow[];
+    readJudgeTelemetry(): TelemetryRow[];
 }

package/dist/run/journal.js

@@ -1,11 +1,19 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { channelKey, TokenUsageSchema } from "../adapters/types.js";
 import { stateDirName, tickmarkrDir } from "../graph/graph.js";
-import { TIERS } from "../graph/schema.js";
+import { GATE_NAMES, TIERS } from "../graph/schema.js";
 import { buildProfile, classify } from "../route/profile.js";
 import { redactSecrets } from "./redact.js";
+export function phaseForGate(gate) {
+    if (gate === "acceptance")
+        return "judge";
+    if (gate === "review")
+        return "review";
+    return `gate:${gate}`;
+}
 export function formatJournalNarration({ event, taskId, data }) {
     const assignment = data.assignment;
     const direct = [data.summary, data.reason, data.error, data.step, data.action, data.lint, data.branch, data.from]
@@ -33,6 +41,9 @@ export const CHANNEL_EXCLUSION_KINDS = ["dead-channel"];
 // Approve stamps this; replayResumeState zeros the attempt counter (fresh budget) while keeping
 // tried (consult bans / burned channels). Absent on pre-v1.24 events ⇒ inert (corpus outcome-identical).
 export const ATTEMPT_CAP_RELEASE = "attempt-cap";
+// OBS-130: task-approved carries the exact failed gate the operator satisfied. The release tag keeps
+// ordinary humanGate and attempt-cap approvals byte-compatible while making this authority explicit.
+export const GATE_SATISFIED_RELEASE = "gate-satisfied";
 // Fail-closed shape for a dispatched assignment (journal.ts:75-90 posture): a malformed assignment in
 // one dispatch degrades that single task toward today's behavior — counts toward attempts, contributes
 // nothing to tried, poisons only lastAssignment — never crashes resume, never poisons other tasks.
@@ -131,7 +142,19 @@ export const TelemetryRowSchema = z.object({
     // v1.46 additive (T5): gate-signal quality for routing hygiene — OPTIONAL, absent = legacy (0.25 at fold).
     signalQuality: z.union([z.literal(0), z.literal(0.25), z.literal(0.5), z.literal(0.75), z.literal(1)]).optional(),
     signalBasis: z.enum(["proved", "review-agree", "judge-only", "legacy", "vacuous", "skipped"]).optional(),
+    // OBS-132 additive judge invocation rows. Absent means the legacy per-task row. Judge rows reuse the
+    // required v1.5 envelope so per-run raw readers stay source-compatible, while readAllTelemetry filters
+    // them before profile derivation: verdict production must be observable without becoming worker reward.
+    kind: z.literal("judge").optional(),
+    judgeOutcome: z.enum(["parseable", "unparseable"]).optional(),
 });
+const judgePersistence = new AsyncLocalStorage();
+// run-gates scopes this context around the existing daemon onGate callback. Journal.append therefore
+// remains the sole persistence boundary: it can enrich the existing judge-retry row and write invocation
+// telemetry without requiring a parallel daemon callback or changing healthy gate-result payloads.
+export function withJudgeInvocationEvidence(invocations, persist) {
+    return judgePersistence.run({ invocations, written: false }, persist);
+}
 // v1.46 T5 (Sol signal telemetry): gate-result rows carry explicit signalQuality so future defect windows
 // are identifiable without forensics. Basis is the provenance claim; quality is the dyadic h-fold weight.
 export const SIGNAL_BASIS = ["proved", "review-agree", "judge-only", "legacy", "vacuous", "skipped"];
@@ -249,7 +272,7 @@ export function readAllTelemetry(repoRoot, lastK, opts = {}) {
     for (const runId of runIds) {
         for (const raw of readJsonl(join(dir, runId, "telemetry.jsonl"))) {
             const r = TelemetryRowSchema.safeParse(raw);
-            if (r.success)
+            if (r.success && r.data.kind !== "judge")
                 out.push({ ...r.data, runId });
         }
     }
@@ -348,7 +371,18 @@ export class Journal {
         return join(this.dir, "journal.jsonl");
     }
     append(event, taskId, data = {}) {
-        const row = { ts: new Date().toISOString(), event, ...(taskId ? { taskId } : {}), data };
+        const evidence = judgePersistence.getStore();
+        const failed = evidence?.invocations.filter((invocation) => invocation.transcript !== undefined) ?? [];
+        const persistedData = event === "judge-retry" && failed.length > 0
+            ? {
+                ...data,
+                transcript: failed[0].transcript,
+                ...(failed[1] ? { retryTranscript: failed[1].transcript } : {}),
+            }
+            : data;
+        const row = {
+            ts: new Date().toISOString(), event, ...(taskId ? { taskId } : {}), data: persistedData,
+        };
         // T3 secret redaction: only the persisted bytes are masked — the caller's data stays untouched in
         // memory. The narrator receives the persisted (masked) row so a pane sink never shows a credential.
         const line = redactSecrets(JSON.stringify(row));
@@ -359,6 +393,29 @@ export class Journal {
         catch {
             // narration is observational; a broken sink must not affect the journal or run
         }
+        if (evidence && !evidence.written && (event === "judge-retry" || event === "gate-result")) {
+            evidence.written = true;
+            for (const invocation of evidence.invocations) {
+                const colon = invocation.channel.indexOf(":");
+                const adapter = colon === -1 ? invocation.channel : invocation.channel.slice(0, colon);
+                const model = colon === -1 ? "" : invocation.channel.slice(colon + 1);
+                this.telemetry({
+                    kind: "judge",
+                    taskId: invocation.taskId,
+                    shape: "judge",
+                    adapter,
+                    model,
+                    channel: invocation.channel,
+                    attempts: 1,
+                    outcome: invocation.outcome,
+                    durationMs: invocation.durationMs,
+                    judgeOutcome: invocation.judgeOutcome,
+                });
+            }
+        }
+    }
+    phaseStart(taskId, phase, data = {}) {
+        this.append("phase-start", taskId, { ...data, phase });
     }
     read() {
         return readJsonl(this.journalPath);
@@ -461,6 +518,20 @@ export class Journal {
         }
         return m;
     }
+    // OBS-130: gate satisfaction is authority, not an inferred daemon state. Only an explicit
+    // task-approved event with the typed release marker and a known gate enters this fold. A daemon-made
+    // gate-satisfied event, a prior pass/fail result, malformed data, or another task's approval is inert.
+    replaySatisfiedGates() {
+        const satisfied = new Map();
+        for (const e of this.read()) {
+            if (e.event !== "task-approved" || !e.taskId || e.data.release !== GATE_SATISFIED_RELEASE)
+                continue;
+            if (typeof e.data.gate === "string" && GATE_NAMES.includes(e.data.gate)) {
+                satisfied.set(e.taskId, e.data.gate);
+            }
+        }
+        return satisfied;
+    }
     // v1.71 OBS-119: run-wide exclusion fold — same replay discipline as replayResumeState().
     // channel-exclusion is the typed event; dead-channel-failover.from is the pre-v1.71 compat seam.
     replayExcludedChannels() {
@@ -479,8 +550,15 @@ export class Journal {
         // T3 secret redaction: same persistence seam as append — credential-free rows are byte-identical.
         appendFileSync(join(this.dir, "telemetry.jsonl"), redactSecrets(JSON.stringify(row)) + "\n");
     }
-    // Per-run, raw (NOT schema-validated) — report.ts reads v1.5 core fields; stays byte-compatible.
+    // Per-run task rows stay byte-compatible for legacy readers (report and task-level test helpers).
+    // Judge rows share telemetry.jsonl but have a dedicated reader so their earlier gate-time ordering
+    // cannot make a find(taskId) caller mistake invocation evidence for the later terminal task row.
     readTelemetry() {
-        return readJsonl(join(this.dir, "telemetry.jsonl"));
+        return readJsonl(join(this.dir, "telemetry.jsonl"))
+            .filter((row) => !(row && typeof row === "object" && "kind" in row && row.kind === "judge"));
+    }
+    readJudgeTelemetry() {
+        return readJsonl(join(this.dir, "telemetry.jsonl"))
+            .filter((row) => row && typeof row === "object" && "kind" in row && row.kind === "judge");
     }
 }

package/dist/tui/ink/components.d.ts

@@ -1,8 +1,12 @@
 import type { ReactNode } from "react";
+import { type SaveTarget } from "../save.js";
 export type FleetListRow = {
     id: string;
     content: ReactNode;
 };
+export declare function TextLines({ lines }: {
+    lines: string[];
+}): import("react").JSX.Element;
 export declare function ToggleMark({ active }: {
     active: boolean;
 }): import("react").JSX.Element;
@@ -18,3 +22,17 @@ export declare function FleetReviewScreen({ title, legend, diff, }: {
     legend: string;
     diff: string;
 }): import("react").JSX.Element;
+export type DiffConfirmationProps = {
+    target: SaveTarget;
+    targetPath: string;
+    diff: string;
+    liveRun: boolean;
+};
+export declare function DiffConfirmationScreen(props: DiffConfirmationProps): import("react").JSX.Element;
+export declare function StudioScreen({ tabs, active, lines, status, children, }: {
+    tabs: string[];
+    active: number;
+    lines: string[];
+    status?: string;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/tui/ink/components.js

@@ -1,14 +1,42 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { GLYPHS } from "../../brand.js";
+import { RELOAD_GUARD_NOTICE } from "../save.js";
+function keyedLines(lines) {
+    const occurrences = new Map();
+    return lines.map((text) => {
+        const occurrence = occurrences.get(text) ?? 0;
+        occurrences.set(text, occurrence + 1);
+        return { id: `${text}:${occurrence}`, text };
+    });
+}
+export function TextLines({ lines }) {
+    return (_jsx(_Fragment, { children: keyedLines(lines).map(({ id, text }) => _jsx(Text, { children: text || " " }, id)) }));
+}
 export function ToggleMark({ active }) {
     return active
         ? _jsx(Text, { color: "ansi256(41)", children: GLYPHS.toggleActive })
         : _jsx(Text, { dimColor: true, children: GLYPHS.toggleInactive });
 }
 export function FleetListScreen({ title, legend, rows, cursor, details = [], }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), details.map((detail) => _jsx(Text, { children: detail }, detail))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), _jsx(TextLines, { lines: details })] }));
 }
 export function FleetReviewScreen({ title, legend, diff, }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), _jsx(Text, { children: diff })] }));
 }
+export function DiffConfirmationScreen(props) {
+    return _jsx(TextLines, { lines: [
+            `Save overlay — ${props.targetPath} (${props.target === "repo" ? "repository" : "global"} target)`,
+            "t toggle target · y confirm · n/esc cancel",
+            ...(props.liveRun ? [RELOAD_GUARD_NOTICE] : []),
+            "─ diff ─",
+            props.diff || "(no overlay changes)",
+        ] });
+}
+export function StudioScreen({ tabs, active, lines, status = "no staged changes", children, }) {
+    const tabBar = [
+        "tickmarkr ui ──",
+        ...tabs.map((label, index) => `[${index + 1}]${index === active ? "*" : ""}${label}`),
+    ].join(" ");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: tabBar }), children ?? _jsx(TextLines, { lines: lines }), _jsx(Text, { dimColor: true, children: status })] }));
+}

package/dist/tui/ink/studio-app.d.ts

@@ -0,0 +1,59 @@
+import { type RunGraph } from "../../graph/schema.js";
+import { type JournalEvent } from "../../run/journal.js";
+import { FleetStaging } from "../staging.js";
+export type StudioInkView = {
+    id: string;
+    label: string;
+    render(props: {
+        cols: number;
+        rows: number;
+    }): string[];
+    key?(name: string): void;
+};
+export type StudioInkIO = {
+    input: NodeJS.ReadStream;
+    output: NodeJS.WriteStream;
+    views?: StudioInkView[];
+    repoRoot?: string;
+    globalDir?: string;
+    staging?: FleetStaging;
+    runsData?: RunsCockpitData;
+    clock?: () => number;
+    debug?: boolean;
+};
+export type RunsCockpitData = {
+    runId?: string;
+    events: JournalEvent[];
+    graph: RunGraph;
+    prompts?: Record<string, string[]>;
+};
+type DossierVerdict = {
+    action: "retry" | "reroute" | "decompose" | "human";
+    reason?: string;
+    prompt?: string;
+};
+type ConsultDossierData = {
+    taskId: string;
+    verdicts: DossierVerdict[];
+};
+type RunsCockpitTask = {
+    id: string;
+    status: string;
+    phase?: string;
+    elapsed?: string;
+    consultCount: number;
+};
+export declare function foldConsultDossier(data: RunsCockpitData, taskId: string): ConsultDossierData;
+export declare function buildRunsCockpitTasks(data: RunsCockpitData, nowMs: number): RunsCockpitTask[];
+export declare function StudioApp({ views: suppliedViews, repoRoot, globalDir, staging: suppliedStaging, runsData: suppliedRunsData, clock, columns, rows, }: {
+    views?: StudioInkView[];
+    repoRoot?: string;
+    globalDir?: string;
+    staging?: FleetStaging;
+    runsData?: RunsCockpitData;
+    clock?: () => number;
+    columns?: number;
+    rows?: number;
+}): import("react").JSX.Element;
+export declare function runStudioInk({ input, output, views, repoRoot, globalDir, staging, runsData, clock, debug, }: StudioInkIO): Promise<void>;
+export {};