tickmarkr 1.30.0

package/dist/run/merge.d.ts

@@ -0,0 +1,12 @@
+import type { DrovrConfig } from "../config/config.js";
+export declare function integrationBranch(cfg: DrovrConfig, runId: string): string;
+export declare function ensureIntegration(repo: string, branch: string, baseRef: string): Promise<string>;
+export declare function integrationHead(intWt: string): Promise<string>;
+export declare function mergeTask(intWt: string, taskBranch: string, message: string, gatedCommit: string): Promise<{
+    ok: boolean;
+    conflict?: string;
+    tipMoved?: {
+        gatedCommit: string;
+        branchTip: string;
+    };
+}>;

package/dist/run/merge.js

@@ -0,0 +1,44 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { shq } from "../adapters/types.js";
+import { drovrDir } from "../graph/graph.js";
+import { gitHead, resolveIntegrationBranch, sh, shOk } from "./git.js";
+export function integrationBranch(cfg, runId) {
+    return `tickmarkr/${runId}`;
+}
+const sanitize = (branch) => branch.replace(/[^\w.-]+/g, "-");
+export async function ensureIntegration(repo, branch, baseRef) {
+    branch = await resolveIntegrationBranch(repo, branch);
+    const dir = join(drovrDir(repo), "worktrees", sanitize(branch));
+    if (existsSync(join(dir, ".git")))
+        return dir; // resume: keep existing tip
+    const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
+    if (exists) {
+        await shOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
+    }
+    else {
+        await shOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+    }
+    return dir;
+}
+export function integrationHead(intWt) {
+    return gitHead(intWt);
+}
+export async function mergeTask(intWt, taskBranch, message, gatedCommit) {
+    const tip = await sh(`git rev-parse --verify ${shq(`refs/heads/${taskBranch}`)}`, intWt);
+    if (tip.code !== 0)
+        return { ok: false, conflict: tip.stderr || tip.stdout };
+    const branchTip = tip.stdout.trim();
+    if (branchTip !== gatedCommit)
+        return { ok: false, tipMoved: { gatedCommit, branchTip } };
+    // Merge the verified hash, not the mutable branch name: a move after the comparison cannot land ungated content.
+    const r = await sh(`git merge --no-ff ${shq(gatedCommit)} -m ${shq(message)}`, intWt);
+    if (r.code === 0)
+        return { ok: true };
+    const conflict = (await sh("git status --porcelain", intWt)).stdout
+        .split("\n")
+        .filter((l) => l.startsWith("UU") || l.startsWith("AA"))
+        .join("\n") || r.stderr || r.stdout;
+    await sh("git merge --abort", intWt);
+    return { ok: false, conflict };
+}

package/dist/run/reconcile.d.ts

@@ -0,0 +1,4 @@
+import { isForeignName, panesToClose, parseOwnedName } from "../drivers/types.js";
+import type { JournalEvent } from "./journal.js";
+export { isForeignName, panesToClose, parseOwnedName };
+export declare function desiredPanes(rows: JournalEvent[], runId: string): Set<string>;

package/dist/run/reconcile.js

@@ -0,0 +1,95 @@
+import { formatOwnedName, isForeignName, panesToClose, parseOwnedName } from "../drivers/types.js";
+export { isForeignName, panesToClose, parseOwnedName };
+// T1: pure fold over journal rows — the exact set of drovr-owned pane/tab names that SHOULD exist
+// right now for a live run. No I/O: the caller supplies rows (Journal.read()) and a live pane listing
+// separately. Anything owned (parseOwnedName succeeds) but not in this set is garbage to close;
+// anything foreign (parseOwnedName fails) is never a candidate, no matter what state it's in.
+export function desiredPanes(rows, runId) {
+    const desired = new Set();
+    const worker = new Map();
+    const judge = new Map();
+    const review = new Map();
+    const clearTask = (taskId) => {
+        for (const m of [worker, judge, review]) {
+            const name = m.get(taskId);
+            if (name)
+                desired.delete(name);
+            m.delete(taskId);
+        }
+    };
+    for (const row of rows) {
+        switch (row.event) {
+            case "run-start":
+            case "run-resume": {
+                // OBS-17 fix (2): a killed daemon can't close its slots — nothing tracked before this
+                // point is still live once the daemon (re)starts; resume re-dispatches at a fresh attempt.
+                for (const taskId of new Set([...worker.keys(), ...judge.keys(), ...review.keys()]))
+                    clearTask(taskId);
+                desired.add(formatOwnedName({ role: "watch", taskId: "run", attempt: 0, runId }));
+                break;
+            }
+            case "task-dispatch": {
+                const taskId = row.taskId;
+                const attempt = Number(row.data.attempt ?? 0);
+                // OBS-17 fix (1): a new dispatch (retry, escalation, OR quota-failover) supersedes the
+                // old attempt's pane — the failover path re-dispatches through this same event.
+                const prev = worker.get(taskId);
+                if (prev)
+                    desired.delete(prev);
+                const name = formatOwnedName({ role: "worker", taskId, attempt, runId });
+                worker.set(taskId, name);
+                desired.add(name);
+                break;
+            }
+            case "worker-result": {
+                const taskId = row.taskId;
+                const name = formatOwnedName({ role: "judge", taskId, attempt: 0, runId });
+                judge.set(taskId, name);
+                desired.add(name);
+                break;
+            }
+            case "judge-retry": {
+                const taskId = row.taskId;
+                const prev = judge.get(taskId);
+                if (prev)
+                    desired.delete(prev);
+                const name = formatOwnedName({ role: "judge", taskId, attempt: 1, runId });
+                judge.set(taskId, name);
+                desired.add(name);
+                break;
+            }
+            case "gate-result": {
+                const taskId = row.taskId;
+                if (row.data.gate === "acceptance") {
+                    const j = judge.get(taskId);
+                    if (j) {
+                        desired.delete(j);
+                        judge.delete(taskId);
+                    }
+                    if (row.data.pass) {
+                        const name = formatOwnedName({ role: "review", taskId, attempt: 0, runId });
+                        review.set(taskId, name);
+                        desired.add(name);
+                    }
+                }
+                else if (row.data.gate === "review") {
+                    const r = review.get(taskId);
+                    if (r) {
+                        desired.delete(r);
+                        review.delete(taskId);
+                    }
+                }
+                break;
+            }
+            case "task-done":
+            case "task-failed":
+            case "task-human":
+                clearTask(row.taskId);
+                break;
+            case "run-end":
+                desired.clear();
+                break;
+        }
+    }
+    return desired;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "tickmarkr",
+  "version": "1.30.0",
+  "description": "Spec in, verified work out.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "tickmarkr": "dist/cli/index.js",
+    "drovr": "dist/cli/index.js",
+    "drover": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "schema"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "schema": "tsx scripts/emit-schema.ts",
+    "e2e": "DROVR_E2E=1 vitest run tests/e2e --testTimeout 900000"
+  },
+  "dependencies": {
+    "picomatch": "^4.0.2",
+    "yaml": "^2.5.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/picomatch": "^4.0.0",
+    "@vitest/coverage-v8": "^3.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  }
+}

package/schema/rungraph.schema.json

@@ -0,0 +1,306 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "version": {
+      "type": "number",
+      "const": 1
+    },
+    "spec": {
+      "type": "object",
+      "properties": {
+        "source": {
+          "type": "string",
+          "enum": [
+            "speckit",
+            "gsd",
+            "prd",
+            "native",
+            "taskmaster"
+          ]
+        },
+        "paths": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "hash": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "source",
+        "paths",
+        "hash"
+      ]
+    },
+    "tasks": {
+      "minItems": 1,
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "maxLength": 64,
+            "pattern": "^[A-Za-z][A-Za-z0-9_-]*$"
+          },
+          "title": {
+            "type": "string",
+            "minLength": 1
+          },
+          "goal": {
+            "type": "string",
+            "minLength": 1
+          },
+          "shape": {
+            "type": "string",
+            "enum": [
+              "plan",
+              "spec",
+              "implement",
+              "tests",
+              "docs",
+              "migration",
+              "ui",
+              "refactor",
+              "chore"
+            ]
+          },
+          "complexity": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 10
+          },
+          "deps": {
+            "default": [],
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "files": {
+            "default": [],
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "context": {
+            "default": [],
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "acceptance": {
+            "minItems": 1,
+            "type": "array",
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "oracle": {
+                      "type": "string",
+                      "const": "command"
+                    },
+                    "command": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  },
+                  "required": [
+                    "oracle",
+                    "command"
+                  ]
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "oracle": {
+                      "type": "string",
+                      "const": "test"
+                    },
+                    "test": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  },
+                  "required": [
+                    "oracle",
+                    "test"
+                  ]
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "oracle": {
+                      "type": "string",
+                      "const": "judge"
+                    },
+                    "text": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  },
+                  "required": [
+                    "oracle",
+                    "text"
+                  ]
+                }
+              ]
+            }
+          },
+          "scopeHints": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "paths": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "confidence": {
+                  "type": "number",
+                  "minimum": 0,
+                  "maximum": 1
+                },
+                "reason": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "paths"
+              ]
+            }
+          },
+          "gates": {
+            "default": [
+              "build",
+              "test",
+              "lint",
+              "evidence",
+              "scope",
+              "acceptance",
+              "review"
+            ],
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": [
+                "build",
+                "test",
+                "lint",
+                "evidence",
+                "scope",
+                "acceptance",
+                "review"
+              ]
+            }
+          },
+          "routingHints": {
+            "type": "object",
+            "properties": {
+              "pin": {
+                "type": "object",
+                "properties": {
+                  "via": {
+                    "type": "string"
+                  },
+                  "model": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "via",
+                  "model"
+                ]
+              },
+              "floor": {
+                "type": "string",
+                "enum": [
+                  "cheap",
+                  "mid",
+                  "frontier"
+                ]
+              },
+              "source": {
+                "type": "string"
+              },
+              "escalate": {
+                "type": "boolean"
+              }
+            }
+          },
+          "humanGate": {
+            "default": false,
+            "type": "boolean"
+          },
+          "status": {
+            "default": "pending",
+            "type": "string",
+            "enum": [
+              "pending",
+              "running",
+              "gated",
+              "failed",
+              "done",
+              "human"
+            ]
+          },
+          "evidence": {
+            "default": {
+              "commits": [],
+              "artifacts": [],
+              "gateResults": []
+            },
+            "type": "object",
+            "properties": {
+              "commits": {
+                "default": [],
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "artifacts": {
+                "default": [],
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "gateResults": {
+                "default": [],
+                "type": "array",
+                "items": {}
+              }
+            }
+          }
+        },
+        "required": [
+          "id",
+          "title",
+          "goal",
+          "shape",
+          "complexity",
+          "acceptance"
+        ]
+      }
+    }
+  },
+  "required": [
+    "version",
+    "spec",
+    "tasks"
+  ],
+  "$comment": "Structural schema only; duplicate-id/unknown-dep/cycle checks live in validateGraph()."
+}