tickmarkr 1.76.0 → 1.77.0

package/dist/adapters/kimi.js

@@ -137,16 +137,37 @@ export function confirmKimiSeedBanner(banner, assignedModel) {
     }
     return { ok: true, sessionId: kimiBannerSessionId(banner) };
 }
-// v1.75 T1 / OBS-136: this readiness line is rendered inside Kimi Code's bordered steady-state
-// input box. The adapter owns the fingerprint; the driver only consults declarations generically.
+const kimiTuiLaunch = (model) => `kimi -y -m ${shq(model)}`;
+const KIMI_ANSI_SGR_RE = /\u001B\[[0-9;]*m/g;
+const KIMI_EDITOR_TOP_RE = /^╭─+╮$/;
+const KIMI_EDITOR_INPUT_RE = /^│ > .*│$/;
+const KIMI_EDITOR_EMPTY_RE = /^│ > +│$/;
+const KIMI_EDITOR_BOTTOM_RE = /^╰─+╯$/;
+function matchesKimiEditorBox(paneText, empty) {
+    const lines = paneText.replace(KIMI_ANSI_SGR_RE, "").split("\n");
+    const input = empty ? KIMI_EDITOR_EMPTY_RE : KIMI_EDITOR_INPUT_RE;
+    return lines.some((line, index) => input.test(line)
+        && index > 0
+        && index + 1 < lines.length
+        && KIMI_EDITOR_TOP_RE.test(lines[index - 1])
+        && KIMI_EDITOR_BOTTOM_RE.test(lines[index + 1]));
+}
+// v1.75 T1 / OBS-136: Kimi's actual editor is a three-line bordered box whose content row starts
+// `│ > `. The welcome panel separately contains "Send /help..." and is only launch-liveness
+// evidence (OBS-142), so it must never satisfy this declaration. The adapter owns the full matcher,
+// empty-state matcher, launch distinction, and bounded cold-start window; the driver stays generic.
 export const KIMI_INPUT_BOX = declareInputBox("kimi", {
-    fingerprint: "Send /help for help information.",
+    fingerprint: "│ > ",
+    match: (paneText) => matchesKimiEditorBox(paneText, false),
+    emptyMatch: (paneText) => matchesKimiEditorBox(paneText, true),
+    launchCommand: (command) => command.startsWith("kimi -y -m "),
+    readinessTimeoutMs: 15_000,
 });
 // Shared launch-then-seed surface (T6) + banner confirm (T7/T2). One definition so the adapter
 // property and the daemon's generic runInteractiveSeed path cannot drift.
 const KIMI_SEED = {
     // v1.76 T2 / OBS-141: 0.29.0 resolves only the full config.toml model key on the first turn.
-    launch: (model) => `kimi -y -m ${shq(model)}`,
+    launch: kimiTuiLaunch,
     readinessMatch: "Send /help for help information.",
     seedLine: (promptFile) => `Read ${promptFile} and do exactly what it says.`,
     confirmBanner: confirmKimiSeedBanner,

package/dist/adapters/types.d.ts

@@ -84,10 +84,15 @@ export interface TrustDialog {
 export declare function matchesTrustDialog(paneText: string, dialog: TrustDialog): boolean;
 export interface InputBox {
     fingerprint: string;
+    match?(paneText: string): boolean;
+    emptyMatch?(paneText: string): boolean;
+    launchCommand?(command: string): boolean;
+    readinessTimeoutMs?: number;
 }
 export declare function declareInputBox(adapterId: string, inputBox: InputBox): InputBox;
 export declare function declaredInputBoxForWorkerName(workerName: string): InputBox | undefined;
 export declare function matchesInputBox(paneText: string, inputBox: InputBox): boolean;
+export declare function matchesEmptyInputBox(paneText: string, inputBox: InputBox): boolean;
 export interface WorkerAdapter {
     id: string;
     vendor: string;

package/dist/adapters/types.js

@@ -40,7 +40,10 @@ export function declaredInputBoxForWorkerName(workerName) {
     return adapterId === undefined ? undefined : inputBoxes.get(adapterId);
 }
 export function matchesInputBox(paneText, inputBox) {
-    return paneText.includes(inputBox.fingerprint);
+    return inputBox.match?.(paneText) ?? paneText.includes(inputBox.fingerprint);
+}
+export function matchesEmptyInputBox(paneText, inputBox) {
+    return inputBox.emptyMatch?.(paneText) === true;
 }
 export function channelsFromConfig(adapterId, cfg) {
     const e = cfg.tiers[adapterId];

package/dist/drivers/herdr.d.ts

@@ -2,6 +2,12 @@ import { type ExecutorDriver, type NotifyOpts, type Slot, type SlotOpts } from "
 export declare const TRAILER_SAFE_FLOOR_COLS = 108;
 export declare const TRAILER_WIDTH_MARGIN = 2;
 export declare const DELIVERY_ATTEMPTS = 3;
+export declare class DeliveryReadinessError extends Error {
+    readonly waitedMs: number;
+    readonly transcript: string;
+    readonly phase = "READINESS";
+    constructor(waitedMs: number, transcript: string);
+}
 /** First-generation join direction from measured trailer-safe floor (43-MEASUREMENT.md). */
 export declare function workerSplitDirection(paneCols: number | null, safeFloor?: number, margin?: number): "right" | "down";
 export declare class HerdrDriver implements ExecutorDriver {
@@ -41,8 +47,10 @@ export declare class HerdrDriver implements ExecutorDriver {
     private joinGroup;
     run(slot: Slot, cmd: string): Promise<void>;
     private deliver;
+    private deliverPersistentShellCommand;
     private submitVerifiedDelivery;
     private settleDeliveryLine;
+    private awaitDeliveryReadiness;
     private deliveryReadMatches;
     private waitOk;
     waitOutput(slot: Slot, pattern: string, timeoutMs: number, opts?: {

package/dist/drivers/herdr.js

@@ -1,4 +1,4 @@
-import { declaredInputBoxForWorkerName, matchesInputBox, shq } from "../adapters/types.js";
+import { declaredInputBoxForWorkerName, matchesEmptyInputBox, matchesInputBox, shq } from "../adapters/types.js";
 import { PANE_IDENTITY_ENV, paneIdentityLine } from "../brand.js";
 import { createWorktree, sh } from "../run/git.js";
 import { herdrSealShellPrefix } from "./subprocess.js";
@@ -13,6 +13,21 @@ const DELIVERY_VERIFY_TIMEOUT_MS = 2000; // per attempt — a paste that hasn't
 const DELIVERY_READ_LINES = 80;
 const DELIVERY_SETTLE_READ_ATTEMPTS = 6;
 const DELIVERY_SETTLE_POLL_MS = 100;
+const DELIVERY_READINESS_TIMEOUT_MS = 1_000;
+// OBS-142: a typed identity lets the daemon's next task distinguish cold-start variance from
+// structural driver faults without parsing prose. The message also carries the bounded wait and
+// final pane evidence so a terminal failure is diagnosable on its own.
+export class DeliveryReadinessError extends Error {
+    waitedMs;
+    transcript;
+    phase = "READINESS";
+    constructor(waitedMs, transcript) {
+        super(`herdr delivery READINESS failed after ${waitedMs}ms — interface never became interactive (OBS-142); pane transcript:\n${transcript}`);
+        this.waitedMs = waitedMs;
+        this.transcript = transcript;
+        this.name = "DeliveryReadinessError";
+    }
+}
 /** First-generation join direction from measured trailer-safe floor (43-MEASUREMENT.md). */
 export function workerSplitDirection(paneCols, safeFloor = TRAILER_SAFE_FLOOR_COLS, margin = TRAILER_WIDTH_MARGIN) {
     if (paneCols == null || paneCols <= 0)
@@ -96,17 +111,18 @@ export class HerdrDriver {
         const needle = norm(cmd);
         return needle.length > 0 && hay.includes(needle);
     }
-    // Submission succeeds when the typed prompt disappears, or when it has moved above a fresh
-    // adapter-declared input box (the prompt is now transcript, not input). Shell-line delivery uses
-    // the same normalized seam: a prompt still at the bottom ends the pane text; output/a fresh prompt
-    // after it proves Enter registered. No adapter-specific fingerprint lives in the driver.
+    // Submission requires positive post-Enter evidence. A prompt echoed above a fresh input target
+    // proves registration; a declared box that is visibly empty after the verified paste also proves
+    // it consumed the prompt. Prompt absence alone is never success (OBS-142).
     submissionRegistered(transcript, cmd, inputBox) {
         const norm = (s) => s.replace(/\s+/g, "");
         const hay = norm(transcript);
         const needle = norm(cmd);
         const promptAt = hay.lastIndexOf(needle);
-        if (needle.length === 0 || promptAt < 0)
-            return true;
+        if (needle.length === 0)
+            return false;
+        if (promptAt < 0)
+            return inputBox !== undefined && matchesEmptyInputBox(transcript, inputBox);
         if (inputBox && matchesInputBox(transcript, inputBox)) {
             return hay.lastIndexOf(norm(inputBox.fingerprint)) > promptAt;
         }
@@ -409,7 +425,8 @@ export class HerdrDriver {
             this.deliveredPanes.set(slot, paneId);
         });
     }
-    async deliver(slot, cmd, pane) {
+    async deliver(slot, cmd, pane, verifySubmission = true) {
+        const readiness = await this.awaitDeliveryReadiness(slot, cmd, pane);
         let transcript = "";
         for (let attempt = 0; attempt < DELIVERY_ATTEMPTS; attempt++) {
             if (attempt > 0) {
@@ -436,7 +453,14 @@ export class HerdrDriver {
                 throw new Error(`herdr pane send-text failed: ${typed.stderr || typed.stdout}`);
             const back = await this.herdr(`pane wait-output ${shq(pane)} --match ${shq(cmd)} --timeout ${DELIVERY_VERIFY_TIMEOUT_MS}`, slot.cwd, DELIVERY_VERIFY_TIMEOUT_MS + 15_000);
             if (this.waitOk(back.code, back.stdout) || await this.deliveryReadMatches(pane, cmd, slot.cwd)) {
-                await this.submitVerifiedDelivery(slot, cmd, pane);
+                if (verifySubmission) {
+                    await this.submitVerifiedDelivery(slot, cmd, pane, readiness);
+                }
+                else {
+                    const enter = await this.herdr(`pane send-keys ${shq(pane)} Enter`, slot.cwd);
+                    if (enter.code !== 0)
+                        throw new Error(`herdr pane send-keys Enter failed: ${enter.stderr || enter.stdout}`);
+                }
                 return;
             }
             // capture the corrupted delivery BEFORE clearing it — the OBS-85 byte-level evidence
@@ -444,9 +468,23 @@ export class HerdrDriver {
         }
         throw new Error(`herdr delivery corrupted after ${DELIVERY_ATTEMPTS} attempts — enter never pressed (OBS-85); pane transcript:\n${transcript}`);
     }
-    async submitVerifiedDelivery(slot, cmd, pane) {
+    // The narrator launches a perpetual shell watch, not an adapter-backed input interface. Keep
+    // OBS-85's readiness + paste read-back and the historical single Enter, while worker/gate runs
+    // continue through positive post-Enter evidence in submitVerifiedDelivery.
+    async deliverPersistentShellCommand(slot, cmd) {
+        return this.deliveryQueue(async () => {
+            const pane = await this.paneId(slot);
+            await this.deliver(slot, cmd, pane, false);
+            this.deliveredPanes.set(slot, pane);
+        });
+    }
+    async submitVerifiedDelivery(slot, cmd, pane, readiness) {
         let transcript = "";
         const inputBox = this.inputBoxes.get(slot);
+        // The base window preserves OBS-140's bounded behavior. A slow readiness observation grants
+        // the same measured time once more for submit paint, capped by the readiness bound itself.
+        const baseVerifyMs = (DELIVERY_SETTLE_READ_ATTEMPTS - 1) * DELIVERY_SETTLE_POLL_MS;
+        const verifyWindowMs = Math.min(baseVerifyMs + readiness.timeoutMs, baseVerifyMs + readiness.waitedMs);
         for (let attempt = 0; attempt < DELIVERY_SUBMIT_ATTEMPTS; attempt++) {
             const enter = await this.herdr(`pane send-keys ${shq(pane)} Enter`, slot.cwd);
             if (enter.code !== 0)
@@ -454,7 +492,7 @@ export class HerdrDriver {
             // Reuse the existing settle-read window. A first-read success returns before any timer; only
             // a prompt that still occupies the delivery target spends the bounded settle window. This
             // verification always completes before a possible re-press, so a slow submit cannot duplicate.
-            const settled = await this.settleDeliveryLine(pane, slot.cwd, transcript, inputBox, (candidate) => this.submissionRegistered(candidate, cmd, inputBox));
+            const settled = await this.settleDeliveryLine(pane, slot.cwd, transcript, inputBox, (candidate) => this.submissionRegistered(candidate, cmd, inputBox), verifyWindowMs);
             transcript = settled.transcript;
             if (settled.ok)
                 return;
@@ -464,9 +502,12 @@ export class HerdrDriver {
         }
         throw new Error(`herdr delivery corrupted after ${DELIVERY_SUBMIT_ATTEMPTS} submit attempts — submission never registered (OBS-140); pane transcript:\n${transcript}`);
     }
-    async settleDeliveryLine(pane, cwd, initialTranscript, inputBox, accept) {
+    async settleDeliveryLine(pane, cwd, initialTranscript, inputBox, accept, settleWindowMs) {
         let transcript = initialTranscript;
-        for (let readAttempt = 0; readAttempt < DELIVERY_SETTLE_READ_ATTEMPTS; readAttempt++) {
+        const readAttempts = settleWindowMs === undefined
+            ? DELIVERY_SETTLE_READ_ATTEMPTS
+            : Math.max(DELIVERY_SETTLE_READ_ATTEMPTS, Math.floor(settleWindowMs / DELIVERY_SETTLE_POLL_MS) + 1);
+        for (let readAttempt = 0; readAttempt < readAttempts; readAttempt++) {
             const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);
             if (read.code !== 0)
                 return { ok: false, transcript: read.stdout || transcript, recognizedInputBox: false, readFailed: true };
@@ -485,12 +526,58 @@ export class HerdrDriver {
                 };
             }
             transcript = read.stdout;
-            if (readAttempt < DELIVERY_SETTLE_READ_ATTEMPTS - 1) {
+            if (readAttempt < readAttempts - 1) {
                 await new Promise((resolve) => setTimeout(resolve, DELIVERY_SETTLE_POLL_MS));
             }
         }
         return { ok: false, transcript, recognizedInputBox: false };
     }
+    async awaitDeliveryReadiness(slot, cmd, pane) {
+        const inputBox = this.inputBoxes.get(slot);
+        const requireInputBox = inputBox !== undefined && inputBox.launchCommand?.(cmd) !== true;
+        const timeoutMs = inputBox?.readinessTimeoutMs ?? DELIVERY_READINESS_TIMEOUT_MS;
+        const started = Date.now();
+        let previous;
+        let transcript = "";
+        let reads = 0;
+        while (true) {
+            const elapsedBeforeRead = Date.now() - started;
+            const remainingBeforeRead = timeoutMs - elapsedBeforeRead;
+            if (remainingBeforeRead <= 0)
+                throw new DeliveryReadinessError(elapsedBeforeRead, transcript);
+            const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, slot.cwd, Math.max(1, Math.ceil(remainingBeforeRead)));
+            reads++;
+            transcript = read.stdout || transcript;
+            const waitedMs = Date.now() - started;
+            if (read.code !== 0) {
+                // Once at least one valid frame has been observed, a read that consumes the remainder of
+                // the readiness budget is the bounded window expiring, not a new submission/protocol
+                // identity. A first-read timeout and every non-timeout read failure remain structural.
+                if (read.timedOut && previous !== undefined && waitedMs >= timeoutMs) {
+                    throw new DeliveryReadinessError(waitedMs, transcript);
+                }
+                const detail = read.stderr || read.stdout || `exit ${read.code}`;
+                throw new Error(`herdr pane read failed during readiness${read.timedOut ? " (timed out)" : ""}: ${detail}`);
+            }
+            if (previous !== undefined) {
+                const stableFrame = read.stdout === previous;
+                const targetReady = stableFrame && (requireInputBox
+                    ? matchesInputBox(previous, inputBox) && matchesInputBox(read.stdout, inputBox)
+                    : !this.deliveryMatches(read.stdout, cmd));
+                if (targetReady)
+                    return { waitedMs, timeoutMs, transcript: read.stdout };
+            }
+            previous = read.stdout;
+            const remaining = timeoutMs - waitedMs;
+            if (remaining <= 0)
+                throw new DeliveryReadinessError(waitedMs, transcript);
+            // The second read is immediate: an already-painted stable target proves readiness with no
+            // added delay. Only observed change spends a poll interval, and every path remains bounded.
+            if (reads > 1) {
+                await new Promise((resolve) => setTimeout(resolve, Math.min(DELIVERY_SETTLE_POLL_MS, remaining)));
+            }
+        }
+    }
     async deliveryReadMatches(pane, cmd, cwd) {
         const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);
         return read.code === 0 && this.deliveryMatches(read.stdout, cmd);
@@ -680,7 +767,7 @@ export class HerdrDriver {
             const s = await this.watchSlot(cwd, name);
             this.watches.set(name, s);
             try {
-                await this.run(s, command);
+                await this.deliverPersistentShellCommand(s, command);
             }
             catch (err) {
                 this.watches.delete(name);

package/dist/run/daemon.js

@@ -9,6 +9,7 @@ import { allAdapters, discoverChannels, getAdapter, probeAll, readDoctor } from
 import { addUsage, channelKey, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
+import { DeliveryReadinessError } from "../drivers/herdr.js";
 import { herdrSealShellPrefix, SubprocessDriver } from "../drivers/subprocess.js";
 import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
@@ -833,6 +834,38 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let earlyLaunchDead = false;
                 let settleParsed;
                 let seedResult;
+                const handleDeliveryReadiness = async (error) => {
+                    journal.append("delivery-readiness-failed", t.id, {
+                        attempt,
+                        waitedMs: error.waitedMs,
+                        transcript: error.transcript,
+                    });
+                    if (keepOpen)
+                        keptSlots.push(slot);
+                    else
+                        await closeSlot(slot);
+                    feedback = `delivery readiness failed after ${error.waitedMs}ms; pane transcript:\n${error.transcript}`;
+                    const step = r.ladder[Math.min(ladderIdx++, r.ladder.length - 1)];
+                    journal.append("escalation", t.id, { step, attempt: attempt + 1 });
+                    await driver.notify(`tickmarkr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
+                    if (step === "retry")
+                        return true;
+                    if (step === "escalate") {
+                        const next = failover("escalate");
+                        if (next) {
+                            assignment = next;
+                            tried.push(channelKey(next));
+                            return true;
+                        }
+                        // no channel left — fall through to a consult
+                    }
+                    if (step === "escalate" || step === "consult") {
+                        const v = await runConsult("delivery-readiness", error.transcript, feedback, []);
+                        return applyVerdict(v, attempt + 1, "dispatch");
+                    }
+                    await park(t, "escalation ladder exhausted", "ladder-exhausted", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
+                    return false;
+                };
                 if (interactive) {
                     // v1.2 interactive: the TUI doesn't exit on completion — the trailer is the finish line.
                     // The exit wrapper still fires if the TUI dies (crash/quit): fast-fail instead of burning the timeout.
@@ -842,11 +875,29 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // v1.69 T6: launch the real TUI without a prompt, wait for readiness, inject one seed turn,
                         // then fall through to the normal trailer harvest. A failed seed is recorded as a finished
                         // failure rather than allowed to race the trailer wait.
-                        seedResult = await runInteractiveSeed({ driver, slot, adapter, assignment, promptFile, taskTimeoutMinutes });
+                        try {
+                            seedResult = await runInteractiveSeed({ driver, slot, adapter, assignment, promptFile, taskTimeoutMinutes });
+                        }
+                        catch (error) {
+                            if (!(error instanceof DeliveryReadinessError))
+                                throw error;
+                            if (await handleDeliveryReadiness(error))
+                                continue attempts;
+                            return;
+                        }
                         output = seedResult.output;
                     }
                     else {
-                        await driver.run(slot, paneDispatchCommand(dispatchScript));
+                        try {
+                            await driver.run(slot, paneDispatchCommand(dispatchScript));
+                        }
+                        catch (error) {
+                            if (!(error instanceof DeliveryReadinessError))
+                                throw error;
+                            if (await handleDeliveryReadiness(error))
+                                continue attempts;
+                            return;
+                        }
                         output = await driver.read(slot, 1000);
                     }
                     if (seedResult?.seedFailed) {
@@ -976,7 +1027,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                     }
                 }
                 else {
-                    await driver.run(slot, paneDispatchCommand(dispatchScript));
+                    try {
+                        await driver.run(slot, paneDispatchCommand(dispatchScript));
+                    }
+                    catch (error) {
+                        if (!(error instanceof DeliveryReadinessError))
+                            throw error;
+                        if (await handleDeliveryReadiness(error))
+                            continue attempts;
+                        return;
+                    }
                     // OBS-54: headless workers have the same output-inactivity budget as visible panes.
                     // v1.76: same monotonic-progress measure as the interactive site; harvest stays raw.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;

package/package.json

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