@deftai/directive-core 0.106.0 → 0.107.0

package/dist/triage/evaluate/github.js

@@ -0,0 +1,153 @@
+import { GhRestError, restIssueListPaginated, restIssueView, runGhApi, splitRepo, } from "../../scm/gh-rest.js";
+const DUPLICATE_RE = /duplicate of\s+#(\d+)/iu;
+const MENTION_RE = /(?:#|issues\/)(\d+)\b/gu;
+function labelsOf(raw) {
+    const labels = raw.labels;
+    if (!Array.isArray(labels)) {
+        return [];
+    }
+    const out = [];
+    for (const item of labels) {
+        if (typeof item === "string") {
+            out.push(item);
+            continue;
+        }
+        if (item !== null && typeof item === "object" && "name" in item) {
+            const name = item.name;
+            if (typeof name === "string") {
+                out.push(name);
+            }
+        }
+    }
+    return out;
+}
+function duplicateOf(title, body, labels) {
+    const match = DUPLICATE_RE.exec(`${title}\n${body}`);
+    if (match?.[1] !== undefined) {
+        return Number.parseInt(match[1], 10);
+    }
+    if (labels.some((label) => label.toLowerCase().includes("duplicate"))) {
+        const hash = /#(\d+)/u.exec(title);
+        if (hash?.[1] !== undefined) {
+            return Number.parseInt(hash[1], 10);
+        }
+    }
+    return null;
+}
+export function snapshotFromIssuePayload(raw) {
+    const number = typeof raw.number === "number" ? raw.number : Number.parseInt(String(raw.number), 10);
+    const state = raw.state === "closed" ? "closed" : "open";
+    const title = typeof raw.title === "string" ? raw.title : "";
+    const body = typeof raw.body === "string" ? raw.body : "";
+    const labels = labelsOf(raw);
+    const htmlUrl = typeof raw.html_url === "string" ? raw.html_url : null;
+    return {
+        number,
+        state,
+        title,
+        body,
+        labels,
+        htmlUrl,
+        pullRequest: raw.pull_request !== undefined && raw.pull_request !== null,
+        duplicateOf: duplicateOf(title, body, labels),
+    };
+}
+function mentionsFrom(text) {
+    const found = new Set();
+    for (const match of text.matchAll(MENTION_RE)) {
+        if (match[1] !== undefined) {
+            found.add(Number.parseInt(match[1], 10));
+        }
+    }
+    return [...found];
+}
+export function snapshotFromPullPayload(raw) {
+    const number = typeof raw.number === "number" ? raw.number : Number.parseInt(String(raw.number), 10);
+    const title = typeof raw.title === "string" ? raw.title : "";
+    const body = typeof raw.body === "string" ? raw.body : "";
+    return {
+        number,
+        title,
+        body,
+        htmlUrl: typeof raw.html_url === "string" ? raw.html_url : null,
+        mentions: mentionsFrom(`${title}\n${body}`),
+    };
+}
+const OPEN_PULLS_PER_PAGE = 100;
+const OPEN_PULLS_MAX_PAGES = 50;
+function parsePullPage(stdout) {
+    const parsed = JSON.parse(stdout.trim() || "[]");
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    return parsed
+        .filter((item) => item !== null && typeof item === "object")
+        .map((item) => snapshotFromPullPayload(item));
+}
+function fetchPullPage(runner, endpoint, page) {
+    const result = runner([
+        endpoint,
+        "--method",
+        "GET",
+        "--raw-field",
+        "state=open",
+        "--raw-field",
+        `per_page=${OPEN_PULLS_PER_PAGE}`,
+        "--raw-field",
+        `page=${page}`,
+    ]);
+    if (result.returncode !== 0) {
+        throw new Error(`GET ${endpoint} failed: ${result.stderr.trim() || "no stderr"}`);
+    }
+    return parsePullPage(result.stdout);
+}
+function listOpenPulls(repo, seams) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/pulls`;
+    const runner = seams.runGhApiFn ?? runGhApi;
+    const out = [];
+    for (let page = 1; page <= OPEN_PULLS_MAX_PAGES; page += 1) {
+        const pageItems = fetchPullPage(runner, endpoint, page);
+        out.push(...pageItems);
+        if (pageItems.length < OPEN_PULLS_PER_PAGE) {
+            return out;
+        }
+    }
+    // Full last collected page: probe one more page to distinguish exactly-at-cap
+    // from a truncated census. Do not collect past the cap.
+    const overflow = fetchPullPage(runner, endpoint, OPEN_PULLS_MAX_PAGES + 1);
+    if (overflow.length === 0) {
+        return out;
+    }
+    throw new GhRestError({
+        stderr: `open-pull census truncated: last page ${OPEN_PULLS_MAX_PAGES} was full (${OPEN_PULLS_PER_PAGE} items) and page ${OPEN_PULLS_MAX_PAGES + 1} has more; later PRs are omitted`,
+        exitCode: 0,
+        endpoint,
+        payload: null,
+        hint: "census is incomplete; fail the evaluation rather than treating a truncated list as complete",
+    });
+}
+/** GET-only GitHub census. Parent-owned. Never POST/PATCH/PUT/DELETE. */
+export function collectGithubCensus(repo, issues, seams = {}) {
+    const views = {};
+    for (const n of issues) {
+        const raw = restIssueView(repo, n, { runGhApiFn: seams.runGhApiFn });
+        views[n] = snapshotFromIssuePayload(raw);
+    }
+    const openIssues = restIssueListPaginated(repo, { state: "open", excludePulls: true, perPage: 100 }, { runGhApiFn: seams.runGhApiFn }).map((raw) => snapshotFromIssuePayload(raw));
+    const openPulls = listOpenPulls(repo, seams);
+    return { issues: views, openIssues, openPulls };
+}
+export function defaultGithubReader(seams = {}) {
+    return {
+        viewIssue: (repo, n) => snapshotFromIssuePayload(restIssueView(repo, n, { runGhApiFn: seams.runGhApiFn })),
+        listOpenIssues: (repo) => restIssueListPaginated(repo, { state: "open", excludePulls: true, perPage: 100 }, {
+            runGhApiFn: seams.runGhApiFn,
+        }).map((raw) => snapshotFromIssuePayload(raw)),
+        listOpenPulls: (repo) => listOpenPulls(repo, seams),
+    };
+}
+export function pullsMentioning(pulls, issue) {
+    return pulls.filter((pull) => pull.mentions.includes(issue) || pull.number === issue);
+}
+//# sourceMappingURL=github.js.map

package/dist/triage/evaluate/index.d.ts

@@ -0,0 +1,9 @@
+export { EvaluateError, evaluateIssues, renderEvaluateText } from "./evaluate.js";
+export { evaluatorWorktreePath, sha12Of, sinkDir } from "./paths.js";
+export type { EvaluateOptions, EvaluateResult, GithubReader, IssueEvalVerdict, ValidityState, ValueAdvice, WipCensus, } from "./types.js";
+export { CRITIQUE_RECOMMEND_FIELD, DEFAULT_CONCURRENCY, RESERVED_CLEARANCE_RE } from "./types.js";
+export { evaluateValidity } from "./validity.js";
+export { buildValueAdvice, formatValueField, ReservedClearanceError } from "./value.js";
+export { collectWipCensus } from "./wip-census.js";
+export { addEvaluatorWorktree, removeEvaluatorWorktree } from "./worktrees.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/evaluate/index.js

@@ -0,0 +1,8 @@
+export { EvaluateError, evaluateIssues, renderEvaluateText } from "./evaluate.js";
+export { evaluatorWorktreePath, sha12Of, sinkDir } from "./paths.js";
+export { CRITIQUE_RECOMMEND_FIELD, DEFAULT_CONCURRENCY, RESERVED_CLEARANCE_RE } from "./types.js";
+export { evaluateValidity } from "./validity.js";
+export { buildValueAdvice, formatValueField, ReservedClearanceError } from "./value.js";
+export { collectWipCensus } from "./wip-census.js";
+export { addEvaluatorWorktree, removeEvaluatorWorktree } from "./worktrees.js";
+//# sourceMappingURL=index.js.map

package/dist/triage/evaluate/paths.d.ts

@@ -0,0 +1,7 @@
+export declare function sha12Of(fullSha: string): string;
+export declare function issueEvalScratchRoot(projectRoot: string): string;
+export declare function sinkDir(projectRoot: string, sha12: string, invocationId: string): string;
+export declare function sinkVerdictPath(projectRoot: string, sha12: string, invocationId: string, issue: number): string;
+export declare function sinkManifestPath(projectRoot: string, sha12: string, invocationId: string): string;
+export declare function evaluatorWorktreePath(projectRoot: string, issue: number, invocationId: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/triage/evaluate/paths.js

@@ -0,0 +1,25 @@
+import { join, resolve } from "node:path";
+import { SHA12_LENGTH } from "./types.js";
+export function sha12Of(fullSha) {
+    const trimmed = fullSha.trim().toLowerCase();
+    if (!/^[0-9a-f]{12,40}$/u.test(trimmed)) {
+        throw new Error(`origin/master SHA is not a git object id: ${fullSha.trim()}`);
+    }
+    return trimmed.slice(0, SHA12_LENGTH);
+}
+export function issueEvalScratchRoot(projectRoot) {
+    return join(resolve(projectRoot), ".deft-scratch", "issue-eval");
+}
+export function sinkDir(projectRoot, sha12, invocationId) {
+    return join(issueEvalScratchRoot(projectRoot), sha12, invocationId);
+}
+export function sinkVerdictPath(projectRoot, sha12, invocationId, issue) {
+    return join(sinkDir(projectRoot, sha12, invocationId), `issue-${issue}.json`);
+}
+export function sinkManifestPath(projectRoot, sha12, invocationId) {
+    return join(sinkDir(projectRoot, sha12, invocationId), "manifest.json");
+}
+export function evaluatorWorktreePath(projectRoot, issue, invocationId) {
+    return join(resolve(projectRoot), ".deft-scratch", "worktrees", `issue-eval-${issue}-${invocationId}`).replace(/\\/g, "/");
+}
+//# sourceMappingURL=paths.js.map

package/dist/triage/evaluate/sink.d.ts

@@ -0,0 +1,5 @@
+import type { EvaluateResult } from "./types.js";
+export declare function writeInvocationSink(projectRoot: string, result: EvaluateResult): string;
+export declare function gcStaleSha12Dirs(projectRoot: string, currentSha12: string): string[];
+export declare function teardownSink(projectRoot: string, sha12: string, invocationId: string): void;
+//# sourceMappingURL=sink.d.ts.map

package/dist/triage/evaluate/sink.js

@@ -0,0 +1,52 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { containedRemove, containedWrite } from "../../fs/contained-write.js";
+import { issueEvalScratchRoot, sinkDir, sinkManifestPath, sinkVerdictPath } from "./paths.js";
+import { assertNoReservedClearance } from "./value.js";
+export function writeInvocationSink(projectRoot, result) {
+    const root = resolve(projectRoot);
+    const serialized = JSON.stringify(result, null, 2);
+    assertNoReservedClearance(serialized, "verdict sink");
+    containedWrite({
+        root,
+        target: sinkManifestPath(projectRoot, result.sha12, result.invocationId),
+        data: `${serialized}\n`,
+        mode: "replace",
+    });
+    for (const verdict of result.verdicts) {
+        const body = JSON.stringify(verdict, null, 2);
+        assertNoReservedClearance(body, `verdict issue-${verdict.issue}`);
+        containedWrite({
+            root,
+            target: sinkVerdictPath(projectRoot, result.sha12, result.invocationId, verdict.issue),
+            data: `${body}\n`,
+            mode: "replace",
+        });
+    }
+    return sinkDir(projectRoot, result.sha12, result.invocationId);
+}
+export function gcStaleSha12Dirs(projectRoot, currentSha12) {
+    const root = resolve(projectRoot);
+    const scratch = issueEvalScratchRoot(projectRoot);
+    if (!existsSync(scratch)) {
+        return [];
+    }
+    const removed = [];
+    for (const name of readdirSync(scratch)) {
+        if (name === currentSha12) {
+            continue;
+        }
+        const target = `${scratch.replace(/\\/g, "/")}/${name}`;
+        containedRemove({ root, target, recursive: true });
+        removed.push(name);
+    }
+    return removed;
+}
+export function teardownSink(projectRoot, sha12, invocationId) {
+    const dir = sinkDir(projectRoot, sha12, invocationId);
+    if (!existsSync(dir)) {
+        return;
+    }
+    containedRemove({ root: resolve(projectRoot), target: dir, recursive: true });
+}
+//# sourceMappingURL=sink.js.map

package/dist/triage/evaluate/types.d.ts

@@ -0,0 +1,93 @@
+/** Stage A issue-eval types (#3648). */
+export declare const DEFAULT_CONCURRENCY = 4;
+export declare const ORIGIN_MASTER = "origin/master";
+export declare const SHA12_LENGTH = 12;
+export declare const CRITIQUE_RECOMMEND_FIELD = "critique-recommend";
+export declare const RESERVED_CLEARANCE_RE: RegExp;
+export declare const VALIDITY_STATES: readonly ["still-open", "partial", "likely-shipped", "needs-re-scope"];
+export type ValidityState = (typeof VALIDITY_STATES)[number];
+export interface ValidityVerdict {
+    readonly state: ValidityState;
+    readonly evidence: string;
+    readonly worktreePath: string;
+    readonly sessionStartReadOnly: true;
+}
+export interface WipHit {
+    readonly kind: "active-xbrief" | "pending-xbrief" | "plan-sequence";
+    readonly path: string;
+    readonly issue: number;
+}
+export interface WipCensus {
+    readonly active: readonly WipHit[];
+    readonly pending: readonly WipHit[];
+    readonly planSequence: readonly WipHit[];
+}
+export interface GithubIssueSnapshot {
+    readonly number: number;
+    readonly state: "open" | "closed";
+    readonly title: string;
+    readonly body: string;
+    readonly labels: readonly string[];
+    readonly htmlUrl: string | null;
+    readonly pullRequest: boolean;
+    readonly duplicateOf: number | null;
+}
+export interface GithubPullSnapshot {
+    readonly number: number;
+    readonly title: string;
+    readonly body: string;
+    readonly htmlUrl: string | null;
+    readonly mentions: readonly number[];
+}
+export interface GithubCensus {
+    readonly issues: Readonly<Record<number, GithubIssueSnapshot>>;
+    readonly openIssues: readonly GithubIssueSnapshot[];
+    readonly openPulls: readonly GithubPullSnapshot[];
+}
+export interface ValueAdvice {
+    readonly [CRITIQUE_RECOMMEND_FIELD]: boolean;
+    readonly reason: string;
+}
+export interface IssueEvalVerdict {
+    readonly issue: number;
+    readonly sha12: string;
+    readonly invocationId: string;
+    readonly validity: ValidityVerdict | null;
+    readonly wip: readonly WipHit[];
+    readonly github: GithubIssueSnapshot | null;
+    readonly openPulls: readonly GithubPullSnapshot[];
+    readonly duplicates: readonly number[];
+    readonly value: ValueAdvice;
+    readonly error: string | null;
+}
+export interface EvaluateResult {
+    readonly sha12: string;
+    readonly invocationId: string;
+    readonly originSha: string;
+    readonly sinkDir: string;
+    readonly concurrency: number;
+    readonly verdicts: readonly IssueEvalVerdict[];
+}
+export interface GitRunnerResult {
+    readonly returncode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export type GitRunner = (args: readonly string[], cwd: string) => GitRunnerResult;
+export type SessionStartFn = (worktreePath: string) => void;
+export type GithubReader = {
+    readonly viewIssue: (repo: string, n: number) => GithubIssueSnapshot;
+    readonly listOpenIssues: (repo: string) => readonly GithubIssueSnapshot[];
+    readonly listOpenPulls: (repo: string) => readonly GithubPullSnapshot[];
+};
+export interface EvaluateOptions {
+    readonly projectRoot: string;
+    readonly repo: string;
+    readonly issues: readonly number[];
+    readonly concurrency?: number;
+    readonly invocationId?: string;
+    readonly git?: GitRunner;
+    readonly sessionStart?: SessionStartFn;
+    readonly github?: GithubReader;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/triage/evaluate/types.js

@@ -0,0 +1,13 @@
+/** Stage A issue-eval types (#3648). */
+export const DEFAULT_CONCURRENCY = 4;
+export const ORIGIN_MASTER = "origin/master";
+export const SHA12_LENGTH = 12;
+export const CRITIQUE_RECOMMEND_FIELD = "critique-recommend";
+export const RESERVED_CLEARANCE_RE = /design-critique:\s*(?:warranted|not warranted)(?:\s*\|\s*(?:warranted|not warranted))?\s*,\s*because/iu;
+export const VALIDITY_STATES = [
+    "still-open",
+    "partial",
+    "likely-shipped",
+    "needs-re-scope",
+];
+//# sourceMappingURL=types.js.map

package/dist/triage/evaluate/validity.d.ts

@@ -0,0 +1,8 @@
+import type { ValidityVerdict } from "./types.js";
+/**
+ * Evaluator-owned. Reads only `worktreeRoot` (detached origin/master).
+ * Must not accept a WIP census argument.
+ */
+export declare function evaluateValidity(worktreeRoot: string, issue: number): ValidityVerdict;
+export declare function joinValidityWithGithub(validity: ValidityVerdict, githubState: "open" | "closed" | null): ValidityVerdict;
+//# sourceMappingURL=validity.d.ts.map

package/dist/triage/evaluate/validity.js

@@ -0,0 +1,87 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { listXbriefHits } from "./xbrief-refs.js";
+const ADR_DIR = join("docs", "decisions");
+const CONTRACT_DIR = join("content", "contracts");
+function filesMentionIssue(dir, issue) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const needle = `#${issue}`;
+    const hits = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".md")) {
+            continue;
+        }
+        const path = join(dir, name);
+        try {
+            const text = readFileSync(path, "utf8");
+            if (text.includes(needle) || text.includes(`/issues/${issue}`)) {
+                hits.push(path);
+            }
+        }
+        catch { }
+    }
+    return hits;
+}
+/**
+ * Evaluator-owned. Reads only `worktreeRoot` (detached origin/master).
+ * Must not accept a WIP census argument.
+ */
+export function evaluateValidity(worktreeRoot, issue) {
+    const completed = listXbriefHits(worktreeRoot, "completed").filter((hit) => hit.issue === issue);
+    const pending = listXbriefHits(worktreeRoot, "pending").filter((hit) => hit.issue === issue);
+    const active = listXbriefHits(worktreeRoot, "active").filter((hit) => hit.issue === issue);
+    const proposed = listXbriefHits(worktreeRoot, "proposed").filter((hit) => hit.issue === issue);
+    const adrHits = filesMentionIssue(join(worktreeRoot, ADR_DIR), issue);
+    const contractHits = filesMentionIssue(join(worktreeRoot, CONTRACT_DIR), issue);
+    if (completed.length > 0) {
+        return {
+            state: "likely-shipped",
+            evidence: `completed xbrief on origin/master: ${completed[0]?.path}`,
+            worktreePath: worktreeRoot,
+            sessionStartReadOnly: true,
+        };
+    }
+    if (pending.length > 0 || active.length > 0 || proposed.length > 0) {
+        const hit = pending[0] ?? active[0] ?? proposed[0];
+        return {
+            state: "partial",
+            evidence: `committed lifecycle xbrief on origin/master: ${hit?.path}`,
+            worktreePath: worktreeRoot,
+            sessionStartReadOnly: true,
+        };
+    }
+    if (adrHits.length > 0 || contractHits.length > 0) {
+        return {
+            state: "partial",
+            evidence: `ADR/contract mention on origin/master: ${adrHits[0] ?? contractHits[0] ?? ""}`,
+            worktreePath: worktreeRoot,
+            sessionStartReadOnly: true,
+        };
+    }
+    return {
+        state: "still-open",
+        evidence: "no origin/master lifecycle coverage, ADR, or contract mention",
+        worktreePath: worktreeRoot,
+        sessionStartReadOnly: true,
+    };
+}
+export function joinValidityWithGithub(validity, githubState) {
+    if (githubState === "closed" && validity.state === "still-open") {
+        return {
+            ...validity,
+            state: "likely-shipped",
+            evidence: `${validity.evidence}; GitHub issue state=closed`,
+        };
+    }
+    if (githubState === "open" && validity.state === "likely-shipped") {
+        return {
+            ...validity,
+            state: "needs-re-scope",
+            evidence: `${validity.evidence}; GitHub issue still open`,
+        };
+    }
+    return validity;
+}
+//# sourceMappingURL=validity.js.map

package/dist/triage/evaluate/value.d.ts

@@ -0,0 +1,12 @@
+import { type GithubIssueSnapshot, type ValueAdvice } from "./types.js";
+export declare class ReservedClearanceError extends Error {
+    name: string;
+}
+export declare function assertNoReservedClearance(text: string, label: string): void;
+/**
+ * Value MAY recommend critique via `critique-recommend:`.
+ * It MUST NOT stamp the reserved ADR-005 clearance grammar.
+ */
+export declare function buildValueAdvice(issue: GithubIssueSnapshot | null): ValueAdvice;
+export declare function formatValueField(advice: ValueAdvice): string;
+//# sourceMappingURL=value.d.ts.map

package/dist/triage/evaluate/value.js

@@ -0,0 +1,33 @@
+import { CRITIQUE_RECOMMEND_FIELD, RESERVED_CLEARANCE_RE, } from "./types.js";
+export class ReservedClearanceError extends Error {
+    name = "ReservedClearanceError";
+}
+export function assertNoReservedClearance(text, label) {
+    if (RESERVED_CLEARANCE_RE.test(text)) {
+        throw new ReservedClearanceError(`${label} must not emit the reserved clearance line ` +
+            "`design-critique: warranted | not warranted, because …`");
+    }
+}
+/**
+ * Value MAY recommend critique via `critique-recommend:`.
+ * It MUST NOT stamp the reserved ADR-005 clearance grammar.
+ */
+export function buildValueAdvice(issue) {
+    const labels = issue?.labels ?? [];
+    const stamped = labels.some((label) => label === "design-critique:mechanism-shaped");
+    const reason = stamped
+        ? "GitHub label design-critique:mechanism-shaped is present; author still stamps clearance"
+        : "no mechanism-shaped stamp; critique not recommended from evaluation";
+    const advice = {
+        [CRITIQUE_RECOMMEND_FIELD]: stamped,
+        reason,
+    };
+    assertNoReservedClearance(JSON.stringify(advice), "value advice");
+    return advice;
+}
+export function formatValueField(advice) {
+    const line = `${CRITIQUE_RECOMMEND_FIELD}: ${advice[CRITIQUE_RECOMMEND_FIELD] ? "true" : "false"}`;
+    assertNoReservedClearance(`${line}\n${advice.reason}`, "value field");
+    return `${line}\n${advice.reason}`;
+}
+//# sourceMappingURL=value.js.map

package/dist/triage/evaluate/wip-census.d.ts

@@ -0,0 +1,5 @@
+import type { WipCensus, WipHit } from "./types.js";
+/** Parent-owned. Evaluators must never receive this object. */
+export declare function collectWipCensus(projectRoot: string, issues: readonly number[]): WipCensus;
+export declare function wipHitsForIssue(census: WipCensus, issue: number): WipHit[];
+//# sourceMappingURL=wip-census.d.ts.map

package/dist/triage/evaluate/wip-census.js

@@ -0,0 +1,39 @@
+import { readPlanSequence } from "../../plan-sequence/store.js";
+import { listXbriefHits } from "./xbrief-refs.js";
+function hitsForIssues(hits, issues, kind) {
+    return hits
+        .filter((hit) => issues.has(hit.issue))
+        .map((hit) => ({ kind, path: hit.path, issue: hit.issue }));
+}
+/** Parent-owned. Evaluators must never receive this object. */
+export function collectWipCensus(projectRoot, issues) {
+    const wanted = new Set(issues);
+    const activeHits = listXbriefHits(projectRoot, "active");
+    const pendingHits = listXbriefHits(projectRoot, "pending");
+    const planHits = [];
+    const sequence = readPlanSequence(projectRoot);
+    if (sequence !== null) {
+        for (const entry of sequence.entries) {
+            const fromField = entry.issue;
+            const fromId = Number.parseInt(entry.id.trim().replace(/^#/u, ""), 10);
+            const asNumber = typeof fromField === "number" ? fromField : fromId;
+            if (!Number.isFinite(asNumber) || !wanted.has(asNumber)) {
+                continue;
+            }
+            planHits.push({
+                kind: "plan-sequence",
+                path: ".deft/plan-sequence.json",
+                issue: asNumber,
+            });
+        }
+    }
+    return {
+        active: hitsForIssues(activeHits, wanted, "active-xbrief"),
+        pending: hitsForIssues(pendingHits, wanted, "pending-xbrief"),
+        planSequence: planHits,
+    };
+}
+export function wipHitsForIssue(census, issue) {
+    return [...census.active, ...census.pending, ...census.planSequence].filter((hit) => hit.issue === issue);
+}
+//# sourceMappingURL=wip-census.js.map

package/dist/triage/evaluate/worktrees.d.ts

@@ -0,0 +1,8 @@
+import type { GitRunner } from "./types.js";
+export declare class EvaluatorWorktreeError extends Error {
+    name: string;
+}
+export declare function addEvaluatorWorktree(projectRoot: string, issue: number, invocationId: string, originSha: string, git?: GitRunner): string;
+/** Verb-owned remove. Not a shared core git-worktree helper. */
+export declare function removeEvaluatorWorktree(projectRoot: string, worktreePath: string, git?: GitRunner): void;
+//# sourceMappingURL=worktrees.d.ts.map

package/dist/triage/evaluate/worktrees.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { defaultGitRunner as swarmGitRunner, } from "../../swarm/worktrees.js";
+import { evaluatorWorktreePath } from "./paths.js";
+export class EvaluatorWorktreeError extends Error {
+    name = "EvaluatorWorktreeError";
+}
+function toSwarm(git) {
+    return (args, cwd) => git(args, cwd);
+}
+export function addEvaluatorWorktree(projectRoot, issue, invocationId, originSha, git = swarmGitRunner) {
+    const sha = originSha.trim();
+    if (sha.length === 0) {
+        throw new EvaluatorWorktreeError("originSha is required for a detached evaluator worktree");
+    }
+    const worktreePath = evaluatorWorktreePath(projectRoot, issue, invocationId);
+    mkdirSync(dirname(resolve(worktreePath)), { recursive: true });
+    const proc = toSwarm(git)(["worktree", "add", "--detach", worktreePath, sha], projectRoot);
+    if (proc.returncode !== 0) {
+        throw new EvaluatorWorktreeError(`git worktree add --detach failed for issue ${issue}: ${proc.stderr.trim() || "<no stderr>"}`);
+    }
+    return worktreePath;
+}
+function forceDeleteWorktreeDir(worktreePath) {
+    if (!existsSync(worktreePath)) {
+        return;
+    }
+    rmSync(worktreePath, { recursive: true, force: true });
+}
+function worktreeStillRegistered(git, projectRoot, worktreePath) {
+    const listed = git(["worktree", "list", "--porcelain"], projectRoot);
+    if (listed.returncode !== 0) {
+        return true;
+    }
+    const needle = resolve(worktreePath).replace(/\\/g, "/").toLowerCase();
+    for (const line of listed.stdout.split(/\r?\n/u)) {
+        if (!line.startsWith("worktree ")) {
+            continue;
+        }
+        const listedPath = line.slice("worktree ".length).replace(/\\/g, "/").toLowerCase();
+        if (listedPath === needle) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Verb-owned remove. Not a shared core git-worktree helper. */
+export function removeEvaluatorWorktree(projectRoot, worktreePath, git = swarmGitRunner) {
+    const runner = toSwarm(git);
+    const proc = runner(["worktree", "remove", "--force", worktreePath], projectRoot);
+    if (proc.returncode === 0) {
+        return;
+    }
+    const firstError = proc.stderr.trim() || "<no stderr>";
+    forceDeleteWorktreeDir(worktreePath);
+    runner(["worktree", "prune"], projectRoot);
+    const retry = runner(["worktree", "remove", "--force", worktreePath], projectRoot);
+    if (retry.returncode === 0) {
+        return;
+    }
+    forceDeleteWorktreeDir(worktreePath);
+    runner(["worktree", "prune"], projectRoot);
+    if (!worktreeStillRegistered(runner, projectRoot, worktreePath) && !existsSync(worktreePath)) {
+        return;
+    }
+    throw new EvaluatorWorktreeError(`git worktree remove failed for ${worktreePath}: ${firstError}; fallback: ${retry.stderr.trim() || "<no stderr>"}`);
+}
+//# sourceMappingURL=worktrees.js.map

package/dist/triage/evaluate/xbrief-refs.d.ts

@@ -0,0 +1,8 @@
+export interface XbriefHit {
+    readonly issue: number;
+    readonly path: string;
+    readonly folder: "active" | "pending" | "proposed" | "completed" | "cancelled";
+}
+export declare function issueNumbersFromXbriefJson(raw: unknown): number[];
+export declare function listXbriefHits(root: string, folder: XbriefHit["folder"]): XbriefHit[];
+//# sourceMappingURL=xbrief-refs.d.ts.map