tickmarkr 2.1.9 → 2.2.0

package/dist/tui/cockpit/setup-cockpit.js

@@ -4,8 +4,8 @@ import { userInfo } from "node:os";
 import { join } from "node:path";
 import { cloneElement, createElement, useState, } from "react";
 import { parse } from "yaml";
-import { approve } from "../../cli/commands/approve.js";
-import { ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, REVIEW_UPHELD_RELEASE, } from "../../run/journal.js";
+import { approvalDispositionForRelease, approvalEnactment, approvalRunOwner, approve, } from "../../cli/commands/approve.js";
+import { ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE, } from "../../run/journal.js";
 import { BANNER, GLYPHS, PLAIN_BANNER, } from "../../brand.js";
 import { DEFAULT_CONFIG, INTEGRITY_FLOOR_SHAPES, TIER_RANK, TickmarkrConfigSchema, unifiedYamlDiff, } from "../../config/config.js";
 import { GATE_NAMES, SHAPES } from "../../graph/schema.js";
@@ -560,6 +560,20 @@ export function actionableDecisions(decisions) {
  * replay is the production one (`Journal.replayStatuses`) so this surface and
  * `tickmarkr status` can never disagree about what is parked.
  */
+function failedGateForNewestPark(events, taskId, parkedIndex) {
+    for (let index = parkedIndex - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.taskId !== taskId)
+            continue;
+        if (event.event === "task-approved" || event.event === "task-human" || event.event === "task-dispatch")
+            return undefined;
+        if (event.event === "gate-result" && event.data.pass === false
+            && typeof event.data.gate === "string" && GATE_NAMES.includes(event.data.gate)) {
+            return event.data.gate;
+        }
+    }
+    return undefined;
+}
 export function deriveParkedDecisions(journal) {
     const statuses = journal.replayStatuses();
     const events = journal.read();
@@ -579,12 +593,7 @@ export function deriveParkedDecisions(journal) {
                 parkedIndex = index;
         }
         const parked = parkedIndex >= 0 ? events[parkedIndex] : undefined;
-        // The same rule the production approve command applies: the newest failed
-        // gate-result before the newest task-human controls what approve records
-        // and whether uphold exists at all. Never inferred from the park's prose.
-        const failedGate = events.slice(0, Math.max(0, parkedIndex)).reverse().find((event) => event.event === "gate-result" && event.taskId === taskId && event.data.pass === false
-            && typeof event.data.gate === "string"
-            && GATE_NAMES.includes(event.data.gate))?.data.gate;
+        const failedGate = failedGateForNewestPark(events, taskId, parkedIndex);
         const kind = typeof parked?.data.kind === "string" ? parked.data.kind : "human-gate";
         const reason = typeof parked?.data.reason === "string" ? parked.data.reason : undefined;
         decisions.push({
@@ -610,8 +619,17 @@ export function initialSetupDecisionsSession() {
  * inert and the keybar does not advertise it — the surface never promises a
  * decision the command must refuse.
  */
+export function setupDecisionVerbs(decision) {
+    if (decision.tombstone)
+        return [];
+    if (decision.kind !== "gate-fail")
+        return ["approve"];
+    if (decision.failedGate === undefined)
+        return [];
+    return decision.failedGate === "review" ? ["waive", "uphold", "recheck"] : ["waive", "recheck"];
+}
 export function upholdAvailable(decision) {
-    return decision.failedGate === "review";
+    return setupDecisionVerbs(decision).includes("uphold");
 }
 /**
  * The decisions surface's whole key grammar: ↑↓ move, a approve, u uphold,
@@ -650,25 +668,30 @@ export function applySetupDecisionsKey(session, event, parked) {
             },
         };
     }
-    if (event.input === "a" || event.input === "u") {
+    const verb = { a: "approve", w: "waive", u: "uphold", r: "recheck" }[event.input ?? ""];
+    if (verb !== undefined) {
         const decision = decisions[selection];
-        if (decision === undefined)
-            return { session };
-        if (event.input === "u" && !upholdAvailable(decision))
+        if (decision === undefined || !setupDecisionVerbs(decision).includes(verb))
             return { session };
         return {
             session: {
                 ...session,
                 selection,
-                confirming: {
-                    verb: event.input === "a" ? "approve" : "uphold",
-                    taskId: decision.taskId,
-                },
+                confirming: { verb, taskId: decision.taskId },
             },
         };
     }
     return { session };
 }
+const decisionFlag = (verb) => {
+    if (verb === "waive")
+        return ["--waive"];
+    if (verb === "uphold")
+        return ["--uphold"];
+    if (verb === "recheck")
+        return ["--recheck"];
+    return [];
+};
 /**
  * THE write. It calls the production `approve` command — validation, fail-closed
  * refusals and the journal append are inherited, never re-implemented — and then
@@ -680,7 +703,7 @@ export async function executeSetupDecision(command, { cwd, runId, by }) {
         const message = await approve([
             runId,
             command.taskId,
-            ...(command.verb === "uphold" ? ["--uphold"] : []),
+            ...decisionFlag(command.verb),
             "--by",
             by,
         ], cwd);
@@ -693,11 +716,12 @@ export async function executeSetupDecision(command, { cwd, runId, by }) {
                 break;
             }
         }
+        const disposition = approvalDispositionForRelease(release);
         return {
             ok: true,
             command,
             message,
-            write: { taskId: command.taskId, verb: command.verb, release, by },
+            write: { taskId: command.taskId, verb: command.verb, release, disposition, by },
         };
     }
     catch (error) {
@@ -726,52 +750,58 @@ function decisionRowText(decision) {
  * append — the release markers are the command's own constants, so this text
  * cannot drift from the write. An effect the operator cannot read here is an
  * effect this surface does not have.
+ *
+ * WHO enacts it is the command's own sentence (`approvalEnactment`), read from
+ * the same run-owner fact: predicting "the next resume" over a LIVE run was
+ * true only while the daemon read approvals once at startup. It now sweeps them
+ * at every task boundary, so that prediction would send the operator to start a
+ * second run in this repository — forbidden — for work already scheduled.
  */
-function decisionEffectLines(command, decision) {
-    if (command.verb === "uphold") {
+function decisionEffectLines(command, decision, run) {
+    if (command.verb === "waive") {
+        const gate = decision?.failedGate;
+        return gate === undefined ? ["effect none — waive refuses without a failed gate"] : [
+            `effect disposition waive-gate; appends release ${GATE_SATISFIED_RELEASE} for gate ${gate}`,
+            `it marks gate ${gate} satisfied; it does NOT mark the task done`,
+            approvalEnactment("waive-gate", run),
+        ];
+    }
+    if (command.verb === "recheck") {
         return [
-            `effect appends one task-approved event with release ${REVIEW_UPHELD_RELEASE};`
-                + " the next resume funds one fixed attempt carrying the findings",
-            "it does NOT mark the task done or pass any gate",
+            `effect disposition re-dispatch; appends release ${RECHECK_RELEASE}`,
+            "it marks no gate satisfied",
+            approvalEnactment("re-dispatch", run),
         ];
     }
-    if (decision?.kind === "gate-fail") {
-        if (decision.failedGate === undefined) {
-            // The command's own refusal, predicted: no write is promised here.
-            return [
-                "effect none — the command refuses: parked on gate-fail"
-                    + " but no failed gate result is recorded",
-            ];
-        }
-        const gate = decision.failedGate;
+    if (command.verb === "uphold") {
         return [
-            `effect appends one task-approved event with release ${GATE_SATISFIED_RELEASE}`
-                + ` for gate ${gate}; the next resume continues past the approved gate`,
-            `it marks gate ${gate} satisfied; it does NOT mark the task done`,
+            `effect disposition fund-fixed-attempt; appends release ${REVIEW_UPHELD_RELEASE}`,
+            approvalEnactment("fund-fixed-attempt", run),
         ];
     }
+    if (decision?.kind === "gate-fail") {
+        return ["effect none — approve is not offered on gate-fail parks; choose waive, recheck or uphold"];
+    }
     if (decision?.kind === ATTEMPT_CAP_RELEASE) {
         return [
-            `effect appends one task-approved event with release ${ATTEMPT_CAP_RELEASE};`
-                + ` the next resume dispatches ${command.taskId} with a fresh attempt budget`,
-            "it does NOT mark the task done or pass any gate",
+            `effect disposition fresh-budget; appends release ${ATTEMPT_CAP_RELEASE}`,
+            approvalEnactment("fresh-budget", run),
         ];
     }
     return [
-        "effect appends one task-approved event with no release;"
-            + ` the next resume dispatches ${command.taskId}`,
-        "it does NOT mark the task done or pass any gate",
+        `effect disposition dispatch; appends one task-approved event with no release`,
+        approvalEnactment("dispatch", run),
     ];
 }
 /**
  * The confirm inset's lines: the task, the actor, the effect and the file,
  * stated before the single key that can write.
  */
-export function setupDecisionConfirmLines(command, decision, actor, journalFile) {
+export function setupDecisionConfirmLines(command, decision, actor, journalFile, run) {
     return [
         `task   ${command.taskId}${decision === undefined ? "" : ` · ${decision.kind} · attempt ${decision.attempts}`}`,
         `actor  ${actor}`,
-        ...decisionEffectLines(command, decision),
+        ...decisionEffectLines(command, decision, run),
         `file   ${journalFile} · append only`,
         `y ${command.verb} · n cancel`,
     ];
@@ -783,8 +813,13 @@ function setupDecisionsKeybar(session, decisions) {
     if (decisions.length === 0)
         return "q Quit";
     const selected = Math.min(session.selection, decisions.length - 1);
-    const uphold = upholdAvailable(decisions[selected]) ? " · u Uphold" : "";
-    return `↑↓ Move · a Approve${uphold} · q Quit`;
+    const verbs = setupDecisionVerbs(decisions[selected]).map((verb) => ({
+        approve: "a Approve",
+        waive: "w Waive",
+        uphold: "u Uphold",
+        recheck: "r Recheck",
+    })[verb]).join(" · ");
+    return `↑↓ Move · ${verbs} · q Quit`;
 }
 /**
  * What the tab is, drawn on the tab it names. The operator's v1.83 UAT read
@@ -793,7 +828,7 @@ function setupDecisionsKeybar(session, decisions) {
  * keybar hint also draw.
  */
 const DECISIONS_TAB_LINE = `tab ${DECISIONS_TAB_HINT} · journal-parked human decisions`
-    + " · approve and uphold are its only writes";
+    + " · approve waive uphold and recheck are its only writes";
 /**
  * What the section says when no park needs the operator. It names its own
  * trigger and both verbs, so an operator who arrives at a quiet surface learns
@@ -801,8 +836,8 @@ const DECISIONS_TAB_LINE = `tab ${DECISIONS_TAB_HINT} · journal-parked human de
  */
 const DECISIONS_EMPTY_STATE = [
     "nothing needs you now — no task is parked on a human gate",
-    "a task that parks on one appears here with its two decisions —"
-        + " approve releases it, uphold sides with the reviewer",
+    "a task that parks on one appears here with its decisions —"
+        + " approve dispatches, waive accepts a gate, uphold funds a fix, recheck re-runs",
 ];
 /**
  * The decisions surface. Every row it draws — decisions, the confirm inset,
@@ -811,15 +846,16 @@ const DECISIONS_EMPTY_STATE = [
  * neither overflow its row nor be cut mid-cluster. The one unclipped element
  * is `notice`: the production command's own words, verbatim.
  */
-export function SetupDecisionsSurface({ decisions, session, columns, actor, journalFile, }) {
+export function SetupDecisionsSurface({ decisions, session, columns, actor, journalFile, run, }) {
     const inner = Math.max(1, Math.floor(columns) - 4);
     const actionable = actionableDecisions(decisions);
     const tombstones = decisions.filter((decision) => decision.tombstone);
     const selected = Math.min(session.selection, Math.max(0, actionable.length - 1));
     const confirming = session.confirming;
-    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsxs(Panel, { title: `${DECISIONS_TAB_TITLE} · ${decisions.length} parked`, focused: true, children: [_jsx(BodyText, { emphasis: "dim", children: fitCells(DECISIONS_TAB_LINE, inner) }), actionable.map((decision, index) => (_jsx(BodyText, { emphasis: index === selected ? "strong" : "normal", children: fitCells(`${index === selected ? `${GLYPHS.pointer} ` : "  "}${decisionRowText(decision)}`, inner) }, decision.taskId))), actionable.length === 0 && DECISIONS_EMPTY_STATE.map((line) => (_jsx(BodyText, { children: fitCells(line, inner) }, line))), tombstones.map((decision) => (_jsx(BodyText, { emphasis: "dim", children: fitCells(`  read-only · permanent by design · ${decisionRowText(decision)}`, inner) }, decision.taskId)))] }), confirming !== null && (_jsx(Panel, { title: `CONFIRM ${confirming.verb.toUpperCase()}`, focused: true, children: setupDecisionConfirmLines(confirming, decisions.find((decision) => decision.taskId === confirming.taskId), actor, journalFile).map((line) => (_jsx(BodyText, { children: fitCells(line, inner) }, line))) })), session.notice !== null && _jsx(BodyText, { children: session.notice }), _jsx(Panel, { title: "PENDING WRITES", children: session.writes.length === 0
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsxs(Panel, { title: `${DECISIONS_TAB_TITLE} · ${decisions.length} parked`, focused: true, children: [_jsx(BodyText, { emphasis: "dim", children: fitCells(DECISIONS_TAB_LINE, inner) }), actionable.map((decision, index) => (_jsx(BodyText, { emphasis: index === selected ? "strong" : "normal", children: fitCells(`${index === selected ? `${GLYPHS.pointer} ` : "  "}${decisionRowText(decision)}`, inner) }, decision.taskId))), actionable.length === 0 && DECISIONS_EMPTY_STATE.map((line) => (_jsx(BodyText, { children: fitCells(line, inner) }, line))), tombstones.map((decision) => (_jsx(BodyText, { emphasis: "dim", children: fitCells(`  read-only · permanent by design · ${decisionRowText(decision)}`, inner) }, decision.taskId)))] }), confirming !== null && (_jsx(Panel, { title: `CONFIRM ${confirming.verb.toUpperCase()}`, focused: true, children: setupDecisionConfirmLines(confirming, decisions.find((decision) => decision.taskId === confirming.taskId), actor, journalFile, run).map((line) => (_jsx(BodyText, { children: fitCells(line, inner) }, line))) })), session.notice !== null && _jsx(BodyText, { children: session.notice }), _jsx(Panel, { title: "PENDING WRITES", children: session.writes.length === 0
                     ? _jsx(BodyText, { children: fitCells("nothing written this session", inner) })
-                    : session.writes.map((write) => (_jsx(BodyText, { children: fitCells(`${write.verb} ${write.taskId} · release ${write.release ?? "none"} · by ${write.by}`, inner) }, `${write.verb}:${write.taskId}`))) }), _jsx(BodyText, { emphasis: "dim", children: fitCells(setupDecisionsKeybar(session, actionable), Math.max(1, Math.floor(columns))) })] }));
+                    : session.writes.map((write) => (_jsx(BodyText, { children: fitCells(`${write.verb} ${write.taskId} · disposition ${write.disposition}`
+                            + ` · release ${write.release ?? "none"} · by ${write.by}`, inner) }, `${write.verb}:${write.taskId}`))) }), _jsx(BodyText, { emphasis: "dim", children: fitCells(setupDecisionsKeybar(session, actionable), Math.max(1, Math.floor(columns))) })] }));
 }
 function SetupDecisionsApp({ cwd, runId, actor, }) {
     const { exit } = useApp();
@@ -846,7 +882,10 @@ function SetupDecisionsApp({ cwd, runId, actor, }) {
             });
         }
     });
-    return (_jsx(SetupDecisionsSurface, { decisions: decisions, session: session, columns: stdout.columns ?? 80, actor: actor, journalFile: join(stateDirName(cwd), "runs", runId, "journal.jsonl") }));
+    return (_jsx(SetupDecisionsSurface, { decisions: decisions, session: session, columns: stdout.columns ?? 80, actor: actor, journalFile: join(stateDirName(cwd), "runs", runId, "journal.jsonl"), 
+        // read per render, not once at mount: a daemon can start or end while the
+        // operator is deciding, and the inset must not promise the wrong enactor.
+        run: approvalRunOwner(cwd, runId) }));
 }
 /**
  * The setup decisions surface on a live engagement. This is the only cockpit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.1.9",
+  "version": "2.2.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",

package/skills/tickmarkr-overseer/SKILL.md

@@ -487,6 +487,12 @@ they are left implicit:
    were authed on 2026-08-17 while every seat ran claude). Priority when independence is scarce:
    **verifier > checker > planner > executors** — the independent seat goes cross-vendor
    (`herdr agent start … --kind codex`), ruled at dispatch, never debated under time pressure.
+   **A codex seat inside a git WORKTREE cannot commit and cannot write outside the worktree** (OBS-824, measured
+   twice on 2026-09-01): its sandbox pins writes to the worktree's own path, and a worktree's `.git` is a FILE pointing
+   at the main repository's object store, so every `git commit` from inside it is refused. Brief such a seat to leave its
+   report INSIDE the worktree and to commit nothing — the overseer commits from the main checkout — or give the work to a
+   claude seat, or to a throwaway CLONE (a real `.git` directory). A brief that tells a codex-in-worktree seat to commit
+   buys a stall, not a commit.
 4. **Gate every exec lane with the shipped battery, not hand-rolled greps.**
    `tickmarkr verify --base <ref> --criteria <file>` is the standalone form of the engine's own gates —
    build/test/lint diffed against a recorded baseline, evidence, scope, plus the semantic judges — one