tickmarkr 2.6.4 → 2.6.6

package/dist/tui/cockpit/log-view.js

@@ -0,0 +1,60 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { narrationRow } from "../../cli/commands/run.js";
+import { STORE_LIMITS } from "./live-store.js";
+/** The board uses the daemon's TTY narration, including its suppression and sanitization. */
+export const renderLogLines = (events, runId, columns) => events.map(event => narrationRow(event, runId, columns)).filter((line) => line !== null);
+const narrate = (rows, source) => rows.flatMap(row => row.event
+    ? renderLogLines([row.event], source.runId, source.columns).map(text => ({ line: row.line, text })) : []);
+/** Demand-page backwards to fill the viewport, including events outside the store's retained tail.
+ * Only the requested visible rows survive; suppressed events never consume viewport rows. */
+export function readLogPage(source, count, end = source.journal.lines) {
+    let cursor = Math.min(end, source.journal.lines);
+    let rows = [];
+    try {
+        while (cursor > 0 && rows.length < count) {
+            const first = Math.max(1, cursor - STORE_LIMITS.history + 1);
+            const retained = source.journal.history.filter(row => row.line >= first && row.line <= cursor);
+            const page = retained.length === cursor - first + 1 ? retained
+                : source.page(first, cursor - first + 1, source.journal.generation);
+            rows = [...narrate(page, source), ...rows].slice(-count);
+            cursor = first - 1;
+        }
+        return { rows };
+    }
+    catch (error) {
+        return { rows: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Move by visible narration rows. Undefined means follow the journal tail again. */
+export function moveLogEnd(source, end, delta) {
+    const cursor = Math.min(end ?? source.journal.lines, source.journal.lines);
+    if (delta < 0) {
+        const rows = readLogPage(source, -delta + 1, cursor).rows;
+        return rows[Math.max(0, rows.length - 1 + delta)]?.line ?? end;
+    }
+    let first = cursor + 1, remaining = delta;
+    while (first <= source.journal.lines) {
+        const last = Math.min(source.journal.lines, first + STORE_LIMITS.history - 1);
+        let rows;
+        try {
+            rows = narrate(source.page(first, last - first + 1, source.journal.generation), source);
+        }
+        catch {
+            return end;
+        } // A stale journal observation must never terminate the board's key handler.
+        if (rows.length >= remaining) {
+            const line = rows[remaining - 1].line;
+            return line === source.journal.lines ? undefined : line;
+        }
+        remaining -= rows.length;
+        first = last + 1;
+    }
+    return undefined;
+}
+export function LogView({ page }) {
+    return _jsx(Box, { flexDirection: "column", children: page.error
+            ? _jsxs(Text, { children: ["Log unavailable: ", page.error] })
+            : page.rows.length ? page.rows.map(row => _jsx(Text, { wrap: "truncate-end", children: row.text }, row.line))
+                : _jsx(Text, { children: "No narrated events" }) });
+}

package/dist/tui/cockpit/run-view.js

@@ -98,6 +98,10 @@ export function runGateCells(task, evidence, rows = []) {
         else if (cell.state === "queued") {
             labels.push(`queued — ${row?.event?.event ?? "wait"}${typeof data.count === "number" ? ` (${data.count} suites)` : ""}`);
         }
+        else if (cell.state === "unknown" && row?.event?.event !== "gate-result") {
+            // I1: a start or wait row settled at a terminal boundary — no verdict ever measured it.
+            labels.push(`unknown — ${row?.event?.event ?? "start"} never finished`);
+        }
         else if (data.disabled === true) {
             labels.push("disabled by policy");
         }

package/dist/tui/cockpit/shell.d.ts

@@ -2,13 +2,14 @@ import { type ReactNode } from "react";
 import { type ShellPlan } from "./layout.js";
 import { SHELL_BINDINGS } from "./keys.js";
 import type { LiveStoreSnapshot } from "./live-store.js";
-export type ShellView = "home" | "run" | "evidence";
+export type ShellView = "home" | "run" | "evidence" | "log";
 export type ShellFocus = ShellPlan["focus"][number];
 export interface ShellState {
     view: ShellView;
     focus: ShellFocus;
     scroll: number;
     help: boolean;
+    logEnd?: number;
     evidenceSection?: number;
     canOpen?: boolean;
     shortcutColumns?: number;

package/dist/tui/cockpit/shell.js

@@ -13,7 +13,8 @@ export const shellHelp = (bindings = SHELL_BINDINGS) => [
     "Esc closes deepest overlay; it never quits.",
     "Text: q1? is literal; Enter applies; Esc cancels.",
     "Confirm: y alone confirms; n/Esc cancels.",
-    "Tab now moves focus; view numbers are 1/4/5.",
+    "Tab now moves focus; view numbers are 1/4/5/7.",
+    "Log: arrows/page keys scroll; f toggles tail follow.",
     "Fleet: tickmarkr fleet", "Plan: tickmarkr plan", "Health: tickmarkr doctor",
 ];
 /** Read the Yoga geometry that actually painted, including clipped/scrolled leaves.
@@ -65,10 +66,11 @@ export function CockpitShell({ snapshot, state, columns, rows, version, children
     const overlay = state.editor !== undefined ? [`${state.editorKind === "export" ? "Export destination" : "Filter"}: ${state.editor}`, "Enter Apply | Esc Cancel"] : state.overlay ?? (state.help ? shellHelp(bindings) : undefined);
     const totalRows = overlay?.length ?? contentRows;
     const displayOffset = overlay ? Math.min(state.overlayOffset, Math.max(0, totalRows - plan.bodyRows)) : scroll;
-    const position = `${totalRows ? displayOffset + 1 : 0}–${Math.min(totalRows, displayOffset + plan.bodyRows)}/${totalRows} | ${Math.max(0, totalRows - plan.bodyRows)} hidden`;
+    const logMode = state.view === "log" ? `${state.logEnd === undefined ? "FOLLOW" : "PAUSED"} | ` : "";
+    const position = `${logMode}${totalRows ? displayOffset + 1 : 0}–${Math.min(totalRows, displayOffset + plan.bodyRows)}/${totalRows} | ${Math.max(0, totalRows - plan.bodyRows)} hidden`;
     const keybar = bindings.filter(b => ["focus", "open", "actions", "help", "quit"].includes(b.action) && (columns >= 60 || b.action !== "focus")).map(b => `${b.key} ${columns < 60 && b.action === "actions" ? "Act" : b.label}`).join(" | ");
     const status = columns < 60 ? `${op.label} | tip ${op.currentTip.toUpperCase()}` : `${op.label} | MERGED ${op.merged}/${op.planned ?? "?"} | CURRENT TIP ${op.currentTip.toUpperCase()} | ${snapshot.freshness}`;
     return _jsx(ShellPresentation.Provider, { value: true, children: _jsx(ShellTheme.Provider, { value: { mode: colour, palette }, children: _jsxs(Box, { ref: root, flexDirection: "column", width: columns, height: rows, flexShrink: 0, backgroundColor: ink(palette.surface), children: [line(`tickmarkr ${version} | ${state.view.toUpperCase()} | ${snapshot.journal.source.split("/").at(-2) ?? "run identity unknown"}`), line(columns < 60
-                        ? `1H 4R 5E | ${position}`
-                        : `1 Home  4 Run  5 Evidence | ${state.focus} | ${position}`), line("─".repeat(columns), columns, palette.chrome), _jsxs(Box, { height: plan.bodyRows, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [_jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) }), plan.rail > 0 && _jsxs(_Fragment, { children: [_jsx(Box, { width: plan.rail, flexDirection: "column", children: ["1 Home", "4 Run", "5 Evidence", "", "CLI:", "fleet", "plan", "doctor"].map((t, i) => _jsx(Text, { color: ink(palette.chrome), children: fitCells(t, plan.rail) }, i)) }), _jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) })] }), _jsxs(Box, { width: plan.bodyColumns, height: plan.bodyRows, flexDirection: "column", overflow: "hidden", flexShrink: 0, children: [overlay?.slice(displayOffset, displayOffset + plan.bodyRows).map((t, i) => _jsx(Text, { wrap: "truncate-end", color: ink(palette.text), children: fitCells(t, plan.bodyColumns) }, i)), _jsx(Box, { ref: leaf, display: overlay ? "none" : "flex", flexDirection: "column", flexShrink: 0, marginTop: -scroll, children: children })] }), plan.shortcuts > 0 && _jsxs(_Fragment, { children: [_jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) }), _jsx(Box, { width: plan.shortcuts, flexDirection: "column", children: bindings.map(b => _jsx(Text, { color: ink(palette.chrome), wrap: "truncate-end", children: fitCells(`${b.key} ${b.label}`, plan.shortcuts) }, b.key)) })] }), _jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) })] }), line("─".repeat(columns), columns, palette.chrome), line(status), line(keybar), line("─".repeat(columns), columns, palette.chrome)] }) }) });
+                        ? `1H 4R 5E 7L | ${position}`
+                        : `1 Home  4 Run  5 Evidence  7 Log | ${state.focus} | ${position}`), line("─".repeat(columns), columns, palette.chrome), _jsxs(Box, { height: plan.bodyRows, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [_jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) }), plan.rail > 0 && _jsxs(_Fragment, { children: [_jsx(Box, { width: plan.rail, flexDirection: "column", children: ["1 Home", "4 Run", "5 Evidence", "7 Log", "", "CLI:", "fleet", "plan", "doctor"].map((t, i) => _jsx(Text, { color: ink(palette.chrome), children: fitCells(t, plan.rail) }, i)) }), _jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) })] }), _jsxs(Box, { width: plan.bodyColumns, height: plan.bodyRows, flexDirection: "column", overflow: "hidden", flexShrink: 0, children: [overlay?.slice(displayOffset, displayOffset + plan.bodyRows).map((t, i) => _jsx(Text, { wrap: "truncate-end", color: ink(palette.text), children: fitCells(t, plan.bodyColumns) }, i)), _jsx(Box, { ref: leaf, display: overlay ? "none" : "flex", flexDirection: "column", flexShrink: 0, marginTop: -scroll, children: children })] }), plan.shortcuts > 0 && _jsxs(_Fragment, { children: [_jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) }), _jsx(Box, { width: plan.shortcuts, flexDirection: "column", children: bindings.map(b => _jsx(Text, { color: ink(palette.chrome), wrap: "truncate-end", children: fitCells(`${b.key} ${b.label}`, plan.shortcuts) }, b.key)) })] }), _jsx(Box, { width: 1, flexDirection: "column", children: Array.from({ length: plan.bodyRows }, (_, i) => _jsx(Text, { color: ink(palette.chrome), children: "\u2502" }, i)) })] }), line("─".repeat(columns), columns, palette.chrome), line(status), line(keybar), line("─".repeat(columns), columns, palette.chrome)] }) }) });
 }

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

@@ -2,9 +2,21 @@ import { type AuthHealth, type WorkerAdapter } from "../../adapters/types.js";
 import { type DenyScopeKey, type InitialDenyProps, type MapEntry, type RoutingMode, type StagedDenyKey, type Tier, type TickmarkrConfig } from "../../config/config.js";
 import { type Effort, type Shape } from "../../graph/schema.js";
 export type FleetSteeringKey = "review" | "consult";
+/** T10 (D-939): the routing.allow entry a classification staged this session excluded — the row's own
+ * entry in its ownAllow spelling, added to the staged complement so Space can admit it in-session.
+ * `model` is the classified id (the tiers key), `displayModel` the browser row it was staged from. */
+export type FleetSeededAllow = {
+    adapter: string;
+    model: string;
+    displayModel: string;
+    identity?: string;
+    entry: string;
+};
 export type FleetEditorState = Record<DenyScopeKey, string[]> & {
     /** OBS-1046: the staged routing.allow complement, distinct from the authored deny lists above */
     allowOut?: string[];
+    /** T10: one seed per staged classification the current allow form left out */
+    seededAllowOut?: FleetSeededAllow[];
     classifications: FleetClassification[];
     /** OBS-1182: staged launch effort per adapter → model; absent = the CLI's own default */
     efforts?: Record<string, Record<string, Effort>>;
@@ -16,8 +28,19 @@ export type FleetEditorState = Record<DenyScopeKey, string[]> & {
     };
     steering: Record<FleetSteeringKey, string[] | undefined>;
 };
+/** T8: the staged classifications and efforts every preview folds — the same metadata a review stages,
+ * so a preview ranks what w would write before the first review and after an escaped one. */
+export type FleetStagedMetadata = Pick<FleetEditorState, "classifications" | "efforts" | "seededAllowOut">;
+/** OBS-525: auto reverts the shape's WHOLE routing declaration — pool included, not just the pin.
+ * prefer survives: it biases auto routing and is valid without pin/pool. */
+export declare function autoMapEntry(entry: MapEntry | undefined): MapEntry;
 export type FleetOverlayReview = {
     kind: "empty";
+}
+/** T10: a staged batch the one-destination review cannot write (mixed destinations, a stray seed) */
+ | {
+    kind: "refused";
+    reason: string;
 } | {
     kind: "diff";
     before: string;
@@ -125,7 +148,7 @@ export type FleetStagedRouting = {
     ok: false;
     error: string;
 };
-export declare function FleetApp({ ageMs, agents, initialAllowOut, initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, ...initialDenyProps }: InitialDenyProps & {
+export declare function FleetApp({ ageMs, agents, initialAllowOut, initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories, reviewOverlay, reloadGuard, stagedRouting, holderOf, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, ...initialDenyProps }: InitialDenyProps & {
     ageMs: number | null;
     agents: AgentCli[];
     /** OBS-1046: adapter ids and adapter:model keys routing.allow leaves out of the fleet */
@@ -136,9 +159,9 @@ export declare function FleetApp({ ageMs, agents, initialAllowOut, initialEffort
     initialMode: RoutingMode;
     modeOptions: FleetModeOption[];
     initialMap: Record<string, MapEntry>;
-    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => string[];
-    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => FleetShapeRow[];
-    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => {
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny, stage?: FleetStagedMetadata) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny, stage?: FleetStagedMetadata) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny, stage?: FleetStagedMetadata) => {
         rows: FleetCandidateOption[];
         excludedNote?: string;
         ledger?: string[];
@@ -152,7 +175,9 @@ export declare function FleetApp({ ageMs, agents, initialAllowOut, initialEffort
     reloadGuard: (bytes: string) => string | null;
     /** the routing policy the staged deny sets load as (fleet: the config loader over the candidate
      * bytes); absent ⇒ the four staged sets alone, with no allowlist */
-    stagedRouting?: (deny: FleetStagedDeny) => FleetStagedRouting;
+    stagedRouting?: (deny: FleetStagedDeny, stage?: FleetStagedMetadata) => FleetStagedRouting;
+    /** T10: the overlay `path:line` holding a dotted config scope in this repository, undefined = defaults */
+    holderOf?: (dotted: string) => string | undefined;
     entry?: "presets" | "probe";
     /** resolved config judge as "adapter:model" — shown on the (keep default) picker row */
     initialJudge?: string;
@@ -165,7 +190,7 @@ export declare function FleetApp({ ageMs, agents, initialAllowOut, initialEffort
     /** terminal height — set only on a real TTY so the footer sticks to the bottom */
     frameRows?: number;
 }): import("react").JSX.Element;
-export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut, initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, initialInput, input, output, debug, ...initialDenyProps }: InitialDenyProps & {
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut, initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories, reviewOverlay, reloadGuard, stagedRouting, holderOf, entry, initialJudge, judgeSeats, initialInput, input, output, debug, ...initialDenyProps }: InitialDenyProps & {
     ageMs: number | null;
     adapters: WorkerAdapter[];
     health: Record<string, AuthHealth>;
@@ -177,9 +202,9 @@ export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllo
     initialMode: RoutingMode;
     modeOptions: FleetModeOption[];
     initialMap: Record<string, MapEntry>;
-    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => string[];
-    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => FleetShapeRow[];
-    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => {
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny, stage?: FleetStagedMetadata) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny, stage?: FleetStagedMetadata) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny, stage?: FleetStagedMetadata) => {
         rows: FleetCandidateOption[];
         excludedNote?: string;
         ledger?: string[];
@@ -193,7 +218,9 @@ export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllo
     reloadGuard: (bytes: string) => string | null;
     /** the routing policy the staged deny sets load as (fleet: the config loader over the candidate
      * bytes); absent ⇒ the four staged sets alone, with no allowlist */
-    stagedRouting?: (deny: FleetStagedDeny) => FleetStagedRouting;
+    stagedRouting?: (deny: FleetStagedDeny, stage?: FleetStagedMetadata) => FleetStagedRouting;
+    /** T10: the overlay `path:line` holding a dotted config scope in this repository, undefined = defaults */
+    holderOf?: (dotted: string) => string | undefined;
     /** "presets" = init's entry: Esc in the browser is HOME to the preset overlay, not quit */
     entry?: "presets" | "probe";
     initialJudge?: string;

package/dist/tui/ink/fleet-app.js

@@ -12,6 +12,12 @@ import { windowRows } from "./components.js";
 import { wrapCells } from "../cockpit/width.js";
 import { clip, clipPathTail, ElisionMark, enterAltScreen, fmtCtx, fmtMs, fmtUsdPair, Glyph, INK, inkInput, inkOutput, KeyBar, OverlayPanel, padCell, padCellStart, Pointer, SearchRow, } from "./frame.js";
 const STEERING_KEYS = ["review", "consult"];
+/** OBS-525: auto reverts the shape's WHOLE routing declaration — pool included, not just the pin.
+ * prefer survives: it biases auto routing and is valid without pin/pool. */
+export function autoMapEntry(entry) {
+    const { pin: _pin, pool: _pool, ...rest } = entry ?? {};
+    return rest;
+}
 /** every scope's staged list, empty — the "every policy scope open" probe the picker lifts against */
 export const openStagedDeny = () => ({
     ...Object.fromEntries(DENY_SCOPES.map((scope) => [stagedDenyKeyOf(scope), []])),
@@ -43,7 +49,7 @@ const REACH_CHOICES = [
     { id: "out-workers", label: "out · workers", gloss: "workers skip it; judge/review/consult unaffected" },
     { id: "out-all", label: "out · all seats", gloss: "no seat routes here" },
 ];
-export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts = {}, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, reloadGuard, stagedRouting, entry = "probe", initialJudge = "", judgeSeats = [], viewRows = Number.POSITIVE_INFINITY, frameColumns = 100, frameRows, ...initialDenyProps }) {
+export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts = {}, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, reloadGuard, stagedRouting, holderOf, entry = "probe", initialJudge = "", judgeSeats = [], viewRows = Number.POSITIVE_INFINITY, frameColumns = 100, frameRows, ...initialDenyProps }) {
     const { exit } = useApp();
     const [, setRevision] = useState(0);
     // the props are the fleet command's contract, one per schema-enumerated scope (initialDeny…),
@@ -65,6 +71,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         notice: "",
         lastEdit: null,
         allowOut: new Set(initialAllowOut),
+        seededAllowOut: [],
         ...Object.fromEntries(DENY_SCOPES.map((scope) => [scope.key, new Set(initialDeny[scope.key])])),
         classifications: [],
         efforts: structuredClone(initialEfforts),
@@ -133,12 +140,13 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     let routingMemo = null;
     const stagedPolicy = () => {
         const deny = stagedDeny();
-        const key = JSON.stringify(deny);
+        const stage = stagedMetadata();
+        const key = JSON.stringify([deny, stage]);
         if (routingMemo?.key !== key) {
             routingMemo = {
                 key,
                 policy: stagedRouting
-                    ? stagedRouting(deny)
+                    ? stagedRouting(deny, stage)
                     : { ok: true, routing: { deny: denyBlockFrom(denyLists()) } },
             };
         }
@@ -157,7 +165,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     const reachFor = (adapter, model, identity) => {
         const policy = stagedPolicy();
         if (!policy.ok)
-            return { reach: "unknown", reasons: [`preview unavailable (${policy.error})`], uncoveredAlias: false };
+            return { reach: "unknown", reasons: [`preview unavailable (${policy.error})`], uncoveredAlias: false, held: [] };
         const channel = { adapter, model, ...(identity !== undefined ? { identity } : {}) };
         const worker = exclusionsOf(channel, policy.routing, "worker");
         const allSeats = exclusionsOf(channel, policy.routing, "judge");
@@ -169,6 +177,10 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             reach,
             reasons: worker.map(exclusionReason),
             uncoveredAlias: identity !== undefined && !worker.some((scope) => scope.by === "deny"),
+            held: [...new Set(worker.map((scope) => scope.configPath))].flatMap((dotted) => {
+                const holder = holderOf?.(dotted);
+                return holder === undefined ? [] : [`${dotted} @ ${holder}`];
+            }),
         };
     };
     // OBS-1099 review: a displayed row may fold several discovered gateway ids (foldedModels);
@@ -346,7 +358,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         ...Object.fromEntries(DENY_SCOPES.map((scope) => [stagedDenyKeyOf(scope), [...ui[scope.key]].sort()])),
         allowOut: [...ui.allowOut].sort(),
     });
-    const shapeList = () => shapeRows(ui.selectedMode, ui.map, stagedDeny());
+    const shapeList = () => shapeRows(ui.selectedMode, ui.map, stagedDeny(), stagedMetadata());
     const steeringList = () => [
         ...STEERING_KEYS.map((key) => ({
             id: key,
@@ -369,9 +381,15 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         ...modelGroups.map((_, index) => ({ kind: "adapter", index })),
     ];
     // ── state transitions ──────────────────────────────────────────────────────
+    // T8: the previews fold the CURRENT staged metadata — never only what the last review saw
+    const stagedMetadata = () => {
+        const { classifications, efforts, seededAllowOut } = editorState();
+        return { classifications, efforts, seededAllowOut };
+    };
     const editorState = () => ({
         ...denyLists(),
         allowOut: [...ui.allowOut].sort(),
+        seededAllowOut: structuredClone(ui.seededAllowOut),
         classifications: ui.classifications.map((classification) => classification.vendor && classification.channel
             ? {
                 ...classification,
@@ -419,9 +437,38 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             finish({ kind: "no-changes" });
             return;
         }
+        if (nextReview.kind === "refused") {
+            ui.notice = `w refused — ${nextReview.reason}`;
+            bump();
+            return;
+        }
         setOverlay({ kind: "review", review: nextReview, scroll: 0 });
     };
+    // T10 (D-925/D-939): a model the current allow form leaves out gets its OWN allow entry staged beside
+    // its classification — the ownAllow spelling Space clears — so it can be admitted in this session.
+    // Re-staging a classification replaces its seed; a row the allow form admits seeds nothing. A row a
+    // flat deny ALSO excludes still seeds, so successive owning lifts (deny, then allow) admit it.
+    const seedAllow = (adapter, model, displayModel) => {
+        // ponytail: a collapsed variant row's allow entry would name no channel (its display name is not the real
+        // model), so it is not seeded for same-session admission — classify, save, then admit next session;
+        // full grouped-row membership (collapse + catalog fold) is 2.6.7 (T10 owed review F1, D-1016)
+        if (model !== displayModel)
+            return;
+        const identity = groupOf(adapter)?.rows.find((row) => row.model === displayModel)?.evidence?.identity;
+        const self = { adapter, model: displayModel, ...(identity !== undefined ? { identity } : {}) };
+        const policy = stagedPolicy();
+        if (!policy.ok || !exclusionsOf(self, policy.routing, "judge").some((scope) => scope.by === "allow"))
+            return;
+        const entry = selectOwn(ui.allowOut, self) ?? `${adapter}:${displayModel}`;
+        ui.allowOut = new Set([...ui.allowOut, entry]);
+        ui.seededAllowOut = [
+            ...ui.seededAllowOut.filter((seed) => seed.adapter !== adapter || seed.model !== model),
+            { adapter, model, displayModel, ...(identity !== undefined ? { identity } : {}), entry },
+        ];
+    };
     const stageSuggested = (adapter, rows, firstTouch) => {
+        for (const row of rows)
+            seedAllow(adapter, row.model, row.displayModel);
         ui.classifications = [
             ...ui.classifications,
             ...rows.map((row) => ({
@@ -476,6 +523,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     };
     const applyClassification = (overlay) => {
         const answered = overlay.vendor ? ui.channelByAdapter[overlay.adapter] : undefined;
+        seedAllow(overlay.adapter, overlay.model, overlay.displayModel ?? overlay.model);
         ui.classifications = [
             ...ui.classifications,
             {
@@ -733,7 +781,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         // channel must be OFFERED at or above the floor once every policy scope is open — a failed
         // model probe (dropped by discovery), a pin or a pool keep it out of that list and a floor
         // marks it belowFloor, so nothing here lifts it.
-        const eligible = candidatesForShape(overlay.shape, ui.selectedMode, ui.map, openStagedDeny()).rows
+        const eligible = candidatesForShape(overlay.shape, ui.selectedMode, ui.map, openStagedDeny(), stagedMetadata()).rows
             .some((row) => row.id === id && !row.belowFloor);
         if (!eligible) {
             // the ledger line spells its reasons; drop the row label and the reach segment for the notice
@@ -756,7 +804,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         const text = `lift: cleared ${found.entry} from ${found.scope}${after.reach === "in" ? "" : ` — still out: ${after.reasons.join("; ")}`}`;
         ui.lastEdit = { id, text };
         ui.notice = text;
-        const picked = candidatesForShape(overlay.shape, ui.selectedMode, ui.map, stagedDeny());
+        const picked = candidatesForShape(overlay.shape, ui.selectedMode, ui.map, stagedDeny(), stagedMetadata());
         ui.overlay = { ...overlay, rows: picked.rows, excludedNote: picked.excludedNote, ledger: picked.ledger ?? [], at: 0 };
         bump();
     };
@@ -1540,7 +1588,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                 const group = modelGroups[ui.adapterAt];
                 const suggested = rows
                     .filter((candidate) => candidate.adapter === group.adapter && !candidate.tier && candidate.suggestion !== undefined)
-                    .map((candidate) => ({ model: candidate.classifyModel ?? candidate.model, suggestion: candidate.suggestion }));
+                    .map((candidate) => ({ model: candidate.classifyModel ?? candidate.model, displayModel: candidate.model, suggestion: candidate.suggestion }));
                 if (!suggested.length) {
                     ui.notice = "no catalog tier suggestions among the visible unclassified models — evidence comes from the cached catalogs (AA index / API pricing)";
                     bump();
@@ -1590,17 +1638,12 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             if (!shape)
                 return;
             if (hotkey === "a") {
-                // OBS-525: auto reverts the shape's WHOLE routing declaration — pool included, not just
-                // the pin. prefer survives: it biases auto routing and is valid without pin/pool.
-                const nextEntry = { ...ui.map[shape] };
-                delete nextEntry.pin;
-                delete nextEntry.pool;
-                ui.map = { ...ui.map, [shape]: nextEntry };
+                ui.map = { ...ui.map, [shape]: autoMapEntry(ui.map[shape]) };
                 bump();
                 return;
             }
             if (key.return || hotkey === "p") {
-                const picked = candidatesForShape(shape, ui.selectedMode, ui.map, stagedDeny());
+                const picked = candidatesForShape(shape, ui.selectedMode, ui.map, stagedDeny(), stagedMetadata());
                 setOverlay({
                     kind: "candidates",
                     shape,
@@ -1677,7 +1720,8 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     const reachDetail = (row) => {
         if (row.evidence?.unauthed !== undefined)
             return "unauthed — re-probe with tickmarkr doctor (Space does not toggle reach)";
-        const reasons = row.reasons.join("; ");
+        // T10: the reasons, then where each scope is held — the overlay a reviewed w writes
+        const reasons = `${row.reasons.join("; ")}${row.held.length ? ` — held: ${row.held.join("; ")}` : ""}`;
         if (row.reach === "out-all")
             return `reach: out · all seats — ${reasons} — Space picks in or out · workers`;
         if (row.reach === "out-allow")
@@ -1791,7 +1835,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         if (!overlay)
             return null;
         if (overlay.kind === "presets") {
-            const details = modeOptions[overlay.at] ? modePreview(modeOptions[overlay.at].id, ui.map, stagedDeny()) : [];
+            const details = modeOptions[overlay.at] ? modePreview(modeOptions[overlay.at].id, ui.map, stagedDeny(), stagedMetadata()) : [];
             return (_jsxs(OverlayPanel, { title: overlay.home ? "routing preset" : "routing mode", width: bodyW, children: [_jsx(Text, { dimColor: true, children: overlay.home ? "a preset routes every shape — custom opens the browser" : "floors move with the mode; the browser edits the rest" }), _jsx(Text, { children: " " }), modeOptions.map((option, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.at === index }), option.id === ui.selectedMode ? _jsx(Glyph, { kind: "on" }) : _jsx(Text, { children: " " }), _jsx(Text, { bold: overlay.at === index, children: ` ${padCell(option.id, 12)}` }), _jsx(Text, { dimColor: true, children: clip(option.gloss, bodyW - 20) })] }, option.id))), overlay.home && (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.at === modeOptions.length }), _jsx(Text, { children: " " }), _jsx(Text, { bold: overlay.at === modeOptions.length, children: ` ${padCell("custom", 12)}` }), _jsx(Text, { dimColor: true, children: clip("open the fleet browser (models · shapes · steering)", bodyW - 20) })] })), _jsx(Text, { children: " " }), details.map((line) => _jsx(Text, { dimColor: true, children: line }, line))] }));
         }
         if (overlay.kind === "review") {
@@ -1936,8 +1980,8 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                     lines.push(coveringDetail(row));
                 if (!row.tier) {
                     lines.push(row.suggestion
-                        ? `catalog suggests ${row.suggestion.tier} — Space/Enter classifies with the note pre-typed · s stages every visible suggestion`
-                        : "unclassified — Space/Enter classifies; unclassified models are never routed");
+                        ? `catalog suggests ${row.suggestion.tier} — Space/Enter classifies with the note pre-typed (t too) · s stages every visible suggestion`
+                        : "unclassified — Space/Enter classifies (t too), then Space sets its reach in this session; unclassified models are never routed");
                 }
             }
             return lines;
@@ -2054,7 +2098,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                 ? _jsx(Text, { color: INK.warn, children: ` ! ${clip(ui.notice, width - 4)}` })
                 : details.map((line) => _jsx(Text, { dimColor: true, children: ` ${clip(line, width - 2)}` }, line)), _jsx(KeyBar, { binds: keyBinds() })] }));
 }
-export async function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut = [], initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, reloadGuard, stagedRouting, entry = "probe", initialJudge = "", judgeSeats = [], initialInput = [], input, output, debug = false, ...initialDenyProps }) {
+export async function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut = [], initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, reloadGuard, stagedRouting, holderOf, entry = "probe", initialJudge = "", judgeSeats = [], initialInput = [], input, output, debug = false, ...initialDenyProps }) {
     const agents = adapters.flatMap((adapter) => {
         const state = health[adapter.id];
         if (!state?.installed)
@@ -2078,7 +2122,7 @@ export async function runFleetInkEditor({ ageMs, adapters, health, initialAllowO
     // rebuilt from output.columns/rows so a pane resize re-renders at the new size. Same root
     // element type on every rerender ⇒ React keeps the component instance, so staged edits,
     // cursor, and overlays all survive the resize.
-    const editorElement = () => (_jsx(FleetApp, { ageMs: ageMs, agents: agents, ...initialDenyProps, initialAllowOut: initialAllowOut, initialEfforts: initialEfforts, modelGroups: declaredModelGroups, initialMode: initialMode, modeOptions: modeOptions, initialMap: initialMap, modePreview: modePreview, shapeRows: shapeRows, candidatesForShape: candidatesForShape, preferOptionsForShape: preferOptionsForShape, initialSteering: initialSteering, steeringOptionsFor: steeringOptionsFor, reviewAdvisories: reviewAdvisories, reviewOverlay: reviewOverlay, reloadGuard: reloadGuard, stagedRouting: stagedRouting, entry: entry, initialJudge: initialJudge, judgeSeats: judgeSeats, 
+    const editorElement = () => (_jsx(FleetApp, { ageMs: ageMs, agents: agents, ...initialDenyProps, initialAllowOut: initialAllowOut, initialEfforts: initialEfforts, modelGroups: declaredModelGroups, initialMode: initialMode, modeOptions: modeOptions, initialMap: initialMap, modePreview: modePreview, shapeRows: shapeRows, candidatesForShape: candidatesForShape, preferOptionsForShape: preferOptionsForShape, initialSteering: initialSteering, steeringOptionsFor: steeringOptionsFor, reviewAdvisories: reviewAdvisories, reviewOverlay: reviewOverlay, reloadGuard: reloadGuard, stagedRouting: stagedRouting, holderOf: holderOf, entry: entry, initialJudge: initialJudge, judgeSeats: judgeSeats, 
         // v1.90.9: cap every list to the terminal minus chrome so the cursor and header can
         // never scroll off-screen (omp's 218-model list did exactly that pre-cap).
         // OBS-523: chrome is ≤12 rows worst case (header, borders, padding, scope+search,

package/package.json

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

package/skills/tickmarkr-auto/SKILL.md

@@ -12,7 +12,7 @@ Use the canonical loop skill's [cockpit, parked decisions and printed twins](../
 for each target: delivered views are **1 Home, 4 Run, 5 Evidence**; Fleet/Bootstrap and
 Plan/Health remain follow-ons with CLI entries. The recorded 1/3 merged, human T2, blocked
 T3 case stays PARTIAL despite tip pass. Review the Run confirmation, read back the appended
-`task-approved` receipt, and explicitly `tickmarkr resume <runId>` when no live owner exists;
+`task-approved` receipt, and explicitly launch `tickmarkr resume <runId>` with the host-owned split form below when no live owner exists;
 approval records permission and never dispatches work itself. Non-TTY readers keep `status`,
 `report` and default-watch line output, with `--watch --plain` as the TTY fallback.
 Keep `name: tickmarkr-auto` and the installed links to canonical `skills/` intact.
@@ -92,7 +92,37 @@ After sending, **confirm delivery** by reading the target pane and verifying the
 1. **Prepare** — confirm the target list. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec-or-directory>`. Fix source-spec defects instead of editing the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review routes, capability-floor warnings, and human gates before execution.
-4. **Run** — run `tickmarkr run`. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every execution clause for you; the debt clause is yours — read CURRENT `tickmarkr status <runId>` (step 5). Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the relevant agent session.
+4. **Run** — launch `tickmarkr run` using the [host-owned split form](#host-owned-daemon-and-detached-beats), and start detached beats with their run-end stop items. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every execution clause for you; the debt clause is yours — read CURRENT `tickmarkr status <runId>` (step 5). Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the relevant agent session.
 5. **Verify and consolidate** — continue only after a green run. A run is green when the run-end event exists in the journal, the tip verify is not "failed", the summary's `failed`, `human`, `blocked` and `pending` buckets are all empty, and CURRENT `tickmarkr status <runId>` reads its owed checks outstanding empty AND known (`outstanding 0`) — a run with a parked task is partial, not green. Empty execution buckets alone are not green either (D-660): every bucket empty and the tip passed, but an operator waived one review, leaves one accepted-risk review check owed — status reads `outstanding 1 (T7 review)` and `run`/`resume` still exit 0 on execution alone, so the run is execution complete, not green. It turns green only when a `tickmarkr verify --record <runId>` discharge moves CURRENT status to `outstanding 0`, including a discharge landing after run-end — the historical run-end record keeps the old count, so never read debt from it; `outstanding unknown` is never green. Tickmarkr consolidates accepted work on `tickmarkr/<runId>` and never signs off to the main branch. A human controls any later release merge.
 6. **Record** — `tickmarkr report <runId> --md` prints Markdown to stdout; redirect explicitly beside the spec (for example `tickmarkr report <runId> --md > feature.record.md`) and commit the execution record when the repository tracks those records.
 7. **Continue** — move to the next requested target. If a target fails or is parked, stop with the journal evidence rather than silently skipping it.
+
+## Host-owned daemon and detached beats
+
+Launch the daemon as a SPLIT of the orchestrator's own pane in the ORCH tab, owned by the
+host PTY. Never launch it as an agent harness background task or in a separate tab. The daemon
+self-places its board from that split, keeping both daemon and board in the ORCH tab.
+
+- **On Orca (`TERM_PROGRAM=Orca` and non-empty `ORCA_TERMINAL_HANDLE`)**:
+  `orca terminal split --terminal "$ORCA_TERMINAL_HANDLE" --direction vertical --command "tickmarkr run"`.
+- **On herdr (`HERDR_ENV=1`)**: use `herdr pane split` on the orchestrator's own pane, then
+  `herdr pane run <new> "tickmarkr run"` in the returned split.
+
+For `resume`, use the same host-owned split form with `tickmarkr resume <runId>` in place of
+`tickmarkr run`. After either launch, read this repository's lock pid and walk its ppid chain
+in the process table to the host PTY; verify no agent session is an ancestor. If an agent is
+an ancestor, stop that launch and relaunch through the host split before continuing.
+
+Start `tickmarkr beat <tier> --seat <seat> --loop` as a DETACHED background process, one per
+(tier, seat), from the repository root. Use setsid plus nohup (or the host's equivalent detached
+session facility), redirect output to a file, and record a pidfile under the repository's state
+dir. Verify ppid 1 and no agent-session ancestor. Never put beats in a harness background task
+or a visible tab. The lifecycle must be idempotent: start checks the pidfile against the live
+process payload and returns an "already running" no-op for the same (repo, tier, seat); status
+checks that payload and beat freshness; stop sends `--stand-down` for the same tier and seat,
+verifies the loop exits within one interval, then removes its pidfile. A stale or reused pid
+must never be killed without matching its live payload. Include a run-end stop item for every
+beat started, also on failure, park or handoff; verify DISARMED and remove retired beat files.
+
+Keep only watchers that must WAKE the seat in the harness. Re-arm them on each wake and at
+their harness cap; daemon and beat lifetimes must not depend on that cap.

package/skills/tickmarkr-loop/SKILL.md

@@ -88,10 +88,40 @@ When spawning consultants (agents gathering synthesis input for decisions like S
 1. **Prepare** — start from the requested spec. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec>`. Correct compilation errors in the spec, never in the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review the routing table, capability-floor warnings, and every human gate, including work that each gate blocks.
-4. **Run** — run `tickmarkr run`. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every execution clause for you; the debt clause is yours — read CURRENT `tickmarkr status <runId>` (step 5). Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
+4. **Run** — launch `tickmarkr run` using the [host-owned split form](#host-owned-daemon-and-detached-beats), and start detached beats with their run-end stop items. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every execution clause for you; the debt clause is yours — read CURRENT `tickmarkr status <runId>` (step 5). Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
 5. **Verify and consolidate** — accept only a green run. A run is green when the run-end event exists in the journal, the tip verify is not "failed", the summary's `failed`, `human`, `blocked` and `pending` buckets are all empty, and CURRENT `tickmarkr status <runId>` reads its owed checks outstanding empty AND known (`outstanding 0`) — a run with a parked task is partial, not green. Empty execution buckets alone are not green either (D-660): every bucket empty and the tip passed, but an operator waived one review, leaves one accepted-risk review check owed — status reads `outstanding 1 (T7 review)` and `run`/`resume` still exit 0 on execution alone, so the run is execution complete, not green. It turns green only when a `tickmarkr verify --record <runId>` discharge moves CURRENT status to `outstanding 0`, including a discharge landing after run-end — the historical run-end record keeps the old count, so never read debt from it; `outstanding unknown` is never green. Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
 6. **Record** — `tickmarkr report <runId> --md` prints Markdown to stdout. Redirect it explicitly beside the source spec (for example `tickmarkr report <runId> --md > feature.record.md`) and commit the execution record when the repository tracks those records. Then [stand down](#stand-down-mission-end-and-retirement).
 
+## Host-owned daemon and detached beats
+
+Launch the daemon as a SPLIT of the orchestrator's own pane in the ORCH tab, owned by the
+host PTY. Never launch it as an agent harness background task or in a separate tab. The daemon
+self-places its board from that split, keeping both daemon and board in the ORCH tab.
+
+- **On Orca (`TERM_PROGRAM=Orca` and non-empty `ORCA_TERMINAL_HANDLE`)**:
+  `orca terminal split --terminal "$ORCA_TERMINAL_HANDLE" --direction vertical --command "tickmarkr run"`.
+- **On herdr (`HERDR_ENV=1`)**: use `herdr pane split` on the orchestrator's own pane, then
+  `herdr pane run <new> "tickmarkr run"` in the returned split.
+
+For `resume`, use the same host-owned split form with `tickmarkr resume <runId>` in place of
+`tickmarkr run`. After either launch, read this repository's lock pid and walk its ppid chain
+in the process table to the host PTY; verify no agent session is an ancestor. If an agent is
+an ancestor, stop that launch and relaunch through the host split before continuing.
+
+Start `tickmarkr beat <tier> --seat <seat> --loop` as a DETACHED background process, one per
+(tier, seat), from the repository root. Use setsid plus nohup (or the host's equivalent detached
+session facility), redirect output to a file, and record a pidfile under the repository's state
+dir. Verify ppid 1 and no agent-session ancestor. Never put beats in a harness background task
+or a visible tab. The lifecycle must be idempotent: start checks the pidfile against the live
+process payload and returns an "already running" no-op for the same (repo, tier, seat); status
+checks that payload and beat freshness; stop sends `--stand-down` for the same tier and seat,
+verifies the loop exits within one interval, then removes its pidfile. A stale or reused pid
+must never be killed without matching its live payload. Include a run-end stop item for every
+beat started, also on failure, park or handoff; verify DISARMED and remove retired beat files.
+
+Keep only watchers that must WAKE the seat in the harness. Re-arm them on each wake and at
+their harness cap; daemon and beat lifetimes must not depend on that cap.
+
 ## Cockpit, parked decisions and printed twins
 
 The shipped cockpit is **1 Home, 4 Run, 5 Evidence**: `tickmarkr ui [runId]` defaults to
@@ -107,7 +137,7 @@ run/task, original park `#L`, actor/reason, exact argv, consequence and enactor.
 confirms; `n`/Esc cancel; Enter never confirms. Read the receipt's appended `task-approved`
 line and actor/reason back from the journal. Approval records permission, never dispatch,
 a passed gate or task completion. With no live owner it says **approved; resume required**:
-exit the observer and run `tickmarkr resume <runId>` explicitly. A matching live daemon
+exit the observer and launch `tickmarkr resume <runId>` explicitly with the same host-owned split form above. A matching live daemon
 enacts at its next task boundary; if a different live run owns the repository lock, wait
 for that run to end before resuming this one.
 
@@ -177,6 +207,20 @@ repair and catalog refresh; default doctor and `--fix` still probe. `scope <inte
 --preview` performs no probes, model calls or writes; authoring requires confirmation or
 `--yes`. These actions remain CLI entries until their follow-on views ship.
 
+**macOS host failure: a launchservicesd restart (D-787/D-789).** If GUI apps suddenly read "The
+application … is not open anymore" during a local suite, launchservicesd crashed and respawned with an
+empty app registry. That was measured on 2026-09-30: `0x1000600b` Mach port exhaustion under node
+`process.title` check-ins, crash at 17:15:00Z and respawn at 17:15:09Z. `tickmarkr doctor` and standalone
+`tickmarkr verify` record the daemon's pid/start through the separate `src/run/launchservices-check.ts`
+module: one bounded `/bin/ps` read with a 5000 ms kill ceiling. doctor's wiring is five lines in
+`src/cli/commands/doctor.ts`. The identity lives on the first `doctor.json` record, and one advisory
+prints and persists when it changed. Unknown evidence keeps the prior identity, and verdicts and retries
+never change. Confirm the identity with `/bin/ps -o pid=,lstart= -p "$(pgrep -x launchservicesd)"`: it
+is young beside Dock and Finder. Confirm the log with `/usr/bin/log show --start '<that lstart minus two
+minutes>'`, looking for `0x1000600b` then `Successfully spawned launchservicesd`. Type the full path: a bare
+`log` is a zsh builtin that prints nothing. Then quit and relaunch the affected apps, or log out /
+restart once the run is stood down; a restart ends agent sessions and wipes `/private/tmp`.
+
 Keep this skill's canonical identity `tickmarkr-loop`; sibling skills link to this
 walkthrough. In this repository `skills/` is canonical and installed `.claude/skills/`
 files resolve to it; change the canonical source, never create a second help skill.