tickmarkr 1.30.0

package/dist/compile/gsd.js

@@ -0,0 +1,222 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { TIERS, validateGraph } from "../graph/schema.js";
+import { CompileError, assertWriteScope, inferShape, sha256 } from "./common.js";
+// GSD artifact front-end (spec v1.3): one GSD *plan* is one drovr *task* — a plan is
+// worktree-sized; its inner <task> steps stay in the worker prompt via context[0] = the plan file.
+// Artifact-level only: parses .planning/ markdown, never GSD repo/command internals.
+const PLAN_SUFFIX = "-PLAN.md";
+export function isGsdPhaseDir(dir) {
+    try {
+        return readdirSync(dir).some((f) => f.endsWith(PLAN_SUFFIX));
+    }
+    catch {
+        return false;
+    }
+}
+const strings = (v) => (Array.isArray(v) ? v.map(String) : []);
+const WRITE_DIRECTIVE = /\b(?:Create|Write|Add|Emit|Generate)\s+`([^`\s]+)`/gi;
+const isPathish = (s) => /^[\w./*-]+$/.test(s) && /\.[a-z]{2,4}$/i.test(s);
+const stripFences = (s) => s.replace(/^```[\s\S]*?^```/gm, "");
+// ponytail: grammar matches GSD SUMMARY boilerplate only; if that boilerplate drifts the check
+// goes vacuous — the v1.9-29 pin in tests/compile/scope-seam.test.ts fails loudly when it does.
+function extractWriteDirectives(body, storedPath) {
+    const phaseDir = dirname(storedPath);
+    const writes = [];
+    for (const m of stripFences(body).matchAll(WRITE_DIRECTIVE)) {
+        const raw = m[1];
+        if (!isPathish(raw))
+            continue;
+        // HARD-09: a bare name (no "/") joins against the plan's CURRENT on-disk dir, which goes stale
+        // the moment the dir is archive-relocated. Carry the bare name through so assertWriteScope's
+        // fallback can resolve it in a relocation-invariant way (basename suffix against files_modified).
+        const bare = !raw.includes("/");
+        const path = bare ? join(phaseDir, raw) : raw;
+        writes.push({ path, directive: m[0], ...(bare ? { bare: raw } : {}) });
+    }
+    return writes;
+}
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+// schema-legal, branch-safe id segment: dots etc. → dashes; no "--" runs (task-branch separator)
+// or trailing dash — the id schema rejects both
+const sanitize = (s) => s
+    .replace(/[^A-Za-z0-9_-]/g, "-")
+    .replace(/-{2,}/g, "-")
+    .replace(/-+$/, "");
+// filename is the canonical id source — frontmatter `plan: 06` YAML-parses to the number 6,
+// losing the zero-padding that depends_on entries ("07-01") reference
+const planKey = (file) => sanitize(basename(file).replace(/-PLAN\.md$/, ""));
+// "06" and 6 must resolve to the same plan: alias each key by its zero-stripped segments
+const unpad = (key) => key
+    .split("-")
+    .map((seg) => (/^\d+$/.test(seg) ? String(Number(seg)) : seg))
+    .join("-");
+// numeric-aware order: 2-PLAN.md before 10-PLAN.md even without zero-padding
+function byPlanOrder(a, b) {
+    const as = a.split("-");
+    const bs = b.split("-");
+    for (let i = 0; i < Math.max(as.length, bs.length); i++) {
+        const x = as[i] ?? "";
+        const y = bs[i] ?? "";
+        if (/^\d+$/.test(x) && /^\d+$/.test(y) && Number(x) !== Number(y))
+            return Number(x) - Number(y);
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+function compileOne(file, storedPath) {
+    const content = readFileSync(file, "utf8");
+    const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+    let fm = {};
+    if (fmMatch) {
+        try {
+            fm = (parseYaml(fmMatch[1]) ?? {});
+        }
+        catch (e) {
+            // fail closed: a swallowed parse error would silently drop autonomous:false (a human gate)
+            throw new CompileError(`${file} has malformed YAML frontmatter: ${e instanceof Error ? e.message.split("\n")[0] : e}`);
+        }
+    }
+    const body = content.slice(fmMatch ? fmMatch[0].length : 0);
+    const key = planKey(file);
+    const objective = /<objective>\s*([\s\S]*?)<\/objective>/.exec(body)?.[1].trim() ?? "";
+    // sentence split that survives common abbreviations and version dots
+    const firstSentence = objective
+        .split(/(?<!\be\.g\.)(?<!\bi\.e\.)(?<!\bvs\.)(?<!\betc\.)(?<=\.)\s/)[0]
+        ?.replace(/\s+/g, " ")
+        .trim();
+    const title = firstSentence || key;
+    const dones = [...body.matchAll(/<done>\s*([\s\S]*?)\s*<\/done>/g)].map((m) => m[1].replace(/\s+/g, " ").trim());
+    const truths = strings(fm.must_haves?.truths);
+    const acceptance = [...dones, ...truths].filter(Boolean);
+    if (!acceptance.length) {
+        throw new CompileError(`${file} has no acceptance criteria — every drovr task needs them.\n` +
+            `GSD source: add <done> lines to the plan's tasks, or must_haves.truths in its frontmatter.`);
+    }
+    // @-refs from the <context> block only; keep repo-relative paths (no $VAR, ~, absolute, or ..-escape)
+    const contextBlock = /<context>([\s\S]*?)<\/context>/.exec(body)?.[1] ?? "";
+    const refs = [...contextBlock.matchAll(/^@(\S+)$/gm)]
+        .map((m) => m[1])
+        .filter((p) => !p.includes("$") && !p.startsWith("~") && !p.startsWith("/") && !p.split("/").includes(".."));
+    const taskCount = [...body.matchAll(/<task[\s>]/g)].length;
+    const humanGate = fm.autonomous === false || /<task type="checkpoint:/.test(body);
+    const done = existsSync(join(dirname(file), `${basename(file).replace(/-PLAN\.md$/, "")}-SUMMARY.md`));
+    const files = strings(fm.files_modified).map((f) => f.replace(/^\.\//, ""));
+    assertWriteScope(file, `P${key}`, files, extractWriteDirectives(body, storedPath));
+    // fail closed (D-03): a silently dropped floor/pin routes the task cheap instead of erroring
+    let routingHints;
+    if (fm.routing !== undefined) {
+        if (!isPlainObject(fm.routing)) {
+            throw new CompileError(`${file} has a routing frontmatter key that must be an object with floor and/or pin`);
+        }
+        const hints = { source: basename(file) };
+        if (fm.routing.floor !== undefined) {
+            if (!TIERS.includes(fm.routing.floor)) {
+                throw new CompileError(`${file} has routing.floor "${fm.routing.floor}" — valid tiers are ${TIERS.join(", ")}`);
+            }
+            hints.floor = fm.routing.floor;
+        }
+        if (fm.routing.pin !== undefined) {
+            const pin = fm.routing.pin;
+            const via = isPlainObject(pin) ? pin.via : undefined;
+            const model = isPlainObject(pin) ? pin.model : undefined;
+            if (typeof via !== "string" || typeof model !== "string") {
+                throw new CompileError(`${file} has a routing.pin missing a string "via" and/or "model"`);
+            }
+            hints.pin = { via, model };
+        }
+        if (hints.floor !== undefined || hints.pin !== undefined)
+            routingHints = hints;
+    }
+    return {
+        task: {
+            id: `P${key}`,
+            title,
+            goal: title,
+            // title only: files_modified nearly always lists test mirrors, which mis-shaped every plan as "tests"
+            shape: inferShape(title),
+            complexity: Math.max(1, Math.min(10, 2 * taskCount + truths.length)),
+            deps: strings(fm.depends_on).map((d) => sanitize(d)),
+            files,
+            context: [storedPath, ...refs],
+            acceptance,
+            ...(humanGate ? { humanGate: true } : {}),
+            ...(done ? { status: "done" } : {}),
+            ...(routingHints ? { routingHints } : {}),
+        },
+        content,
+    };
+}
+export function compileGsd(src, root) {
+    if (!existsSync(src))
+        throw new CompileError(`${src} does not exist — point drovr compile at a GSD phase directory or a *-PLAN.md`);
+    const isDir = statSync(src).isDirectory();
+    const files = isDir
+        ? readdirSync(src)
+            .filter((f) => f.endsWith(PLAN_SUFFIX))
+            .sort(byPlanOrder)
+            .map((f) => join(src, f))
+        : [src];
+    if (!files.length) {
+        throw new CompileError(`no *-PLAN.md files in ${src} — point drovr compile at a GSD phase directory`);
+    }
+    // context[0] must be readable from an isolated worktree: store repo-relative, never absolute
+    const rel = (f) => {
+        if (root && isAbsolute(f)) {
+            const r = relative(root, f);
+            if (!r.startsWith(".."))
+                return r;
+        }
+        return f;
+    };
+    const compiled = files.map((f) => compileOne(f, rel(f)));
+    const tasks = compiled.map((c) => c.task);
+    // deps reference plan keys; YAML may have stripped zero-padding ("06" → 6) — resolve via aliases.
+    // Phase compile: an unresolvable dep is a lost edge → fail closed. Single-plan compile: deps
+    // point at plans outside this graph (already executed by GSD) → drop them.
+    const byAlias = new Map();
+    for (const t of tasks) {
+        const key = t.id.slice(1);
+        byAlias.set(key, t.id);
+        byAlias.set(unpad(key), t.id);
+    }
+    if (isDir) {
+        const bareAliases = new Map();
+        const claimBareAlias = (alias, id) => {
+            const existing = bareAliases.get(alias);
+            if (existing === undefined && bareAliases.has(alias))
+                return;
+            if (existing !== undefined && existing !== id) {
+                bareAliases.set(alias, undefined);
+                return;
+            }
+            bareAliases.set(alias, id);
+        };
+        for (const t of tasks) {
+            const bare = t.id.slice(1).split("-").at(-1) ?? "";
+            claimBareAlias(bare, t.id);
+            claimBareAlias(unpad(bare), t.id);
+        }
+        for (const [alias, id] of bareAliases) {
+            if (id !== undefined && !byAlias.has(alias))
+                byAlias.set(alias, id);
+        }
+    }
+    for (const [i, t] of tasks.entries()) {
+        t.deps = t.deps.flatMap((d) => {
+            const id = byAlias.get(d) ?? byAlias.get(unpad(d));
+            if (id)
+                return [id];
+            if (!isDir)
+                return []; // external to this single-plan graph
+            throw new CompileError(`${files[i]} depends on "${d}" but no such plan exists in ${src}`);
+        });
+    }
+    return validateGraph({
+        version: 1,
+        spec: { source: "gsd", paths: files, hash: sha256(compiled.map((c) => c.content).join("\n")) },
+        tasks,
+    });
+}

package/dist/compile/index.d.ts

@@ -0,0 +1,4 @@
+import type { RunGraph } from "../graph/schema.js";
+type SourceType = "speckit" | "gsd" | "prd" | "native";
+export declare function compileSource(src: string, type?: SourceType, root?: string): RunGraph;
+export {};

package/dist/compile/index.js

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { CompileError } from "./common.js";
+import { compileGsd, isGsdPhaseDir } from "./gsd.js";
+import { compileNative, NATIVE_MARKER } from "./native.js";
+import { compilePrd } from "./prd.js";
+import { compileSpecKit } from "./speckit.js";
+function detect(src) {
+    if (existsSync(src) && statSync(src).isDirectory()) {
+        if (existsSync(join(src, "tasks.md")))
+            return "speckit";
+        if (isGsdPhaseDir(src))
+            return "gsd"; // gsd.ts owns the *-PLAN.md rule; unreadable dirs fall to null
+        return null;
+    }
+    if (src.endsWith("-PLAN.md"))
+        return "gsd"; // before the generic .md → prd rule
+    if (src.endsWith(".md"))
+        return existsSync(src) && NATIVE_MARKER.test(readFileSync(src, "utf8")) ? "native" : "prd";
+    return null;
+}
+export function compileSource(src, type, root) {
+    const kind = type ?? detect(src);
+    if (kind === "speckit")
+        return compileSpecKit(src);
+    if (kind === "gsd")
+        return compileGsd(src, root);
+    if (kind === "native")
+        return compileNative(src);
+    if (kind === "prd")
+        return compilePrd(src);
+    throw new CompileError(`cannot detect spec type for ${src} — pass a Spec Kit feature dir (with tasks.md), a GSD phase dir (with *-PLAN.md), or a marked native/generic PRD .md file, or use --type speckit|prd|gsd|native`);
+}

package/dist/compile/native.d.ts

@@ -0,0 +1,4 @@
+import { type RunGraph } from "../graph/schema.js";
+export declare const NATIVE_MARKER: RegExp;
+export declare function compileNative(file: string): RunGraph;
+export declare function specTemplate(): string;

package/dist/compile/native.js

@@ -0,0 +1,196 @@
+import { existsSync, readFileSync } from "node:fs";
+import { GATE_NAMES, ORACLES, SHAPES, TIERS, validateGraph } from "../graph/schema.js";
+import { CompileError, inferShape, sha256 } from "./common.js";
+export const NATIVE_MARKER = /^<!--\s*drovr:spec(?:\s+v1)?\s*-->\s*$/m;
+const HEAD_RE = /^## (T\d+):\s*(.+)$/;
+const FIELD_RE = /^- (\w+):\s*(.*)$/;
+const NESTED_RE = /^\s+- (.+)$/;
+// v1.19: a typed acceptance oracle line — "command: ...", "test: ...", or "judge: ...". Anything
+// without one of these prefixes is a plain-string judge criterion (compat path, emits a warning).
+const ORACLE_RE = new RegExp(`^(${ORACLES.join("|")}):\\s*(.*)$`);
+const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance"]);
+function invalid(task, field, detail) {
+    throw new CompileError(`Task ${task} field "${field}" ${detail}`);
+}
+export function compileNative(file) {
+    if (!existsSync(file))
+        throw new CompileError(`no such native spec file: ${file}`);
+    const content = readFileSync(file, "utf8");
+    const drafts = [];
+    let plainCount = 0; // v1.19: plain-string acceptance items compiled as judge oracles (compat) — warn once
+    for (const line of content.split("\n")) {
+        const heading = line.match(HEAD_RE);
+        if (heading) {
+            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptance: [], gates: [], hasGates: false, list: null });
+            continue;
+        }
+        const draft = drafts.at(-1);
+        if (!draft)
+            continue;
+        const field = line.match(FIELD_RE);
+        if (field) {
+            const name = field[1].toLowerCase();
+            if (!FIELDS.has(name))
+                invalid(draft.id, field[1], "is unknown");
+            const value = field[2].trim();
+            if (name === "acceptance" || name === "gates") {
+                if (value)
+                    invalid(draft.id, field[1], "must be a nested list");
+                draft.list = name;
+                if (name === "gates")
+                    draft.hasGates = true;
+            }
+            else {
+                if (name === "goal" && !value)
+                    invalid(draft.id, field[1], "must not be empty");
+                draft.fields[name] = value;
+                draft.list = null;
+            }
+            continue;
+        }
+        const nested = line.match(NESTED_RE);
+        if (nested && draft.list) {
+            const value = nested[1].trim();
+            if (!value)
+                invalid(draft.id, draft.list, "must not contain empty entries");
+            // v1.19: only the acceptance list parses typed oracle prefixes; gates stay plain names.
+            if (draft.list === "acceptance") {
+                const typed = value.match(ORACLE_RE);
+                if (typed) {
+                    const [, kind, body] = typed;
+                    if (!body.trim())
+                        invalid(draft.id, "acceptance", `${kind} oracle must carry a value`);
+                    draft.acceptance.push(kind === "command" ? { oracle: "command", command: body.trim() }
+                        : kind === "test" ? { oracle: "test", test: body.trim() }
+                            : { oracle: "judge", text: body.trim() });
+                }
+                else {
+                    plainCount++;
+                    draft.acceptance.push(value);
+                }
+            }
+            else {
+                draft[draft.list].push(value);
+            }
+            continue;
+        }
+        if (line.startsWith("- "))
+            invalid(draft.id, "field", `bullet is malformed: ${JSON.stringify(line)}`);
+        if (line.trim() && !line.startsWith(" "))
+            draft.list = null;
+    }
+    if (!drafts.length) {
+        throw new CompileError(`${file} has no task sections. Expected "## T1: Title" headings with field bullets.`);
+    }
+    const missing = drafts.filter((draft) => !draft.acceptance.length).map((draft) => draft.id);
+    if (missing.length) {
+        throw new CompileError(`acceptance criteria are required on every task. Missing on: ${missing.join(", ")}.\n` +
+            `Add to each section in ${file}:\n- acceptance:\n  - <observable outcome>`);
+    }
+    const csv = (value) => (value && value.toLowerCase() !== "none" ? value.split(",").map((item) => item.trim()).filter(Boolean) : []);
+    const tasks = drafts.map((draft) => {
+        const { fields } = draft;
+        const shape = fields.shape ?? inferShape(draft.title);
+        if (!SHAPES.includes(shape))
+            invalid(draft.id, "shape", `must be one of ${SHAPES.join(", ")}`);
+        const complexity = fields.complexity === undefined ? 5 : Number(fields.complexity);
+        if (!Number.isInteger(complexity) || complexity < 1 || complexity > 10)
+            invalid(draft.id, "complexity", "must be an integer from 1 to 10");
+        if (fields.humangate !== undefined && fields.humangate !== "true" && fields.humangate !== "false") {
+            invalid(draft.id, "humanGate", "must be literally true or false");
+        }
+        const pin = fields.pin?.split(/\s+/);
+        if (pin && (pin.length !== 2 || pin.some((part) => !part)))
+            invalid(draft.id, "pin", "must be exactly 'via model'");
+        if (fields.floor !== undefined && !TIERS.includes(fields.floor)) {
+            invalid(draft.id, "floor", `must be one of ${TIERS.join(", ")}`);
+        }
+        const badGate = draft.gates.find((gate) => !GATE_NAMES.includes(gate));
+        if (badGate)
+            invalid(draft.id, "gates", `contains invalid gate "${badGate}"`);
+        const routingHints = pin || fields.floor ? {
+            ...(pin ? { pin: { via: pin[0], model: pin[1] } } : {}),
+            ...(fields.floor ? { floor: fields.floor } : {}),
+        } : undefined;
+        return {
+            id: draft.id,
+            title: draft.title,
+            goal: fields.goal ?? draft.title,
+            shape,
+            complexity,
+            deps: csv(fields.deps),
+            files: csv(fields.files),
+            context: csv(fields.context),
+            acceptance: draft.acceptance,
+            ...(fields.humangate === "true" ? { humanGate: true } : {}),
+            ...(routingHints ? { routingHints } : {}),
+            ...(draft.hasGates ? { gates: draft.gates } : {}),
+        };
+    });
+    const result = validateGraph({
+        version: 1,
+        spec: { source: "native", paths: [file], hash: sha256(content) },
+        tasks,
+    });
+    // v1.19 read-old/write-new: a plain-string acceptance item compiles as a judge oracle. This is the
+    // one-time nudge toward typed oracles (command/test/judge); PRD/Spec Kit/GSD stay silent (untouched).
+    if (plainCount > 0) {
+        console.warn(`drovr: ${plainCount} acceptance item${plainCount === 1 ? "" : "s"} in ${file} ${plainCount === 1 ? "is a plain string" : "are plain strings"} — compiled as judge oracle${plainCount === 1 ? "" : "s"}. Prefix with command:/test:/judge: to make the oracle explicit.`);
+    }
+    return result;
+}
+// Commented native spec written to drovr.spec.md by `drovr init`. Documented via HTML comments (which the
+// parser ignores) so the template itself round-trips through compileSource() unchanged. Every field is
+// documented; the two example tasks illustrate plain vs deps+routing-hint, each with acceptance[].
+export function specTemplate() {
+    return `<!-- drovr:spec -->
+# drovr native spec
+
+Your starting point for a drovr native spec. Edit this file, then run:
+  drovr compile drovr.spec.md && drovr plan && drovr run
+
+Each task is a "## Tn: Title" heading with "- field: value" bullets.
+acceptance is required on every task (a nested list of observable outcomes).
+
+<!--
+  Fields available per task:
+    goal:        outcome the task must achieve (defaults to the title if omitted)
+    shape:       plan | spec | implement | tests | docs | migration | ui | refactor | chore
+                 (auto-inferred from the title if omitted)
+    deps:        comma-separated task ids this depends on, or "none"
+    files:       comma-separated repo paths this task may touch
+    context:     comma-separated paths the task should read for background
+    complexity:  integer 1 to 10 (default 5)
+    humanGate:   true | false — pauses for a human review before merging this task
+    pin:         "via model" — pin an exact channel, e.g. "claude-code opus"
+    floor:       cheap | mid | frontier — minimum capability tier for routing
+    gates:       nested list, any of build | test | lint | evidence | scope | acceptance | review
+    acceptance:  nested list (REQUIRED, non-empty). Each item is either a typed oracle or plain text:
+                 - command: <shell>   (oracle: command — exit code)
+                 - test: <name>       (oracle: test — named test)
+                 - judge: <rubric>    (oracle: judge — LLM-judged, free text)
+                 - <plain text>       (compat: compiles as judge oracle, warns)
+-->
+
+## T1: Scaffold the feature
+- goal: Lay the groundwork for the feature
+- shape: implement
+- files: src/feature.ts
+- context: docs/design.md
+- complexity: 4
+- acceptance:
+  - feature module exists and exports its entry point
+  - npm test stays green
+
+## T2: Cover it with tests
+- goal: Add tests for the feature
+- shape: tests
+- deps: T1
+- files: tests/feature.test.ts
+- complexity: 3
+- floor: cheap
+- acceptance:
+  - new tests pass
+  - coverage floor holds
+`;
+}

package/dist/compile/prd.d.ts

@@ -0,0 +1,2 @@
+import { type RunGraph } from "../graph/schema.js";
+export declare function compilePrd(file: string): RunGraph;

package/dist/compile/prd.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from "node:fs";
+import { validateGraph } from "../graph/schema.js";
+import { CompileError, inferShape, sha256 } from "./common.js";
+const HEAD_RE = /^## (T\d+):\s*(.+)$/;
+const FIELD_RE = /^- (\w+):\s*(.*)$/;
+const NESTED_RE = /^\s+- (.+)$/;
+export function compilePrd(file) {
+    if (!existsSync(file))
+        throw new CompileError(`no such PRD file: ${file}`);
+    const content = readFileSync(file, "utf8");
+    const drafts = [];
+    for (const line of content.split("\n")) {
+        const h = line.match(HEAD_RE);
+        if (h) {
+            drafts.push({ id: h[1], title: h[2].trim(), fields: {}, acceptance: [], inAcceptance: false });
+            continue;
+        }
+        const d = drafts.at(-1);
+        if (!d)
+            continue;
+        const f = line.match(FIELD_RE);
+        if (f) {
+            d.inAcceptance = f[1].toLowerCase() === "acceptance";
+            if (!d.inAcceptance)
+                d.fields[f[1].toLowerCase()] = f[2].trim();
+            continue;
+        }
+        const n = line.match(NESTED_RE);
+        if (n && d.inAcceptance)
+            d.acceptance.push(n[1].trim());
+        else if (line.trim() && !line.startsWith(" "))
+            d.inAcceptance = false;
+    }
+    if (!drafts.length) {
+        throw new CompileError(`${file} has no task sections. Expected "## T1: Title" headings with field bullets (goal/shape/deps/files/acceptance).`);
+    }
+    const missing = drafts.filter((d) => !d.acceptance.length).map((d) => d.id);
+    if (missing.length) {
+        throw new CompileError(`acceptance criteria are required on every task. Missing on: ${missing.join(", ")}.\n` +
+            `Add to each section in ${file}:\n- acceptance:\n  - <observable outcome>`);
+    }
+    const csv = (v) => (v && v.toLowerCase() !== "none" ? v.split(",").map((s) => s.trim()).filter(Boolean) : []);
+    const tasks = drafts.map((d) => {
+        const pin = d.fields.pin?.split(/\s+/);
+        return {
+            id: d.id,
+            title: d.title,
+            goal: d.fields.goal ?? d.title,
+            shape: d.fields.shape ?? inferShape(d.title),
+            complexity: d.fields.complexity ? Number(d.fields.complexity) : 5,
+            deps: csv(d.fields.deps),
+            files: csv(d.fields.files),
+            context: csv(d.fields.context),
+            acceptance: d.acceptance,
+            ...(d.fields.humangate === "true" ? { humanGate: true } : {}),
+            ...(pin && pin.length === 2 ? { routingHints: { pin: { via: pin[0], model: pin[1] } } } : {}),
+        };
+    });
+    return validateGraph({
+        version: 1,
+        spec: { source: "prd", paths: [file], hash: sha256(content) },
+        tasks,
+    });
+}

package/dist/compile/speckit.d.ts

@@ -0,0 +1,2 @@
+import { type RunGraph } from "../graph/schema.js";
+export declare function compileSpecKit(dir: string): RunGraph;

package/dist/compile/speckit.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { validateGraph } from "../graph/schema.js";
+import { CompileError, inferShape, sha256 } from "./common.js";
+const TASK_RE = /^- \[( |x)\] (T\d+)\s*(\[P\])?\s*(.+)$/;
+const SUB_RE = /^\s+- (\w+):\s*(.+)$/;
+export function compileSpecKit(dir) {
+    const path = join(dir, "tasks.md");
+    if (!existsSync(path)) {
+        throw new CompileError(`no tasks.md in ${dir} — point drovr compile at a Spec Kit feature directory`);
+    }
+    const content = readFileSync(path, "utf8");
+    const drafts = [];
+    for (const line of content.split("\n")) {
+        const t = line.match(TASK_RE);
+        if (t) {
+            drafts.push({ id: t[2], title: t[4].trim(), parallel: !!t[3], done: t[1] === "x", fields: {} });
+            continue;
+        }
+        const s = line.match(SUB_RE);
+        if (s && drafts.length) {
+            const d = drafts[drafts.length - 1];
+            (d.fields[s[1].toLowerCase()] ??= []).push(s[2].trim());
+        }
+    }
+    if (!drafts.length)
+        throw new CompileError(`${path} contains no task lines ("- [ ] T001 ...")`);
+    const missing = drafts.filter((d) => !d.fields.acceptance?.length).map((d) => d.id);
+    if (missing.length) {
+        throw new CompileError(`acceptance criteria are required on every task (spec rule). Missing on: ${missing.join(", ")}.\n` +
+            `Annotate each task in ${path} with an indented sub-bullet:\n  - acceptance: <observable outcome>`);
+    }
+    // [P] semantics → dependency edges
+    let barrier = null;
+    let sinceBarrier = [];
+    const csv = (v) => (v ? v.flatMap((x) => x.split(",")).map((s) => s.trim()).filter(Boolean) : []);
+    const tasks = drafts.map((d) => {
+        const deps = d.parallel
+            ? barrier ? [barrier] : []
+            : sinceBarrier.length ? [...sinceBarrier] : barrier ? [barrier] : [];
+        if (d.parallel) {
+            sinceBarrier.push(d.id);
+        }
+        else {
+            barrier = d.id;
+            sinceBarrier = [];
+        }
+        return {
+            id: d.id,
+            title: d.title,
+            goal: d.fields.goal?.[0] ?? d.title,
+            shape: d.fields.shape?.[0] ?? inferShape(d.title),
+            complexity: d.fields.complexity ? Number(d.fields.complexity[0]) : 5,
+            deps,
+            files: csv(d.fields.files),
+            context: csv(d.fields.context),
+            acceptance: d.fields.acceptance,
+            ...(d.done ? { status: "done" } : {}),
+        };
+    });
+    return validateGraph({
+        version: 1,
+        spec: { source: "speckit", paths: [path], hash: sha256(content) },
+        tasks,
+    });
+}