things-api 0.19.3 → 0.20.0

package/dist/op-result.js

@@ -14,17 +14,26 @@
  * caller runs `things op-result <op-id>` in a FRESH short-lived process and reads
  * the final outcome the killed process already durably wrote (fsync per record).
  *
- * Three outcomes:
+ * Four outcomes:
  *  - FOUND — a final (non-intent) record carries the id: report its result code,
  *    target uuid, and post-verify observation (the standard fields the killed
  *    process would have printed).
- *  - INTENT-ONLY — only an `intent` marker exists: the op is still running, or the
- *    process died between touching the app and writing its final record — the
- *    outcome is UNCERTAIN (the app-side change may have landed). The newest
+ *  - IN-FLIGHT — an unsuperseded `intent` marker whose HOLDER IS ALIVE: the op is
+ *    still running right now. The caller's move is to poll again, not to retry.
+ *  - ORPHANED — an unsuperseded `intent` marker whose holder is GONE: the process
+ *    died between touching the app and writing its final record, so the outcome is
+ *    genuinely UNCERTAIN (the app-side change may have landed). The newest
  *    correlated trace file is surfaced when determinable.
  *  - UNKNOWN — no record carries the id: it never ran, the id is mistyped, or the
  *    record has aged out of the local history.
  *
+ * Splitting the last two used to be impossible: an intent recorded no holder, so
+ * this could only hedge ("still running, OR died mid-flight") and the caller had
+ * to guess which. A keyed intent now carries the writing process's instance
+ * identity (#639), which makes it a question with an answer. The rare third
+ * shape — an intent with no holder recorded — keeps the old hedged status,
+ * because for that record the honest answer really is "cannot tell".
+ *
  * This is a pure history read — it opens no database and drives nothing. Reused by
  * the CLI subcommand and (read-only) the MCP surface through the single library
  * entry point (src/index.ts), like {@link diagnose}.
@@ -32,6 +41,7 @@
 import { readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { auditDir as defaultAuditDir, traceDir as defaultTraceDir } from "./paths.js";
+import { instanceAlive } from "./process-instance.js";
 import { readAuditRecords } from "./write/undo.js";
 /** The trace file whose mtime is closest to `targetTs` (within a window), else null. */
 function correlatedTrace(traceDir, targetTs) {
@@ -116,18 +126,26 @@ export function opResult(opId, options = {}) {
             uuid: null,
             observed: null,
             verify: null,
+            steps: null,
             ts: null,
             durationMs: null,
             tracePath: null,
+            holder: null,
             note: `no change-history record carries op-id "${opId}" — it never ran, the id is mistyped, or ` +
                 "the record has aged out of the local history (`things doctor` shows the history health)",
         };
     }
-    // A final (non-intent) record supersedes the intent marker. Take the NEWEST one
-    // (an ambiguously-failed op can be re-dispatched under the same id, yielding
-    // several finals — the last is the current truth).
-    const finals = matched.filter((r) => r.result !== "intent");
-    if (finals.length > 0) {
+    // An intent is superseded by the final of its OWN attempt, paired by `ts` —
+    // both records of one attempt derive from the same `startedAt`, which is the
+    // schema's documented sibling invariant. Deliberately NOT "the last record
+    // wins": `readAuditRecords` RE-SORTS the trail by `ts`, so file order does not
+    // survive the read. `findPendingIntent` (write/opid.ts) applies the identical
+    // rule, so the reporting surface and the dispatch gate can never disagree
+    // about whether a key is in flight.
+    const settled = new Set(matched.filter((r) => r.result !== "intent").map((r) => r.ts));
+    const pending = matched.findLast((r) => r.result === "intent" && !settled.has(r.ts));
+    if (pending === undefined) {
+        const finals = matched.filter((r) => r.result !== "intent");
         const rec = finals[finals.length - 1];
         return {
             opId,
@@ -138,29 +156,68 @@ export function opResult(opId, options = {}) {
             ...(rec.occurrence !== undefined && { occurrence: rec.occurrence }),
             observed: rec.observed,
             verify: rec.verify,
+            steps: rec.steps ?? null,
             ts: rec.ts,
             durationMs: rec.durationMs,
             tracePath: null,
+            holder: null,
             note: foundNote(rec.result, rec.uuid),
         };
     }
-    // Only intent marker(s): still running, or the process died mid-flight.
-    const rec = matched[matched.length - 1];
-    const tracePath = correlatedTrace(traceDir, rec.ts);
-    return {
+    // An unsuperseded intent. Its holder decides which of the two very different
+    // situations this is — and the caller's next move differs completely between
+    // them, which is why the old single hedged answer was worth splitting.
+    const last = pending;
+    const tracePath = correlatedTrace(traceDir, last.ts);
+    const recorded = last.holder;
+    const holder = recorded === undefined ? null : { ...recorded, alive: instanceAlive(recorded) };
+    const target = last.uuid ?? "<uuid>";
+    const base = {
         opId,
-        status: "intent-only",
-        op: rec.op,
+        op: last.op,
         result: null,
-        uuid: rec.uuid,
+        uuid: last.uuid,
         observed: null,
         verify: null,
-        ts: rec.ts,
+        // An intent marker is written BEFORE the app is touched, so it never carries
+        // steps — the drive had not run yet. The trace file is the recovery here.
+        steps: null,
+        ts: last.ts,
         durationMs: null,
         tracePath,
-        note: "the operation was recorded as STARTED but no final outcome was written — it is still " +
-            "running, or the process died mid-flight (its GUI-side change may have landed). The outcome " +
-            "is UNCERTAIN: re-read the target and inspect the trace" +
+        holder,
+    };
+    if (holder !== null && holder.alive) {
+        return {
+            ...base,
+            status: "in-flight",
+            note: `the operation is STILL RUNNING — it started ${last.ts} and the process that owns it ` +
+                `(pid ${holder.pid}) is alive. Nothing to recover yet: run this command again in a few ` +
+                "seconds until it reports a final outcome. Do NOT resubmit the write — a GUI-driven " +
+                "change takes seconds, and longer on a large or syncing database. (Resubmitting the same " +
+                "op-id while it runs is refused rather than executed, so a retry costs you the wait " +
+                "either way.)",
+        };
+    }
+    if (holder !== null) {
+        return {
+            ...base,
+            status: "orphaned",
+            note: `the operation started ${last.ts} and the process that owned it (pid ${holder.pid}) is ` +
+                "GONE without recording an outcome — its app-side change may or may not have landed. " +
+                `Re-read the target (\`things show ${target}\`) and inspect the trace` +
+                (tracePath !== null ? ` (${tracePath})` : "") +
+                " rather than blind-retrying. Resubmitting the SAME command with the SAME op-id is safe: " +
+                "it re-reads state to decide whether that change is there, replaying it rather than " +
+                "repeating it (and refusing outright when the record cannot settle the question)",
+        };
+    }
+    return {
+        ...base,
+        status: "intent-only",
+        note: "the operation was recorded as STARTED but no final outcome was written, and the record " +
+            "names no process, so whether it is still running cannot be determined from here. The " +
+            `outcome is UNCERTAIN: re-read the target (\`things show ${target}\`) and inspect the trace` +
             (tracePath !== null ? ` (${tracePath})` : "") +
             " rather than blind-retrying",
     };

package/dist/op-result.js.map

@@ -1 +1 @@
-{"version":3,"file":"op-result.js","sourceRoot":"","sources":["../src/op-result.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"op-result.js","sourceRoot":"","sources":["../src/op-result.ts"],"names":[],"mappings":"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"}

package/dist/process-instance.d.ts

@@ -0,0 +1,41 @@
+/** The process that owns an in-flight piece of work, as an identity (not just a pid). */
+export interface ProcessInstance {
+    pid: number;
+    /**
+     * The pid's start time (`ps -o lstart=`), stable for that process's whole
+     * life. Null when it could not be read — the pid alone then carries the
+     * answer, which is weaker but never fabricated.
+     */
+    start: string | null;
+}
+/**
+ * Does a process with this pid exist right now? (Signal 0 tests existence only.)
+ *
+ * Non-positive pids are rejected BEFORE the syscall, and that guard is
+ * load-bearing rather than defensive tidiness: in `kill(2)`, pid 0 means "every
+ * process in the caller's group" and a negative pid means "the group" — both
+ * succeed, so a zero or negative holder would report itself alive forever and
+ * wedge its idempotency key. A holder is always a real process or it is nothing.
+ */
+export declare function pidAlive(pid: number): boolean;
+/** A pid's start time, or null when the pid is gone / `ps` could not answer. */
+export declare function processStart(pid: number): string | null;
+/** This process, as the identity to record on a piece of work it is starting. */
+export declare function currentInstance(): ProcessInstance;
+/** Seams so tests never shell out. */
+export interface InstanceLivenessDeps {
+    pidAlive?: (pid: number) => boolean;
+    processStart?: (pid: number) => string | null;
+}
+/**
+ * Is the RECORDED instance still running?
+ *
+ * Deliberately CONSERVATIVE: this answers a question whose wrong answer is
+ * expensive in one direction only. Reporting a dead writer as alive costs a
+ * caller one more poll; reporting a LIVE writer as dead invites a second
+ * execution of a mutation that is still in flight. So every ambiguity — a start
+ * time that was never recorded, a `ps` that would not answer now — resolves to
+ * "alive". Only a pid that is gone, or one whose start time PROVES it is a
+ * different process wearing the same number, is reported dead.
+ */
+export declare function instanceAlive(instance: ProcessInstance, deps?: InstanceLivenessDeps): boolean;

package/dist/process-instance.js

@@ -0,0 +1,82 @@
+/**
+ * PROCESS INSTANCE IDENTITY — a pid paired with its start time, which is what
+ * makes "is that process still alive?" answerable across a pid reuse.
+ *
+ * A bare pid is not an identity: the kernel recycles pids, so a dead writer's
+ * number can belong to an unrelated process minutes later and `kill(pid, 0)`
+ * would report the writer as alive. Pairing the pid with `ps -o lstart=` — a
+ * value the reusing process cannot reproduce, because it is the moment the
+ * kernel started IT — turns the pair into an identity that only the original
+ * process satisfies.
+ *
+ * This is the same instance-key shape `session-grant.ts` uses to decide whether
+ * the app instance a grant was minted for is still the one running; both callers
+ * share this module so the liveness rule is stated once.
+ */
+import { execFileSync } from "node:child_process";
+/**
+ * Does a process with this pid exist right now? (Signal 0 tests existence only.)
+ *
+ * Non-positive pids are rejected BEFORE the syscall, and that guard is
+ * load-bearing rather than defensive tidiness: in `kill(2)`, pid 0 means "every
+ * process in the caller's group" and a negative pid means "the group" — both
+ * succeed, so a zero or negative holder would report itself alive forever and
+ * wedge its idempotency key. A holder is always a real process or it is nothing.
+ */
+export function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** A pid's start time, or null when the pid is gone / `ps` could not answer. */
+export function processStart(pid) {
+    try {
+        const out = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+            encoding: "utf8",
+            timeout: 3000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const trimmed = out.trim();
+        return trimmed === "" ? null : trimmed;
+    }
+    catch {
+        // A dead pid exits nonzero — the instance is gone, which is an answer.
+        return null;
+    }
+}
+/** This process, as the identity to record on a piece of work it is starting. */
+export function currentInstance() {
+    return { pid: process.pid, start: processStart(process.pid) };
+}
+/**
+ * Is the RECORDED instance still running?
+ *
+ * Deliberately CONSERVATIVE: this answers a question whose wrong answer is
+ * expensive in one direction only. Reporting a dead writer as alive costs a
+ * caller one more poll; reporting a LIVE writer as dead invites a second
+ * execution of a mutation that is still in flight. So every ambiguity — a start
+ * time that was never recorded, a `ps` that would not answer now — resolves to
+ * "alive". Only a pid that is gone, or one whose start time PROVES it is a
+ * different process wearing the same number, is reported dead.
+ */
+export function instanceAlive(instance, deps = {}) {
+    const alive = deps.pidAlive ?? pidAlive;
+    const start = deps.processStart ?? processStart;
+    if (!alive(instance.pid))
+        return false;
+    // The pid exists. Without both start times we cannot rule out reuse, so we
+    // do not: the conservative answer is that this is still our process.
+    if (instance.start === null)
+        return true;
+    const current = start(instance.pid);
+    if (current === null)
+        return true;
+    return current === instance.start;
+}
+//# sourceMappingURL=process-instance.js.map

package/dist/process-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-instance.js","sourceRoot":"","sources":["../src/process-instance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAalD;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAW;IAClC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACrD,IAAI,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE;YACnE,QAAQ,EAAE,MAAM;YAChB,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;SACpC,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;QAC3B,OAAO,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,uEAAuE;QACvE,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,eAAe;IAC7B,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;AAChE,CAAC;AAQD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,QAAyB,EAAE,OAA6B,EAAE;IACtF,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACvC,2EAA2E;IAC3E,qEAAqE;IACrE,IAAI,QAAQ,CAAC,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACzC,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO,OAAO,KAAK,QAAQ,CAAC,KAAK,CAAC;AACpC,CAAC"}

package/dist/rescue.d.ts

@@ -0,0 +1,247 @@
+/**
+ * `things rescue` — the headless emergency surface for un-sticking Things
+ * (issue #640).
+ *
+ * WHY THIS EXISTS. Things can reach a state where the app is up, answering, and
+ * unusable to automation, with no scripted way back. Three measured behaviours
+ * converge on it:
+ *
+ *   - a standing modal sheet EMPTIES the app's top-level AppleScript collections
+ *     (oddities §25 / MODALX1), so `delete` reports `-1728 Can't get to do id` on
+ *     a row the database holds open — issue #620's "ghost clone", which has no
+ *     second cause;
+ *   - a standing sheet GATES Things Cloud sync entirely (oddities §24), so writes
+ *     land locally and silently never leave the Mac;
+ *   - a Repeat dialog opened while Things is BACKGROUNDED becomes a detached
+ *     window that nothing dismisses (oddities §26 / DRVLAT1 §5) — not its own
+ *     Cancel, not Escape, not ⌘W, not a real HID click at its Cancel frame.
+ *
+ * The shipped driver never creates the third state (every dialog recipe
+ * activates Things first, which is exactly why that step is permanent), but a
+ * killed client, a harness tool-timeout or a person walking away mid-dialog can
+ * all leave the first two. {@link rescueStatus} reports them; the other two
+ * verbs act on them. This is the single home for both halves — the read-only
+ * census that was once the top-level `ui-state` command lives here now.
+ *
+ * THE THREE VERBS, separated by what they can cost you:
+ *
+ *   - {@link rescueStatus}   free, ungated, read-only — the census + the lock
+ *                            table + a "we must not touch that" verdict;
+ *   - {@link rescueDismiss}  gated two ways — presses ONE dialog's own Cancel;
+ *   - {@link rescueRelaunch} gated two ways — ends the process and starts it
+ *                            again, the only cure measured for oddities §26.
+ *
+ * PERMISSIONS DOCTRINE. Nothing here raises a macOS consent dialog. The screen
+ * is read behind the prompt-free capability verdict, exactly as `doctor
+ * --ui-state` reads it, and a machine that has not granted the access is TOLD so
+ * rather than
+ * prompted. {@link rescueRelaunch} is the deliberate exception to needing that
+ * grant at all — see its own note.
+ */
+import { type AuditWriter } from "./audit/log.ts";
+import { type UiCapability } from "./capability.ts";
+import { type UiState } from "./write/vectors/ui-state.ts";
+import { type UiRunner } from "./write/vectors/ui.ts";
+/** What a relaunch could establish about the database it left behind. */
+export interface RescueSchemaVerdict {
+    /** Did the database open and read as a shape this build understands? */
+    ok: boolean;
+    /** One sentence, for the report. */
+    detail: string;
+}
+/**
+ * Every side-effecting thing this module does, injectable. Production defaults
+ * are the real ones; the unit suite substitutes all of them, which is what makes
+ * the gating, the refusals and the kill ladder testable without an app.
+ */
+export interface RescueDeps {
+    /** The prompt-free GUI capability verdict. */
+    uiCapability?: () => UiCapability;
+    /** The osascript / reveal dispatch seam — the same transport the drive uses. */
+    run?: UiRunner;
+    /** Process environment, for config, the lock path and the change-history directory. */
+    env?: NodeJS.ProcessEnv;
+    /** Where a rescue ACTION records what it did. */
+    audit?: AuditWriter;
+    now?: () => number;
+    pidAlive?: (pid: number) => boolean;
+    /** Which pids Things is running as, newest first; empty when it is not running. */
+    thingsPids?: () => Promise<number[]>;
+    /** Signal one pid. Never throws for a pid that has already gone. */
+    signal?: (pid: number, sig: NodeJS.Signals) => void;
+    /** Start Things in the BACKGROUND — we do not steal the screen to fix the screen. */
+    launch?: () => Promise<{
+        ok: boolean;
+        detail: string;
+    }>;
+    /** Read the database's own verdict, for the post-relaunch check. */
+    schemaStatus?: () => RescueSchemaVerdict;
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * A modal that is NOT ours. `inspectable: false` is the signature of a secure
+ * system modal — a macOS privacy/consent dialog, which belongs to no
+ * application's Accessibility tree and which no rescue verb may ever press a
+ * button on. It is reported so the operator knows to look at the screen, and so
+ * they know the refusal that follows is deliberate rather than a failure.
+ */
+export interface RescueForeignModal {
+    /** The application that owns the screen, or null when even that could not be read. */
+    owner: string | null;
+    detail: string;
+}
+/** The mutation lock, as `rescue status` reports it. Read-only, always. */
+export interface RescueLockView {
+    path: string;
+    held: boolean;
+    pid: number | null;
+    /** ISO instant the holder took it. */
+    since: string | null;
+    /** Human age ("4m 12s"), or null when it could not be computed. */
+    heldFor: string | null;
+    /** Does a process with that pid still exist? */
+    alive: boolean;
+    /** Alive AND older than any change takes — old enough to say so. */
+    suspect: boolean;
+    detail: string;
+}
+export interface RescueStatusReport {
+    /** Could the screen be read at all on this machine? */
+    screenReadable: boolean;
+    /** One sentence: the census summary, or the reason there is none. */
+    detail: string;
+    /** The census; null when it could not be read. */
+    state: UiState | null;
+    lock: RescueLockView;
+    /** Set when something we must not touch owns the screen. */
+    foreignModal: RescueForeignModal | null;
+    /** Consequences worth stating — the open-dialog sync gate. */
+    warnings: string[];
+    /** What to do next, including which rescue verb applies. */
+    remediation: string[];
+}
+/**
+ * Read everything a stuck machine can be asked about, without touching any of
+ * it. Never throws and never refuses: the cases this exists for are exactly the
+ * ones where something is already wrong, so every failure is a REPORTED state.
+ */
+export declare function rescueStatus(deps?: RescueDeps): Promise<RescueStatusReport>;
+export type RescueDismissOutcome = 
+/** Nothing was stranded — no dialog was open. */
+"no-dialog"
+/** Cancel was pressed and the dialog is confirmed gone. */
+ | "dismissed"
+/** Cancel was pressed and the dialog is demonstrably still there (oddities §26). */
+ | "still-open"
+/** Cancel was pressed and the screen could not be re-read to confirm either way. */
+ | "unverified"
+/** Nothing was pressed. */
+ | "refused";
+export interface RescueDismissResult {
+    outcome: RescueDismissOutcome;
+    /** Which press worked, when one did. */
+    how: "cancel-button" | "cancel-click" | null;
+    before: UiState | null;
+    after: UiState | null;
+    /** Dialogs still stacked after this one; null when it could not be re-read. */
+    levelsRemaining: number | null;
+    detail: string;
+    remediation: string[];
+    notes: string[];
+    warnings: string[];
+}
+/** The two keys `rescue dismiss` needs, spelled the way each surface spells them. */
+export interface RescueDismissAck {
+    /** `--dangerously-dismiss-dialog`. */
+    dangerouslyDismissDialog?: boolean;
+}
+/**
+ * Close the dialog IN FRONT by pressing its own Cancel button — FGRD2's proven
+ * Cancel, generalized off the drive's abort path and onto a dialog no drive
+ * opened.
+ *
+ * EXACTLY ONE LIFO LEVEL PER INVOCATION. Sheets nest as `AXSheet` children of
+ * the sheet below and dismiss strictly last-in-first-out (MODALX1 §6). A loop
+ * that cleared a whole stack in one command would be a loop pressing an unknown
+ * number of buttons on an unknown number of dialogs; instead this closes the top
+ * one, re-reads, and reports how many remain so the caller decides.
+ *
+ * PROVEN, never assumed. The press reporting success is NOT closure: the
+ * detached editor of oddities §26 accepts an AXPress on its Cancel and stays
+ * exactly where it is. Closure is decided by a fresh census showing the stack one
+ * level shorter, and an unconfirmable press is reported as unconfirmed.
+ *
+ * WHAT IT CAN COST YOU: the dialog's own pending edits, and nothing else. The
+ * database is untouched, and a URL command parked behind a consent sheet is
+ * discarded with it (URLEN1).
+ */
+export declare function rescueDismiss(ack?: RescueDismissAck, deps?: RescueDeps): Promise<RescueDismissResult>;
+export type RescueRelaunchOutcome = "relaunched" | "refused" | "failed";
+export interface RescueRelaunchResult {
+    outcome: RescueRelaunchOutcome;
+    /** Which rung actually ended the process. */
+    endedBy: "quit" | "sigterm" | "sigkill" | "not-running" | null;
+    before: UiState | null;
+    after: UiState | null;
+    /** The step-by-step account of the ladder, always present. */
+    ladder: string[];
+    detail: string;
+    remediation: string[];
+    notes: string[];
+    warnings: string[];
+}
+/** The keys `rescue relaunch` needs. The second one is profile-dependent. */
+export interface RescueRelaunchAck {
+    /** `--yes`. */
+    yes?: boolean;
+    /** `--dangerously-force-quit`; required only under the `workstation` profile. */
+    dangerouslyForceQuit?: boolean;
+}
+/**
+ * End Things and start it again — the nuclear rung, and the ONLY cure this
+ * project has measured for the detached editor of oddities §26. DRVLAT1 §5 tried
+ * every other route against the same live dialog (its own Cancel backgrounded,
+ * foregrounded and after `AXRaise`; Escape; ⌘W then re-activate; a real HID click
+ * at the AX-resolved Cancel frame) and every one was inert.
+ *
+ * THE LADDER, each rung bounded:
+ *
+ *   1. ask Things to quit through its own scripting interface. Bounded, because
+ *      a standing sheet swallows ⌘Q and the `quit` verb can block behind one.
+ *   2. SIGTERM, and wait for the process to go.
+ *   3. SIGKILL — the lab's canonical reset for a modal that will not clear.
+ *   4. start it again in the BACKGROUND: we do not steal the screen to fix the
+ *      screen.
+ *   5. prove it: the process is answering, the database still reads as the shape
+ *      this version expects, and no dialog is open.
+ *
+ * WHAT IS LOST: the Things database is write-ahead-logged, so everything already
+ * committed survives a kill unconditionally. The ceiling is what was never
+ * committed — the edits sitting in the dialog being destroyed.
+ *
+ * WHAT COMES BACK: sync. While a dialog stands, Things stops sending changes to
+ * Things Cloud (oddities §24); killing the dialog with the process releases that,
+ * and everything written on this Mac in the meantime goes out.
+ *
+ * DELIBERATELY NOT GATED ON THE GUI CAPABILITY. Every other verb that touches the
+ * app needs the GUI grant, because it synthesizes input into someone's window.
+ * This one signals a process the user already owns, which needs no grant at all —
+ * and the machines that need it most are exactly the ones where the Accessibility
+ * path is what broke. The quit rung and the census still run through the granted
+ * seam when it is available, and are skipped without complaint when it is not.
+ */
+export declare function rescueRelaunch(ack?: RescueRelaunchAck, deps?: RescueDeps): Promise<RescueRelaunchResult>;
+/**
+ * The human render of `things rescue status`.
+ *
+ * A ROW WHOSE PROBE DID NOT ANSWER SAYS SO (issue #629). Printing a field's
+ * unset default ("none", "unknown") beside rows that WERE measured is exactly
+ * what made a stalled inspection read as a clean screen in the field, so an
+ * unproven probe renders as "not established" rather than as its default, and
+ * the probes are named again in full on the `unproven:` row.
+ */
+export declare function rescueStatusLines(report: RescueStatusReport): string[];
+/** The human render of `things rescue dismiss`. */
+export declare function rescueDismissLines(result: RescueDismissResult): string[];
+/** The human render of `things rescue relaunch`. */
+export declare function rescueRelaunchLines(result: RescueRelaunchResult): string[];