tickmarkr 2.8.4 → 2.8.6

package/dist/cli/commands/approve.js

@@ -1,11 +1,11 @@
 import { graphDefinitionHash, loadGraph, saveGraph, taskDefinitionFingerprint } from "../../graph/graph.js";
 import { filesGlob } from "../../graph/files-glob.js";
-import { execFileSync } from "node:child_process";
 import { userInfo } from "node:os";
 import { allAdapters } from "../../adapters/registry.js";
 import { channelKey } from "../../adapters/types.js";
 import { loadConfig } from "../../config/config.js";
 import { integrationBranch } from "../../run/merge.js";
+import { gitSync } from "../../run/git.js";
 import { integrationAnchor } from "../../run/daemon.js";
 import { separabilityErrors, surfaceErrors, taskBudgetErrors } from "../../compile/collateral.js";
 import { GATE_NAMES } from "../../graph/schema.js";
@@ -444,15 +444,10 @@ function mergedSiblingExempt(cwd, events, status, siblingId, requesterRef) {
     if (commit === undefined || !FULL_OBJECT_ID.test(commit))
         return false;
     const ref = requesterRef();
-    try {
-        execFileSync("git", ["rev-parse", "--verify", ref], { cwd, stdio: "ignore" });
-        execFileSync("git", ["merge-base", "--is-ancestor", commit, ref], { cwd, stdio: "ignore" });
-    }
-    catch {
-        return false;
-    }
-    return true;
+    return gitOk(cwd, "rev-parse", "--verify", ref) && gitOk(cwd, "merge-base", "--is-ancestor", commit, ref);
 }
+/** Queue row 2 item b: approve's git runs through the protected path; a trust refusal throws, never reads as false. */
+const gitOk = (cwd, ...args) => gitSync(cwd, args).status === 0;
 /** The conflicting unordered pairs of separabilityErrors, in its exact emission order. */
 function separabilityPairs(tasks) {
     const byId = new Map(tasks.map((t) => [t.id, t.deps ?? []]));
@@ -531,27 +526,13 @@ function failedTaskCommitsAhead(cwd, journal, runId, taskId) {
     const preservedRef = preserved?.data.ref;
     let ref = taskRef;
     if (preservedRef) {
-        try {
-            execFileSync("git", ["rev-parse", "--verify", taskRef], { cwd, stdio: "ignore" });
-            execFileSync("git", ["merge-base", "--is-ancestor", taskRef, preservedRef], { cwd, stdio: "ignore" });
+        if (gitOk(cwd, "rev-parse", "--verify", taskRef) && gitOk(cwd, "merge-base", "--is-ancestor", taskRef, preservedRef))
+            ref = preservedRef;
+        else if (!gitOk(cwd, "rev-parse", "--verify", taskRef))
             ref = preservedRef;
-        }
-        catch {
-            try {
-                execFileSync("git", ["rev-parse", "--verify", taskRef], { cwd, stdio: "ignore" });
-            }
-            catch {
-                ref = preservedRef;
-            }
-        }
-    }
-    try {
-        const out = execFileSync("git", ["rev-list", "--count", `${integration.base}..${ref}`], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-        return { ref, base, count: Number.parseInt(out.trim(), 10) || 0 };
-    }
-    catch {
-        return { ref, base, count: 0 };
     }
+    const out = gitSync(cwd, ["rev-list", "--count", `${integration.base}..${ref}`]);
+    return { ref, base, count: out.status === 0 ? Number.parseInt(out.stdout.trim(), 10) || 0 : 0 };
 }
 // The status is command OUTPUT, not a typed sibling result: the registered approve function returns
 // one primitive string and the dispatcher prints those bytes unchanged. A compact sentinel followed

package/dist/cli/commands/doctor.d.ts

@@ -52,6 +52,23 @@ type OrcaCapability = {
  * stderr (Electron timestamps), so the row is byte-stable across runs.
  */
 export declare function probeOrcaCapability(cwd: string, opts?: Pick<DoctorOpts, "orcaStatusProbe" | "orcaHooksStatusProbe" | "resolveOrcaBinary" | "orcaEnv">): Promise<OrcaCapability>;
+/** D-2102 add.39: the seams for a Node without stripTypeScriptTypes, and for a child that does not answer in time. */
+export type ParseSeam = {
+    strip?: "absent";
+    timeoutMs?: number;
+};
+/**
+ * D-2102 add.37 and add.39: the config's text with its TypeScript types erased (offsets unchanged), once a real
+ * parser accepts it — or why not. The source reaches PARSE_CHILD on stdin through process.execPath with no shell
+ * and no temp file. A spawn error, a timeout, a non-zero exit, a missing or malformed answer, or erased text of
+ * another length reads "doctor could not check <file>'s syntax"; a TypeScript config on a Node without
+ * stripTypeScriptTypes (below 22.13) reads unverifiable; nothing here throws.
+ */
+export declare function realParse(source: string, configPath: string, seam?: ParseSeam): {
+    text: string;
+} | {
+    why: string;
+};
 export declare function runnerIgnoreFinding(cwd: string): {
     verdict: "pass" | "warn";
     detail: string;
@@ -61,16 +78,43 @@ export declare function runnerIgnoreFinding(cwd: string): {
  * repos a hand-edit (SentioQ run 2 paid a whole run first); --fix applies the ignore
  * where a safe textual edit exists and refuses loudly otherwise.
  *
- * Safety contract: only three write shapes, each verified by re-running
- * runnerIgnoreFinding afterward — a write that does not turn the row green is
- * REVERTED and reported as manual. Never touches package.json (jest block → manual).
- * ponytail: text-level edits, same ceilings as the finding; the verify-then-revert
- * loop is what makes them safe to ship.
+ * Safety contract (queue row 197; D-2102 add.8 and add.30): the canonical entries the config's own literal
+ * ignore list lacks go into that array as complete string-literal elements (never a coverage array or a
+ * scalar), beside the state dir's canonical entry, else first; a jest element that is exactly an unanchored
+ * entry for either directory (the SentioQ run-2 shape) is replaced by its canonical twin; a jest config with
+ * no testPathIgnorePatterns gets the property, preserving jest's default /node_modules/ ignore, as before
+ * this change (a JSON config with its key quoted), and a vitest config without test.exclude gets one that
+ * keeps Vitest 3.2.7's default excludes ahead of the two entries — inside a new test object where it has
+ * none (D-2102 add.31). A config doctor could not read or any other element is manual with the file
+ * byte-unchanged. The write is verified by
+ * re-running the same rule on the written file (and JSON.parse for a .json config); a write that does not
+ * turn the row green is REVERTED byte-for-byte and reported as manual. Never touches package.json.
  */
 export declare function applyRunnerIgnore(cwd: string): {
     action: "none" | "wrote" | "manual";
     detail: string;
 };
+type EnvLike = NodeJS.ProcessEnv | Record<string, string | undefined>;
+/**
+ * Queue row 196 (D-2102 add.1): the host decides where seats run. herdr or Orca markers (classifyHost)
+ * name that driver; with neither, seats run headless on the subprocess driver with no daemon board.
+ * Only the exact claude-desktop entry point names Claude Desktop — a cli entry point is a terminal seat
+ * and no Claude variable alone is a host. Panes configured where no pane host exists cannot be honored.
+ */
+export declare function hostRows(env: EnvLike, llm: "pane" | "headless"): {
+    verdict: "pass" | "warn";
+    key: string;
+    detail: string;
+}[];
+/**
+ * Queue row 196 (D-2102 add.1): gates inherit the launching locale. The effective value is LC_ALL, else
+ * LC_CTYPE, else LANG (an empty value counts as unset). Unset, C or POSIX is the C-locale fallback;
+ * C.UTF-8 is a UTF-8 locale and passes. Advisory only — doctor never sets or writes a locale.
+ */
+export declare function localeFinding(env: EnvLike): {
+    verdict: "pass" | "warn";
+    detail: string;
+};
 /**
  * Q140s(b) / operator directive (D-OBS-10): the repo's package manager must resolve in
  * THIS process's environment — the same class of environment the daemon spawns gates