@tokenfactory/acc-runner 0.44.0 → 0.44.2

package/dist/loc-advisory.d.ts

@@ -0,0 +1,70 @@
+/** Heading of the generated section. Matched case-insensitively on splice. */
+export declare const LOC_ADVISORY_HEADING = "## LOC advisory";
+/** `kind` of the structured task_event emitted alongside the section. */
+export declare const LOC_ADVISORY_EVENT_KIND = "loc_advisory";
+/** House guideline (CLAUDE.md "≤300 LOC per commit"), read as IMPL lines. */
+export declare const HOUSE_IMPL_LOC_GUIDELINE = 300;
+/** Added/removed lines of a diff, split into implementation vs test files. */
+export interface LocSplit {
+    /** Added lines: non-test / test / both, then removed lines (never budgeted). */
+    impl: number;
+    tests: number;
+    total: number;
+    removed: number;
+}
+/** LOC ceilings declared by a task's acceptance criteria; null = undeclared. */
+export type LocCeilings = {
+    impl: number | null;
+    total: number | null;
+};
+/** A computed overage. Only ever constructed when a ceiling is exceeded. */
+export interface LocAdvisory extends LocSplit {
+    /** Effective impl ceiling — declared, else HOUSE_IMPL_LOC_GUIDELINE. */
+    ceiling: number;
+    /** Declared total ceiling (null = undeclared), and where `ceiling` came from. */
+    totalCeiling: number | null;
+    ceilingSource: "declared" | "house";
+    /** Which ceilings are exceeded, in report order. Never empty. */
+    exceeded: Array<"impl" | "total">;
+}
+/**
+ * True when a repo-relative path is a TEST file: anything under a `tests/` /
+ * `__tests__/` dir at any depth, or a `*.test.*` / `*.spec.*` basename.
+ * Backslashes are normalised so a Windows-shaped path classifies identically.
+ */
+export declare function isTestPath(path: string | null | undefined): boolean;
+/**
+ * Split a unified diff into impl vs test line counts. Binary files contribute
+ * nothing — the same convention the Files-changed table uses.
+ */
+export declare function splitDiffLoc(diff: string | null | undefined): LocSplit;
+/**
+ * Parse the LOC ceilings a task declared in its acceptance criteria — the
+ * `<= N LOC` family named in the spec ("Implementation (non-test) additions
+ * <= 250; total diff <= 450 LOC", "LOC budget: implementation <= 250", or a
+ * bare "<= 300 LOC"). A criterion must mention LOC / lines / additions before
+ * any of its `<= N` clauses count — otherwise "retries <= 3" reads as a budget.
+ * Each clause (delimited by `;`, `,`, `.`) binds to a bucket by the qualifier
+ * words before its operator; an UNQUALIFIED ceiling fills `impl` first (the
+ * house guideline is itself impl-shaped), then `total`. First one per bucket wins.
+ */
+export declare function parseLocCeilings(acceptance: readonly string[] | null | undefined): LocCeilings;
+/**
+ * Measure a pushed diff against the task's ceilings. Returns `null` — the common
+ * case — when nothing is exceeded, so the caller emits nothing at all.
+ */
+export declare function evaluateLocAdvisory(diff: string | null | undefined, acceptance: readonly string[] | null | undefined): LocAdvisory | null;
+/** The `loc_advisory` task_event payload (snake_case, like its peers). */
+export declare function locAdvisoryEventPayload(a: LocAdvisory): Record<string, unknown>;
+/**
+ * Render the `## LOC advisory` section — deliberately short: state the split,
+ * name the ceiling that is over, say plainly that it is not a blocker.
+ */
+export declare function renderLocAdvisorySection(a: LocAdvisory): string;
+/**
+ * Prepend the advisory to a PR body. Any pre-existing `## LOC advisory` section
+ * (up to the next `## ` heading) is REMOVED first, so a re-run can never stack
+ * two advisories.
+ */
+export declare function prependLocAdvisory(body: string | null | undefined, advisory: LocAdvisory): string;
+//# sourceMappingURL=loc-advisory.d.ts.map

package/dist/loc-advisory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loc-advisory.d.ts","sourceRoot":"","sources":["../src/loc-advisory.ts"],"names":[],"mappings":"AAuBA,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,oBAAoB,CAAC;AACtD,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,6EAA6E;AAC7E,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,8EAA8E;AAC9E,MAAM,WAAW,QAAQ;IACvB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAExE,4EAA4E;AAC5E,MAAM,WAAW,WAAY,SAAQ,QAAQ;IAC3C,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,UAAU,GAAG,OAAO,CAAC;IACpC,iEAAiE;IACjE,QAAQ,EAAE,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC;CACnC;AAWD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAMnE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,QAAQ,CAUtE;AAWD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GAC/C,WAAW,CAuBb;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GAC/C,WAAW,GAAG,IAAI,CAepB;AAED,0EAA0E;AAC1E,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAW/E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAkB/D;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,QAAQ,EAAE,WAAW,GACpB,MAAM,CAYR"}

package/dist/loc-advisory.js

@@ -0,0 +1,196 @@
+/**
+ * LOC-ADVISORY-2B — pre-PR LOC advisory, with an impl-vs-test line split.
+ *
+ * A PR that blows its LOC ceiling is discovered MID-review today: the reviewer
+ * reads the diff, notices the overage, and either rejects or grants a
+ * `loc_exception` after the fact (api/_lib/automerge-gates.ts). Both outcomes
+ * burn a review cycle on something the runner already knew at push time. So
+ * before opening the PR the runner measures the pushed diff, splits it into
+ * IMPLEMENTATION and TEST lines and — only when a ceiling is exceeded — emits a
+ * structured `loc_advisory` task_event and prepends a short `## LOC advisory`
+ * section to the PR body, so the overage is granted CONSCIOUSLY. The split
+ * matters because tests are the cheapest lines in a diff: 180 impl + 200 test
+ * lines is not the review risk that 380 impl lines is, and a single additions
+ * number cannot tell them apart.
+ *
+ * The advisory NEVER blocks. Everything here is pure and dependency-free; the
+ * caller wraps it so a parse error, a missing diff, or a failed event RPC all
+ * fall through to opening the PR anyway. impl/tests/total count ADDED lines,
+ * matching the server-side LOC gate (which budgets `additions`) and the house
+ * "≤300 LOC per commit" guideline; removed lines are context, never budgeted.
+ */
+import { parseDiffFileStats } from "./pr-body.js";
+/** Heading of the generated section. Matched case-insensitively on splice. */
+export const LOC_ADVISORY_HEADING = "## LOC advisory";
+/** `kind` of the structured task_event emitted alongside the section. */
+export const LOC_ADVISORY_EVENT_KIND = "loc_advisory";
+/** House guideline (CLAUDE.md "≤300 LOC per commit"), read as IMPL lines. */
+export const HOUSE_IMPL_LOC_GUIDELINE = 300;
+/**
+ * Dirs whose contents are tests. `tests` is the spec'd one, `__tests__` is
+ * unambiguous; a bare `test/` is deliberately absent — it collides with real
+ * source dirs too often to assume.
+ */
+const TEST_DIR_SEGMENTS = new Set(["tests", "__tests__"]);
+/** `foo.test.ts` / `foo.spec.tsx` — the test marker must precede the extension. */
+const TEST_FILE_RE = /\.(test|spec)\.[^./]+$/i;
+/**
+ * True when a repo-relative path is a TEST file: anything under a `tests/` /
+ * `__tests__/` dir at any depth, or a `*.test.*` / `*.spec.*` basename.
+ * Backslashes are normalised so a Windows-shaped path classifies identically.
+ */
+export function isTestPath(path) {
+    const p = (path ?? "").replace(/\\/g, "/").trim();
+    const segments = p.split("/").filter((s) => s.length > 0 && s !== ".");
+    if (segments.length === 0)
+        return false;
+    if (TEST_FILE_RE.test(segments[segments.length - 1]))
+        return true;
+    return segments.slice(0, -1).some((s) => TEST_DIR_SEGMENTS.has(s.toLowerCase()));
+}
+/**
+ * Split a unified diff into impl vs test line counts. Binary files contribute
+ * nothing — the same convention the Files-changed table uses.
+ */
+export function splitDiffLoc(diff) {
+    const split = { impl: 0, tests: 0, total: 0, removed: 0 };
+    for (const stat of parseDiffFileStats(diff)) {
+        if (stat.binary)
+            continue;
+        if (isTestPath(stat.path))
+            split.tests += stat.added;
+        else
+            split.impl += stat.added;
+        split.removed += stat.removed;
+    }
+    split.total = split.impl + split.tests;
+    return split;
+}
+/** A criterion only carries a ceiling if it talks about LOC/lines/additions. */
+const LOC_CONTEXT_RE = /\b(loc|lines?|additions?)\b/i;
+/** `<= 250`, `≤250`, `< 450` — the ceiling operators we accept. */
+const CEILING_RE = /(<=|≤|<)\s*(\d{1,6})\b/g;
+/** Words binding a ceiling to the implementation bucket. */
+const IMPL_QUALIFIER_RE = /\b(impl|implementation|non-?test|source|code)\b/i;
+/** Words binding a ceiling to the total bucket. */
+const TOTAL_QUALIFIER_RE = /\b(total|overall|combined|whole|entire|diff)\b/i;
+/**
+ * Parse the LOC ceilings a task declared in its acceptance criteria — the
+ * `<= N LOC` family named in the spec ("Implementation (non-test) additions
+ * <= 250; total diff <= 450 LOC", "LOC budget: implementation <= 250", or a
+ * bare "<= 300 LOC"). A criterion must mention LOC / lines / additions before
+ * any of its `<= N` clauses count — otherwise "retries <= 3" reads as a budget.
+ * Each clause (delimited by `;`, `,`, `.`) binds to a bucket by the qualifier
+ * words before its operator; an UNQUALIFIED ceiling fills `impl` first (the
+ * house guideline is itself impl-shaped), then `total`. First one per bucket wins.
+ */
+export function parseLocCeilings(acceptance) {
+    const out = { impl: null, total: null };
+    for (const raw of acceptance ?? []) {
+        if (typeof raw !== "string" || !LOC_CONTEXT_RE.test(raw))
+            continue;
+        const text = raw.replace(/\r\n/g, "\n");
+        CEILING_RE.lastIndex = 0;
+        let m;
+        while ((m = CEILING_RE.exec(text)) !== null) {
+            const n = Number.parseInt(m[2], 10);
+            if (!Number.isFinite(n) || n <= 0)
+                continue;
+            // The clause is the run of text since the last delimiter — the phrase
+            // that qualifies THIS operator ("total diff <=" vs "implementation <=").
+            const head = text.slice(0, m.index);
+            const clause = head.slice(head.search(/[^;,.\n]*$/));
+            if (IMPL_QUALIFIER_RE.test(clause)) {
+                if (out.impl === null)
+                    out.impl = n;
+            }
+            else if (TOTAL_QUALIFIER_RE.test(clause)) {
+                if (out.total === null)
+                    out.total = n;
+            }
+            else if (out.impl === null)
+                out.impl = n;
+            else if (out.total === null)
+                out.total = n;
+        }
+    }
+    return out;
+}
+/**
+ * Measure a pushed diff against the task's ceilings. Returns `null` — the common
+ * case — when nothing is exceeded, so the caller emits nothing at all.
+ */
+export function evaluateLocAdvisory(diff, acceptance) {
+    const split = splitDiffLoc(diff);
+    const declared = parseLocCeilings(acceptance);
+    const ceiling = declared.impl ?? HOUSE_IMPL_LOC_GUIDELINE;
+    const exceeded = [];
+    if (split.impl > ceiling)
+        exceeded.push("impl");
+    if (declared.total !== null && split.total > declared.total)
+        exceeded.push("total");
+    if (exceeded.length === 0)
+        return null;
+    return {
+        ...split,
+        ceiling,
+        totalCeiling: declared.total,
+        ceilingSource: declared.impl !== null ? "declared" : "house",
+        exceeded,
+    };
+}
+/** The `loc_advisory` task_event payload (snake_case, like its peers). */
+export function locAdvisoryEventPayload(a) {
+    return {
+        impl: a.impl,
+        tests: a.tests,
+        total: a.total,
+        ceiling: a.ceiling,
+        total_ceiling: a.totalCeiling,
+        ceiling_source: a.ceilingSource,
+        exceeded: a.exceeded,
+        removed: a.removed,
+    };
+}
+/**
+ * Render the `## LOC advisory` section — deliberately short: state the split,
+ * name the ceiling that is over, say plainly that it is not a blocker.
+ */
+export function renderLocAdvisorySection(a) {
+    const note = (n, cap, label) => cap === null ? "" : n > cap
+        ? ` — **exceeds** the ${label} of ${cap} (over by ${n - cap})`
+        : ` (${label} ${cap})`;
+    const implLabel = a.ceilingSource === "declared" ? "declared ceiling" : "house guideline";
+    return [
+        LOC_ADVISORY_HEADING,
+        "",
+        `- Implementation (non-test) additions: **${a.impl}**${note(a.impl, a.ceiling, implLabel)}`,
+        `- Test additions: ${a.tests}`,
+        `- Total additions: **${a.total}**${note(a.total, a.totalCeiling, "declared total ceiling")}` +
+            ` (removed: ${a.removed})`,
+        "",
+        "_(Advisory only — it does not block this PR. Grant a `loc_exception` in the " +
+            "review verdict if the diff is cohesive, or ask for a split.)_",
+    ].join("\n");
+}
+/** Match an existing `## LOC advisory` heading at line start. */
+const HEADING_RE = /^##[ \t]+loc advisory[ \t]*$/im;
+/**
+ * Prepend the advisory to a PR body. Any pre-existing `## LOC advisory` section
+ * (up to the next `## ` heading) is REMOVED first, so a re-run can never stack
+ * two advisories.
+ */
+export function prependLocAdvisory(body, advisory) {
+    let text = (body ?? "").replace(/\r\n/g, "\n");
+    const match = HEADING_RE.exec(text);
+    if (match) {
+        const after = match.index + match[0].length;
+        const next = /^##[ \t]+\S/m.exec(text.slice(after));
+        const end = next != null ? after + next.index : text.length;
+        text = `${text.slice(0, match.index)}\n${text.slice(end)}`;
+    }
+    const tail = text.trim();
+    const section = renderLocAdvisorySection(advisory);
+    return tail.length > 0 ? `${section}\n\n${tail}\n` : `${section}\n`;
+}
+//# sourceMappingURL=loc-advisory.js.map

package/dist/loc-advisory.js.map

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

package/dist/locks/claim-lock-policy.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Claim-time lock POLICY — runner-side copy.
+ *
+ * The runner is a standalone published package and MUST NOT import from
+ * api/_lib (see capacity-plugin.ts / cost-pricing.ts for the same rule), so this
+ * DUPLICATES the pure policy in api/_lib/claim-lock-policy.ts. Keep the two in
+ * sync — that api module is the canonical spec, and migration
+ * 0353_acc_claim_lock_file_granular.sql mirrors `declaredLockPaths` in SQL
+ * (acc._declared_lock_paths) so the DB overlap key is file-granular too.
+ *
+ * The rule (the bug this fixes): claim-time locking is FILE-granular. A broad
+ * directory glob (`api/_lib/**`, `tests/*`) is AUTHORIZATION scope, not lock
+ * scope — it acquires no directory-wide lock, so two tasks that share a parent
+ * directory but touch disjoint files never serialize. A concrete lock only
+ * exists once concrete files are known through the task's declared `allowed[]`
+ * or its touched-file reporting.
+ */
+/** At most three fast claim attempts against a live lock holder before yielding. */
+export declare const CLAIM_LOCK_MAX_FAST_ATTEMPTS = 3;
+/** Spacing between the fast attempts. */
+export declare const CLAIM_LOCK_FAST_RETRY_MS = 60000;
+/** Bounded back-off once the fast attempts are spent (AC3). */
+export declare const CLAIM_LOCK_YIELD_MS: number;
+/** Per-task claim-loss state, persisted across runTask invocations. */
+export interface ClaimLockLossState {
+    attempts: number;
+    eventRecorded: boolean;
+    firstConflictAtMs: number;
+}
+export interface ClaimLockLossDecision {
+    attempts: number;
+    eventRecorded: boolean;
+    firstConflictAtMs: number;
+    nextAttemptAtMs: number;
+    /** Non-null once the fast attempts are spent: do not re-attempt before this. */
+    yieldUntilMs: number | null;
+    /** The single conflict event to record, or null when it was already recorded. */
+    event: {
+        phase: "claim_locks";
+        conflicts: string[];
+        message: string;
+    } | null;
+}
+/**
+ * The concrete file paths a task actually locks at claim time. Broad directory
+ * globs are dropped (authorization scope, not lock scope); concrete files from
+ * `allowed[]` and any reported `touched` files are kept, de-duplicated, sorted.
+ */
+export declare function declaredLockPaths(allowed: readonly string[] | null | undefined, touched?: readonly string[]): string[];
+/**
+ * Advance the claim-loss retry state after a file-lock conflict. Returns the
+ * back-off decision: fast retries up to CLAIM_LOCK_MAX_FAST_ATTEMPTS, then a
+ * bounded yield (AC3), plus the ONE conflict event to record — null after the
+ * first, so the caller emits a single event per contention episode (AC4).
+ */
+export declare function planClaimLockLoss(previous: ClaimLockLossState | null | undefined, conflicts: readonly string[], nowMs: number): ClaimLockLossDecision;
+/**
+ * Clear the claim-loss state after a SUCCESSFUL claim so the next contention
+ * episode starts over — attempts back to 1 and a fresh conflict event emitted.
+ * `planClaimLockLoss` only ever advances state (attempts saturate at the cap,
+ * `eventRecorded` stays true), so without an explicit reset a task that once
+ * lost a claim could never resume fast attempts or re-open an event for the
+ * life of the state. Callers pass the result (null) back as `previous` on the
+ * next episode; passing null directly is equivalent.
+ */
+export declare function resetClaimLockLoss(): ClaimLockLossState | null;
+//# sourceMappingURL=claim-lock-policy.d.ts.map

package/dist/locks/claim-lock-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-lock-policy.d.ts","sourceRoot":"","sources":["../../src/locks/claim-lock-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,oFAAoF;AACpF,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,yCAAyC;AACzC,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAC/C,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,QAAa,CAAC;AAE9C,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,iFAAiF;IACjF,KAAK,EACD;QACE,KAAK,EAAE,aAAa,CAAC;QACrB,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,GACD,IAAI,CAAC;CACV;AAyDD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAC7C,OAAO,GAAE,SAAS,MAAM,EAAO,GAC9B,MAAM,EAAE,CAOV;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EAC/C,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,KAAK,EAAE,MAAM,GACZ,qBAAqB,CAsBvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,kBAAkB,GAAG,IAAI,CAE9D"}

package/dist/locks/claim-lock-policy.js

@@ -0,0 +1,132 @@
+/**
+ * Claim-time lock POLICY — runner-side copy.
+ *
+ * The runner is a standalone published package and MUST NOT import from
+ * api/_lib (see capacity-plugin.ts / cost-pricing.ts for the same rule), so this
+ * DUPLICATES the pure policy in api/_lib/claim-lock-policy.ts. Keep the two in
+ * sync — that api module is the canonical spec, and migration
+ * 0353_acc_claim_lock_file_granular.sql mirrors `declaredLockPaths` in SQL
+ * (acc._declared_lock_paths) so the DB overlap key is file-granular too.
+ *
+ * The rule (the bug this fixes): claim-time locking is FILE-granular. A broad
+ * directory glob (`api/_lib/**`, `tests/*`) is AUTHORIZATION scope, not lock
+ * scope — it acquires no directory-wide lock, so two tasks that share a parent
+ * directory but touch disjoint files never serialize. A concrete lock only
+ * exists once concrete files are known through the task's declared `allowed[]`
+ * or its touched-file reporting.
+ */
+/** At most three fast claim attempts against a live lock holder before yielding. */
+export const CLAIM_LOCK_MAX_FAST_ATTEMPTS = 3;
+/** Spacing between the fast attempts. */
+export const CLAIM_LOCK_FAST_RETRY_MS = 60_000;
+/** Bounded back-off once the fast attempts are spent (AC3). */
+export const CLAIM_LOCK_YIELD_MS = 5 * 60_000;
+// ── shared file-lock scope helpers ──────────────────────────────────────────
+// The block from EXTENSIONLESS_LOCK_FILENAMES through declaredLockPaths is kept
+// BYTE-IDENTICAL with api/_lib/claim-lock-policy.ts (the canonical spec) and
+// acc._declared_lock_paths in the migration. tests/unit/claim-lock-policy.test.ts
+// runs BOTH copies over one shared input table and asserts identical output, so
+// the three normalizers can never silently diverge into two different lock keys.
+/**
+ * Canonical extensionless filenames that ARE concrete file locks despite having
+ * no dotted extension. Without this set they are indistinguishable from a bare
+ * directory and would be silently dropped from lock scope, so two tasks editing
+ * the same one would both claim. Kept small and closed — only conventional,
+ * unambiguous filenames.
+ */
+const EXTENSIONLESS_LOCK_FILENAMES = new Set([
+    "Dockerfile",
+    "Makefile",
+    "Rakefile",
+    "Gemfile",
+    "Procfile",
+    "Brewfile",
+    "Vagrantfile",
+    "Jenkinsfile",
+    "Caddyfile",
+    "LICENSE",
+    "NOTICE",
+    "CODEOWNERS",
+]);
+/** The wildcard-free leading token of a raw allowed[] entry, path-normalized. */
+function normalizePath(raw) {
+    const first = (raw ?? "").trim().split(/\s+/)[0] ?? "";
+    return first
+        .replace(/^\.\//, "")
+        .replace(/^\/+/, "")
+        .replace(/\/{2,}/g, "/")
+        .replace(/\/+$/, "");
+}
+/**
+ * True for a concrete file path — one that names a single file, not a directory
+ * or wildcard scope. A basename counts as a file when it carries a dotted
+ * extension, is a dotfile (`.env`, `.gitignore`), or is a canonical
+ * extensionless filename (Dockerfile, Makefile, …). A bare directory
+ * (`api/_lib`) has none of those and is authorization scope, not a lock. The
+ * `.` and `..` path segments are never files.
+ */
+function isConcreteFilePath(path) {
+    if (!path || path.includes("*") || path.endsWith("/"))
+        return false;
+    const base = path.split("/").pop() ?? "";
+    if (base === "" || base === "." || base === "..")
+        return false;
+    if (EXTENSIONLESS_LOCK_FILENAMES.has(base))
+        return true;
+    return base.includes(".");
+}
+/**
+ * The concrete file paths a task actually locks at claim time. Broad directory
+ * globs are dropped (authorization scope, not lock scope); concrete files from
+ * `allowed[]` and any reported `touched` files are kept, de-duplicated, sorted.
+ */
+export function declaredLockPaths(allowed, touched = []) {
+    const paths = new Set();
+    for (const raw of [...(allowed ?? []), ...touched]) {
+        const path = normalizePath(raw);
+        if (isConcreteFilePath(path))
+            paths.add(path);
+    }
+    return [...paths].sort();
+}
+/**
+ * Advance the claim-loss retry state after a file-lock conflict. Returns the
+ * back-off decision: fast retries up to CLAIM_LOCK_MAX_FAST_ATTEMPTS, then a
+ * bounded yield (AC3), plus the ONE conflict event to record — null after the
+ * first, so the caller emits a single event per contention episode (AC4).
+ */
+export function planClaimLockLoss(previous, conflicts, nowMs) {
+    const attempts = Math.min((previous?.attempts ?? 0) + 1, CLAIM_LOCK_MAX_FAST_ATTEMPTS);
+    const alreadyRecorded = previous?.eventRecorded === true;
+    const firstConflictAtMs = previous?.firstConflictAtMs ?? nowMs;
+    const boundedYield = attempts >= CLAIM_LOCK_MAX_FAST_ATTEMPTS;
+    const uniqueConflicts = [...new Set(conflicts.filter(Boolean))].sort();
+    const nextAttemptAtMs = nowMs + (boundedYield ? CLAIM_LOCK_YIELD_MS : CLAIM_LOCK_FAST_RETRY_MS);
+    return {
+        attempts,
+        eventRecorded: true,
+        firstConflictAtMs,
+        nextAttemptAtMs,
+        yieldUntilMs: boundedYield ? nextAttemptAtMs : null,
+        event: alreadyRecorded
+            ? null
+            : {
+                phase: "claim_locks",
+                conflicts: uniqueConflicts,
+                message: `file-lock conflict with: ${uniqueConflicts.join(", ") || "(unknown)"}`,
+            },
+    };
+}
+/**
+ * Clear the claim-loss state after a SUCCESSFUL claim so the next contention
+ * episode starts over — attempts back to 1 and a fresh conflict event emitted.
+ * `planClaimLockLoss` only ever advances state (attempts saturate at the cap,
+ * `eventRecorded` stays true), so without an explicit reset a task that once
+ * lost a claim could never resume fast attempts or re-open an event for the
+ * life of the state. Callers pass the result (null) back as `previous` on the
+ * next episode; passing null directly is equivalent.
+ */
+export function resetClaimLockLoss() {
+    return null;
+}
+//# sourceMappingURL=claim-lock-policy.js.map

package/dist/locks/claim-lock-policy.js.map

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

package/dist/login.d.ts

@@ -1,5 +1,7 @@
-import { type ConcurrencySource, type RunnerConcurrency } from "./config.js";
+import { type ConcurrencySource, type RunnerConcurrency, type RunnerConfig } from "./config.js";
 import type { RunnerCaps } from "./types.js";
+import { type RunnerBuildCaps } from "./build-fingerprint.js";
+import { type CredentialIdentity } from "./credential-identity.js";
 export declare const RUNNER_CAPS: RunnerCaps;
 /**
  * Repo-scoped routing — build the register_runner `p_caps` payload with
@@ -33,13 +35,60 @@ export declare const RUNNER_CAPS: RunnerCaps;
  * advertised number can never drift from the number the runner actually runs.
  * Both keys are additive to the frozen caps shape — a pure superset.
  */
-export declare function runnerCapsWithRepos(repos: readonly string[] | undefined, engines?: readonly string[] | undefined, conc?: RunnerConcurrency, source?: ConcurrencySource): RunnerCaps & {
+export declare function runnerCapsWithRepos(repos: readonly string[] | undefined, engines?: readonly string[] | undefined, conc?: RunnerConcurrency, source?: ConcurrencySource, processCapabilities?: readonly string[], identity?: CredentialIdentity, build?: RunnerBuildCaps): RunnerCaps & {
     repos: string[];
     engines: string[];
+    process_capabilities: string[];
     concurrency: number;
     reserved_review_slots: number;
     concurrency_source: ConcurrencySource;
+    account_email: string | null;
+    account_org: string | null;
+    credential_source: CredentialIdentity["credential_source"];
+    build?: RunnerBuildCaps;
 };
+/**
+ * CAPS-ENGINES-STALE-KEYCHAIN-1 (AC10): the SINGLE `register_runner` `p_caps`
+ * builder shared by the `login` CLI and the watch-boot register, so the two
+ * cannot drift for the same environment. Merged with the upstream caps shape:
+ * it also folds liveProcessCapabilities(cfg), the resolved credential identity
+ * (capacity-attribution), and the build fingerprint — the caller resolves the
+ * async `identity`/`build` once and passes them so both paths publish an
+ * identical rich caps payload.
+ */
+export declare function registerRunnerCaps(cfg: Pick<RunnerConfig, "repos" | "capabilities">, engines: readonly string[], conc: RunnerConcurrency, identity: CredentialIdentity, build: RunnerBuildCaps | undefined): ReturnType<typeof runnerCapsWithRepos>;
+/**
+ * REGISTER-CAPS-PRESERVE-1 — the `p_capabilities` array every `register_runner`
+ * call must send. Neither call site passed the argument at all, so PostgREST
+ * omitted it, the RPC took its `text[] default '{}'` and the 0114/0153 body
+ * wrote that empty array straight over acc.runners.capabilities: a runner
+ * dispatchable for seven tags came back matching only tasks with an EMPTY
+ * required_capabilities — nothing the board queues. Migration 0349 makes the
+ * server refuse to shrink; this stops the client asking, which is what keeps
+ * 0349's activity-event alarm quiet in steady state. Same set that
+ * `set_runner_capabilities` publishes (ACC_RUNNER_CAPABILITIES > config.json >
+ * profile > []), so register and refresh can never disagree. Empty stays empty
+ * on the wire: 0349 reads it as "preserve", and on a FRESH row it is the 0114
+ * backward-compat default.
+ */
+export declare function advertisedCapabilities(cfg: Pick<RunnerConfig, "capabilities">): string[];
+/**
+ * M5 (CODEX-DISPATCH-WIRE-1): the runner's LIVE process capabilities, published
+ * as `caps.process_capabilities` for the capability-divergence report (#2131).
+ * Advertised capabilities are static config (`ACC_RUNNER_CAPABILITIES`); the
+ * live set drops any advertised tag that names a batch engine THIS runner's
+ * registry does not currently register — e.g. a config advertising `codex`
+ * while `ACC_ENGINE_CODEX_ENABLED` is off. Publishing the config value verbatim
+ * (the pre-M5 behaviour) made `advertised == process` always, so `stale_config`
+ * could never fire; deriving it from `engineIds()` is what lets the fleet report
+ * surface a disabled/unregistered Codex runner whose advertised caps are stale.
+ * Non-engine tags (e.g. `code`, `migration`, `review`) pass through untouched.
+ */
+export declare function liveProcessCapabilities(cfg: Pick<RunnerConfig, "capabilities">, registeredEngineIds?: readonly string[]): string[];
+/** The `machine` string the server dedups identity on. NAMED-INSTANCES-1
+ * appends `#<name>` so each instance resolves its own stable runner id;
+ * unnamed = the v0.44.0 string byte-for-byte. Every caller shares this fn so
+ * the suffix can never reach some payloads and not others. */
 export declare function machineIdentity(): string;
 export declare function detectInstalledModels(): Promise<string[]>;
 /**
@@ -91,6 +140,18 @@ export interface LoginOptions extends BrowserOpenContext {
     timeoutSeconds?: number;
     /** Injectable `open` (tests). Defaults to the real `open` package. */
     openBrowser?: (url: string) => Promise<unknown>;
+    /**
+     * AC10/AC11: engine-detection seam (mirrors WatchOptions.detectEngines).
+     * Defaults to the real detectCapableEngines; a test injects the same probe
+     * into login and watch to compare the two real caps paths without a mock.
+     */
+    detectEngines?: () => Promise<string[]>;
+    /**
+     * Injectable default-engine executable preflight. Production resolves `claude`
+     * before registering so a machine that cannot run the default engine fails the
+     * login loudly instead of registering a runner that can only fail at dispatch.
+     */
+    claudePreflight?: () => void;
 }
 export declare function loginCommand(options?: LoginOptions): Promise<void>;
 //# sourceMappingURL=login.d.ts.map

package/dist/login.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../src/login.ts"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAGV,UAAU,EACX,MAAM,YAAY,CAAC;AAOpB,eAAO,MAAM,WAAW,EAAE,UAczB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACpC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACvC,IAAI,GAAE,iBAA8C,EAKpD,MAAM,GAAE,iBAAgE,GACvE,UAAU,GAAG;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,kBAAkB,EAAE,iBAAiB,CAAC;CACvC,CASA;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAe/D;AAoBD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,uBAAuB,CAAC;AAEhD,MAAM,WAAW,kBAAkB;IACjC,mFAAmF;IACnF,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AASD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,GAAE,kBAAuB,GAAG,MAAM,GAAG,IAAI,CAWhF;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,kBAAuB,GAAG,OAAO,CAEvE;AAED,MAAM,WAAW,uBAAwB,SAAQ,kBAAkB;IACjE,sEAAsE;IACtE,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjD;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,OAAO,CAAC,CASlB;AAED,MAAM,WAAW,YAAa,SAAQ,kBAAkB;IACtD,gEAAgE;IAChE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjD;AAED,wBAAsB,YAAY,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0H5E"}
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../src/login.ts"],"names":[],"mappings":"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"}