@attalabs/vinaya 0.20.1 → 0.22.0

package/dist/checks/bin/check-dispatch-readiness.js

@@ -2,7 +2,7 @@
 
 // src/checks/bin/check-dispatch-readiness.ts
 import { execFile as execFile4, execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
 import { sep as sep2 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 // ../../packages/aeg-core/src/gate-audience.ts
@@ -192,6 +192,12 @@ var NEXT_HEADER = /\*\*[A-Z][^*]*\*\*/;
 var FIELD_LABEL = /^(Depends-on|Conflicts-with)\s*:\s*(.*)$/i;
 var ID_TOKEN = /^(?:[\w.-]+\s+)?#?\d+[a-z]?$/i;
 var SLUG_QUALIFIED_ID = /^([\w.-]+)\s+(#?\d+[a-z]?)$/i;
+function splitSlugQualifiedEdge(edge) {
+  const m = edge.trim().match(SLUG_QUALIFIED_ID);
+  if (!m)
+    return null;
+  return { slug: m[1], bareId: m[2] };
+}
 function isEmptyMarker(s) {
   const t = s.trim();
   return t === "" || t === "—" || t === "-" || t === "–";
@@ -1788,6 +1794,257 @@ var DERIVED_STATUSES = [
   "incoherent"
 ];
 var DERIVABLE_STATUSES = DERIVED_STATUSES.filter((s) => s !== "backlog");
+// ../../packages/aeg-core/src/parse-ledger.ts
+function rowFromCells(cells) {
+  if (cells.length < 7)
+    return null;
+  const phase = (cells[0] ?? "").trim();
+  if (!phase)
+    return null;
+  return {
+    phase,
+    role: (cells[1] ?? "").trim(),
+    agentModel: (cells[2] ?? "").trim(),
+    tokensIn: parseIntCell(cells[3] ?? ""),
+    tokensOut: parseIntCell(cells[4] ?? ""),
+    cost: parseCostCell(cells[5] ?? ""),
+    date: (cells[6] ?? "").trim()
+  };
+}
+function parseIntCell(cell) {
+  const trimmed = cell.replace(/`/g, "").trim();
+  if (!trimmed || isEmDashOrDash(trimmed))
+    return null;
+  const normalized = trimmed.replace(/[,_\s]/g, "");
+  if (!/^-?\d+$/.test(normalized))
+    return null;
+  return Number(normalized);
+}
+function parseCostCell(cell) {
+  const trimmed = cell.replace(/`/g, "").trim();
+  if (!trimmed || isEmDashOrDash(trimmed))
+    return null;
+  const normalized = trimmed.replace(/^\$/, "").replace(/[,_\s]/g, "");
+  if (!/^-?\d+(\.\d+)?$/.test(normalized))
+    return null;
+  return Number(normalized);
+}
+function isEmDashOrDash(s) {
+  const t = s.trim();
+  return t === "—" || t === "-" || t === "–";
+}
+// ../../packages/aeg-core/src/parse-token-report.ts
+var TOKEN_REPORT_HEADING = /^\s*(?:#{1,6}\s*Token report\s*|\*\*Token report\*\*)\s*$/i;
+var INLINE_FIELD_LIST = /Phase:\s*([^|]+?)\s*\|\s*Role:\s*([^|]+?)\s*\|\s*Agent\/Model:\s*([^|]+?)\s*\|\s*Tokens in:\s*([^|]+?)\s*\|\s*Tokens out:\s*([^|]+?)\s*\|\s*Cost:\s*([^|]+?)\s*\|\s*Date:\s*(.+?)\s*$/im;
+function parseTokenReportEntries(body) {
+  const lines = body.split(/\r?\n/);
+  const headingIdxs = [];
+  lines.forEach((line, i) => {
+    if (TOKEN_REPORT_HEADING.test(line))
+      headingIdxs.push(i);
+  });
+  const out = [];
+  for (let h = 0;h < headingIdxs.length; h++) {
+    const start = headingIdxs[h] + 1;
+    const end = h + 1 < headingIdxs.length ? headingIdxs[h + 1] : lines.length;
+    const section = lines.slice(start, end).join(`
+`);
+    const tableRows = parseTableSection(section);
+    if (tableRows.length > 0) {
+      out.push(...tableRows);
+      continue;
+    }
+    const inlineRow = parseInlineFieldList(section);
+    if (inlineRow)
+      out.push(inlineRow);
+  }
+  return out;
+}
+function parseTableSection(section) {
+  const lines = section.split(/\r?\n/);
+  let i = 0;
+  for (;i < lines.length; i++) {
+    if ((lines[i] ?? "").trim().startsWith("|"))
+      break;
+  }
+  if (i + 1 >= lines.length)
+    return [];
+  i += 2;
+  const out = [];
+  for (;i < lines.length; i++) {
+    const trimmed = (lines[i] ?? "").trim();
+    if (!trimmed.startsWith("|"))
+      break;
+    const row = rowFromCells(splitTableRow(trimmed));
+    if (row)
+      out.push(row);
+  }
+  return out;
+}
+function parseInlineFieldList(section) {
+  const m = section.match(INLINE_FIELD_LIST);
+  if (!m)
+    return null;
+  return rowFromCells([m[1], m[2], m[3], m[4], m[5], m[6], m[7]]);
+}
+// ../../packages/aeg-core/src/report-tokens.ts
+var DASH_LOOKALIKES = {
+  "-": "‑",
+  "–": "‒",
+  "—": "―"
+};
+var DASH_CHARS = new Set(Object.keys(DASH_LOOKALIKES));
+// ../../packages/aeg-core/src/claude-code-transcript.ts
+import { createHash } from "node:crypto";
+function summarizeTranscript(jsonl) {
+  const seen = new Set;
+  const components = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0
+  };
+  let model = null;
+  let messageCount = 0;
+  for (const rawLine of jsonl.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    let entry2;
+    try {
+      entry2 = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!entry2 || typeof entry2 !== "object")
+      continue;
+    const obj = entry2;
+    if (obj.type !== "assistant")
+      continue;
+    const message = obj.message;
+    const id = message?.id;
+    const usage = message?.usage;
+    if (typeof id !== "string" || !id || !usage || seen.has(id))
+      continue;
+    seen.add(id);
+    messageCount++;
+    components.inputTokens += numberOr(usage.input_tokens, 0);
+    components.outputTokens += numberOr(usage.output_tokens, 0);
+    components.cacheCreationInputTokens += numberOr(usage.cache_creation_input_tokens, 0);
+    components.cacheReadInputTokens += numberOr(usage.cache_read_input_tokens, 0);
+    const messageModel = message?.model;
+    if (typeof messageModel === "string" && messageModel)
+      model = messageModel;
+  }
+  return { components, model, messageCount };
+}
+function numberOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function sanitizeKey(value) {
+  return value.replace(/[^A-Za-z0-9]+/g, "-");
+}
+function collisionResistantKey(value) {
+  const digest = createHash("sha256").update(value).digest("hex");
+  return `${sanitizeKey(value)}-${digest}`;
+}
+function transcriptPointerPath(projectDir, tmpDir) {
+  return `${tmpDir}/claude-transcript-${collisionResistantKey(projectDir)}.txt`;
+}
+function legacyTranscriptPointerPath(projectDir, tmpDir) {
+  return `${tmpDir}/claude-transcript-${sanitizeKey(projectDir)}.txt`;
+}
+function resolvePointer(explicitTranscriptPath, deps) {
+  if (explicitTranscriptPath)
+    return { path: explicitTranscriptPath, corroborated: true };
+  const projectDir = deps.env.CLAUDE_PROJECT_DIR ?? deps.cwd;
+  const tmpDir = deps.env.TMPDIR ?? "/tmp";
+  const primaryPointerPath = transcriptPointerPath(projectDir, tmpDir);
+  const legacyPointerPath = legacyTranscriptPointerPath(projectDir, tmpDir);
+  const currentSessionId = deps.env.CLAUDE_CODE_SESSION_ID;
+  const pointerPath = deps.exists(primaryPointerPath) ? primaryPointerPath : deps.exists(legacyPointerPath) ? legacyPointerPath : undefined;
+  if (!pointerPath) {
+    return {
+      pointerExisted: false,
+      corroborated: false,
+      error: `No transcript pointer at ${primaryPointerPath} (nor its pre-migration name ${legacyPointerPath}) ` + "and no --transcript given. Either this repo installs no track-transcript.sh Stop hook (lacking one " + "is not a defect — name the transcript directly instead), or no session has completed a turn yet."
+    };
+  }
+  let contents;
+  try {
+    contents = deps.readFile(pointerPath).replace(/\r?\n+$/, "");
+  } catch (err) {
+    return {
+      pointerExisted: true,
+      oursByLocation: true,
+      error: `Transcript pointer at ${pointerPath} could not be read: ${err.message}. ` + "Remove that file to clear this — the Stop hook rewrites it on the next turn."
+    };
+  }
+  const [pointerSessionId, transcriptPath] = contents.split("\t");
+  if (!transcriptPath) {
+    return {
+      pointerExisted: true,
+      oursByLocation: true,
+      error: `Transcript pointer file ${pointerPath} is malformed: "${contents.slice(0, 120)}${contents.length > 120 ? "…" : ""}". ` + "Remove that file to clear this — the Stop hook rewrites it on the next turn."
+    };
+  }
+  if (currentSessionId && pointerSessionId && currentSessionId !== pointerSessionId) {
+    return {
+      pointerExisted: true,
+      corroborated: false,
+      error: `Transcript pointer at ${pointerPath} is stale: written for session ${pointerSessionId}, ` + `but this session is ${currentSessionId}. Name your own transcript with --transcript instead of ` + "reporting another session's figures as yours."
+    };
+  }
+  return { path: transcriptPath, corroborated: Boolean(currentSessionId && pointerSessionId) };
+}
+function resolveMeteringCapability(deps, explicitTranscriptPath) {
+  const resolved = resolvePointer(explicitTranscriptPath, deps);
+  if ("error" in resolved) {
+    const ours = resolved.pointerExisted && (resolved.corroborated || resolved.oursByLocation);
+    if (ours)
+      return { capable: false, reason: "pointer-unusable", detail: resolved.error };
+    return {
+      capable: false,
+      reason: "no-transcript-resolved",
+      detail: resolved.pointerExisted ? `A transcript pointer exists but belongs to another session, so this session has no wiring of its own to use. (Underlying condition, for diagnosis only: ${resolved.error})` : resolved.error
+    };
+  }
+  const downstream = (r, detail) => resolved.corroborated ? { reason: r, detail } : {
+    reason: "no-transcript-resolved",
+    detail: `A transcript pointer was found but could not be shown to belong to this session, so it is not treated as this session's wiring. (Underlying condition, for diagnosis only: ${detail})`
+  };
+  if (!deps.exists(resolved.path)) {
+    return {
+      capable: false,
+      ...downstream("transcript-unreadable", `Resolved transcript path ${resolved.path} is not readable as a regular file owned by this user.`)
+    };
+  }
+  let jsonl;
+  try {
+    jsonl = deps.readFile(resolved.path);
+  } catch (err) {
+    return {
+      capable: false,
+      ...downstream("transcript-unreadable", `Transcript at ${resolved.path} could not be read: ${err.message}`)
+    };
+  }
+  const summary = summarizeTranscript(jsonl);
+  if (summary.messageCount === 0) {
+    return {
+      capable: false,
+      ...downstream("transcript-empty", `Transcript at ${resolved.path} yielded zero assistant messages with usage data — ` + "it's empty, unparseable, or not yet flushed to disk.")
+    };
+  }
+  return { capable: true, transcriptPath: resolved.path, summary };
+}
+function isTokenCollectionWiringBroken(capability) {
+  if (capability.capable)
+    return false;
+  return capability.reason !== "no-transcript-resolved";
+}
+// ../../packages/aeg-core/src/metering-io-guard.ts
+import { closeSync, constants as fsConstants, fstatSync, openSync, readFileSync } from "node:fs";
+var GUARD_OPEN_FLAGS = fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW;
 // ../../packages/aeg-core/src/file-classify.ts
 function isCodeFile(p) {
   if (p.endsWith(".md"))
@@ -1994,7 +2251,7 @@ function overrideActive(opts) {
   return false;
 }
 // ../../packages/aeg-core/src/premise-check.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var ASSERTION_KINDS = new Set(["contains", "absent", "sha256"]);
 function isPremiseHeader(line) {
   const stripped = line.replace(/[*#]/g, "").trim();
@@ -2039,7 +2296,7 @@ function checkPremises(assertions, fileReader) {
     } else if (a.kind === "absent" && content.includes(a.value)) {
       failures.push(`premise-check: ${a.path} now contains "${a.value}", but the brief pinned it absent — the premise has moved; re-dig before proceeding.`);
     } else if (a.kind === "sha256") {
-      const actual = createHash("sha256").update(content).digest("hex");
+      const actual = createHash2("sha256").update(content).digest("hex");
       if (actual !== a.value.toLowerCase()) {
         failures.push(`premise-check: ${a.path} sha256 mismatch (brief pinned ${a.value}, file is now ${actual}) — the file changed since this brief was authored; re-dig before proceeding.`);
       }
@@ -3219,6 +3476,100 @@ function parseGlossaryTerms(glossaryContent) {
   }
   return terms;
 }
+// ../../packages/aeg-core/src/quoted-command.ts
+var QUOTED_COMMAND_SHIPS_PREFIX = "aeg-root/";
+var QUOTED_COMMAND_SWEPT_CLASSES = new Set(["ships", "reader-facing"]);
+var START_PATTERN = /<!--\s*AEG:QUOTES-FILE:START:(\S+?)\s*-->/g;
+var END_PATTERN = /<!--\s*AEG:QUOTES-FILE:END\s*-->/;
+function isValidCitedFilePath(path) {
+  if (path.length === 0)
+    return false;
+  if (path.startsWith("/") || path.startsWith("\\"))
+    return false;
+  if (/^[A-Za-z]:[\\/]/.test(path))
+    return false;
+  return !path.split(/[\\/]+/).includes("..");
+}
+function quotedCommandLineAt(content, index) {
+  let line = 1;
+  for (let i = 0;i < index; i++) {
+    if (content.charCodeAt(i) === 10)
+      line++;
+  }
+  return line;
+}
+function extractQuotedText(raw) {
+  const trimmed = raw.trim();
+  const fenced = /^(?:`{3,}|~{3,})[^\n]*\n([\s\S]*?)\n?(?:`{3,}|~{3,})$/.exec(trimmed);
+  if (fenced)
+    return (fenced[1] ?? "").trim();
+  const inline = /^`([^`]+)`$/.exec(trimmed);
+  if (inline)
+    return (inline[1] ?? "").trim();
+  return trimmed;
+}
+function findQuotesInFile(path, content) {
+  const masked = maskCode(content);
+  const quotes = [];
+  START_PATTERN.lastIndex = 0;
+  let start = START_PATTERN.exec(masked);
+  while (start !== null) {
+    const citedFile = start[1];
+    const innerStart = start.index + start[0].length;
+    const end = END_PATTERN.exec(masked.slice(innerStart));
+    if (end === null) {
+      START_PATTERN.lastIndex = innerStart;
+      start = START_PATTERN.exec(masked);
+      continue;
+    }
+    const innerEnd = innerStart + end.index;
+    if (isValidCitedFilePath(citedFile)) {
+      const quotedText = extractQuotedText(content.slice(innerStart, innerEnd));
+      if (quotedText.length > 0) {
+        quotes.push({ file: path, line: quotedCommandLineAt(content, innerStart), quotedText, citedFile });
+      }
+    }
+    START_PATTERN.lastIndex = innerEnd + end[0].length;
+    start = START_PATTERN.exec(masked);
+  }
+  return quotes;
+}
+function findCitedQuotes(files, readerFacingPrefix, readerFacingSuffix, shipsPrefix = QUOTED_COMMAND_SHIPS_PREFIX) {
+  const quotes = [];
+  for (const file of files) {
+    const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix, shipsPrefix);
+    if (!cls || !QUOTED_COMMAND_SWEPT_CLASSES.has(cls))
+      continue;
+    quotes.push(...findQuotesInFile(file.path, file.content));
+  }
+  return quotes;
+}
+function evaluateCitedQuotes(citedQuotes, citedFileContents) {
+  const findings = [];
+  for (const quote of citedQuotes) {
+    const content = citedFileContents.get(quote.citedFile);
+    if (content === undefined) {
+      findings.push({
+        file: quote.file,
+        line: quote.line,
+        citedFile: quote.citedFile,
+        quotedText: quote.quotedText,
+        message: `${quote.file}:${quote.line} quotes "${quote.quotedText}" as citing \`${quote.citedFile}\`, but that file could not be read`
+      });
+      continue;
+    }
+    if (!content.includes(quote.quotedText)) {
+      findings.push({
+        file: quote.file,
+        line: quote.line,
+        citedFile: quote.citedFile,
+        quotedText: quote.quotedText,
+        message: `${quote.file}:${quote.line} quotes "${quote.quotedText}" as citing \`${quote.citedFile}\`, but \`${quote.citedFile}\` no longer contains that text verbatim`
+      });
+    }
+  }
+  return findings;
+}
 // ../../packages/aeg-core/src/retired-vocabulary.ts
 var RETIRED_PATTERNS = [
   String.raw`\bD-[0-9]{3}\b`,
@@ -3332,6 +3683,10 @@ function checkDispatchReadiness(input) {
     blockers.push(`dispatch-gate rationale: Issue #${input.issue.number} for ${taskLabel} fails the rationale gate (checkIssueRationale) — the Planner must complete the eight-field rationale before this task is dispatchable.`);
   }
   for (const dep of input.dependsOn) {
+    if (dep.resolved === false) {
+      blockers.push(`dispatch-gate depends-on: ${taskLabel} depends on "${dep.id}", which is UNRESOLVABLE — the resolver could not find a matching tranche/task/Issue for this edge (not a claim about merge status). Not dispatchable until the edge is corrected.`);
+      continue;
+    }
     if (!dep.merged && !isHandClosedByRecognizedPrincipal(dep, principalAllowlist)) {
       const issueStr = dep.issue !== null ? ` (#${dep.issue})` : "";
       blockers.push(`dispatch-gate depends-on: ${taskLabel} depends on ${dep.id}${issueStr}, whose PR is not merged yet — not dispatchable, it serializes behind it.`);
@@ -3819,6 +4174,18 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "pr verify-evidence",
+    description: "Prove a pull request's AEG:EVIDENCE region was machine-generated — regenerate it and compare",
+    flags: [],
+    details: [
+      "Deliberately a command, not a check: `evidence-fresh` runs inside `vinaya check --all`, and `pr report` runs `vinaya check --all --diff-only`, so a check that regenerated the block would run the suite containing itself. That recursion is why `evidence-fresh` verifies Group A only and leaves Group B attested.",
+      "Must be run from the repository ROOT of a CLEAN checkout at the pull request's head, and refuses otherwise. The regeneration inherits the working directory and several gates resolve their scan root from it, so a subdirectory silently narrows what the fresh run inspects. On cleanliness: Group B is regenerated by diff-scoped checks, so uncommitted or untracked files change which files are scanned and can produce a MATCH a clean checkout would not. Ignored paths are deliberately NOT inspected — `git diff` never reports one, so they cannot change the scope, and including them would refuse in every real checkout since `node_modules` is ignored and always present. The head is read from the forge and both a mismatch AND an unreadable head refuse — the verdict is bound to a commit, never merely attested. `BASE_SHA` is refused as well, since it steers the regeneration's merge-base.",
+      "Exits 0 on MATCH; 1 on DIFFERS, HIDDEN, or no block; 2 on a refusal (dirty worktree, wrong head, usage error). HIDDEN means the anchor pair sits inside a collapsed `<details>` block, where `body-bare-digits` blanks every digit and nothing can verify what it claims.",
+      "Comparison is a multiset of repo-relative, control-stripped lines: absolute paths (local AND foreign, so a block generated in CI compares against one generated on a laptop) and line order are ignored — a reorder is not a fabrication. Only the AEG:EVIDENCE region is read, since AEG:TOKENS appends by design. A moved merge-base is reported ALONGSIDE the differing lines, never instead of them."
+    ],
+    status: "shipped"
+  },
   {
     name: "issue create",
     description: "Open an issue after full brief-schema validation",
@@ -3895,6 +4262,19 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "milestone close",
+    description: "Close a tranche's Milestone after verifying every labeled Issue is actually attached",
+    flags: [
+      { flag: "--slug", description: "The tranche whose Milestone is being closed" },
+      { flag: "--validate-only", description: "Run every gate and report PASS without closing the Milestone" },
+      { flag: "--json", description: "Enveloped JSON output (schema: 1)" }
+    ],
+    details: [
+      "Resolves the target Milestone the same legacy-or-intent-declared way Issue create auto-attach does, then refuses to close on any mismatch between the label's Issues and the Milestone's natively attached Issues — naming each unattached or foreign Issue and its repair path (`gh issue edit <n> --milestone <title>`, or `vinaya milestone adopt`) — before the PATCH ever reaches the forge."
+    ],
+    status: "shipped"
+  },
   {
     name: "review post",
     description: "Render, post, and self-verify a code-reviewer or security-review verdict comment on a PR",
@@ -4104,9 +4484,9 @@ function emitCheckError(error) {
 
 // src/lib/config.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { z as z2 } from "zod";
 
 // src/lib/agent-vendors.ts
@@ -4214,6 +4594,20 @@ var ManagedManifestSchema = z2.object({
   labels: z2.array(z2.string()),
   agents: z2.array(z2.enum(AGENT_VENDORS)).optional()
 });
+var ProjectEntrySchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().min(1).optional(),
+  path: z2.string().min(1).optional()
+});
+function parseTokensCollectDeclaration(value) {
+  const m = value.trim().match(/^(\S+)\s+(\S+)$/);
+  if (!m)
+    return null;
+  const [, interpreter, script] = m;
+  if (!isSafeRepoRelPath(script))
+    return null;
+  return { interpreter, script };
+}
 var VinayaConfigSchema = z2.object({
   rings: z2.object({
     ring1_forgeWriteInterception: z2.boolean(),
@@ -4226,13 +4620,19 @@ var VinayaConfigSchema = z2.object({
   principals: z2.array(z2.string()).min(1).optional(),
   releaseActor: z2.string().min(1).optional(),
   ci: z2.object({ setup: z2.string().min(1) }).optional(),
+  tokens: z2.object({
+    collect: z2.string().min(1).refine((v) => parseTokensCollectDeclaration(v) !== null, {
+      message: 'tokens.collect must be exactly "<interpreter> <repo-relative-script-path>" — two whitespace-separated tokens, no flags, no shell syntax, no quoting'
+    })
+  }).optional(),
   blastRadius: z2.object({ extraDomains: z2.array(z2.string()).optional() }).optional(),
   proseGates: z2.object({
     doctrineRoot: z2.string().min(1).optional(),
     readerFacingPrefix: z2.string().min(1).optional(),
     readerFacingSuffix: z2.string().min(1).optional(),
     legacySlugDir: z2.string().min(1).optional()
-  }).optional()
+  }).optional(),
+  projects: z2.array(ProjectEntrySchema).optional()
 });
 var GLOBAL_VINAYA_HOME = join(homedir(), ".vinaya");
 var GLOBAL_CONFIG_PATH = join(GLOBAL_VINAYA_HOME, "config.json");
@@ -4271,6 +4671,9 @@ function globalRolesIgnoredWarning(path) {
 function globalReleaseActorIgnoredWarning(path) {
   return `${path}: "releaseActor" in the global config is ignored — releaseActor may only be declared from a repo-local vinaya.config.json.`;
 }
+function globalTokensCollectIgnoredWarning(path) {
+  return `${path}: "tokens" in the global config is ignored — tokens.collect may only be declared from a repo-local vinaya.config.json.`;
+}
 function stripGlobalOnlyKeys(config, path) {
   if (path !== GLOBAL_CONFIG_PATH)
     return config;
@@ -4291,6 +4694,10 @@ function stripGlobalOnlyKeys(config, path) {
     console.error(`⚠ ${globalReleaseActorIgnoredWarning(path)}`);
     result = { ...result, releaseActor: undefined };
   }
+  if (result.tokens) {
+    console.error(`⚠ ${globalTokensCollectIgnoredWarning(path)}`);
+    result = { ...result, tokens: undefined };
+  }
   return result;
 }
 function resolvePrincipalAllowlist(config) {
@@ -4370,18 +4777,19 @@ function loadConfig() {
   if (!path)
     return null;
   try {
-    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    const raw = JSON.parse(readFileSync2(path, "utf-8"));
     return stripGlobalOnlyKeys(VinayaConfigSchema.parse(raw), path);
   } catch {
     return null;
   }
 }
+var TOKENS_COLLECT_TRUST_PATH = join(GLOBAL_VINAYA_HOME, "tokens-collect-trust.json");
 
 // src/lib/ops.ts
-import { dirname as dirname2, isAbsolute, join as join2, resolve, sep } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2, sep } from "node:path";
 function containedAbs(repoRoot, relPath) {
-  const root = resolve(repoRoot);
-  const target = resolve(root, relPath);
+  const root = resolve2(repoRoot);
+  const target = resolve2(root, relPath);
   if (target === root)
     return null;
   return target === root || target.startsWith(root + sep) ? target : null;
@@ -4413,9 +4821,32 @@ function fetchIssueState(num, repo) {
   issueCache.set(key, out);
   return out;
 }
+var defaultResolveSiblingTranche = async (slug, repo) => {
+  let tranche;
+  try {
+    tranche = await deriveTrancheFromForge(repo.owner, repo.repo, slug);
+  } catch {
+    return null;
+  }
+  const taskRefs = tranche.tasks.map((t) => ({ id: t.id, issue: t.issue }));
+  const snapshot = await fetchForgeFacts({ owner: repo.owner, repo: repo.repo, tranche: slug, tasks: taskRefs });
+  return {
+    tasks: new Map(tranche.tasks.map((t) => [t.id, { id: t.id, issue: t.issue }])),
+    facts: snapshot.facts
+  };
+};
+var siblingTrancheCache = new Map;
 function edgeFromIssueJson(num, json) {
   if (json === null) {
-    return { issue: num, merged: false, open: false, issueState: null, stateReason: null, closedByActor: null };
+    return {
+      issue: num,
+      merged: false,
+      open: false,
+      issueState: null,
+      stateReason: null,
+      closedByActor: null,
+      resolved: true
+    };
   }
   const state = json.state === "CLOSED" ? "closed" : json.state === "OPEN" ? "open" : null;
   const reason = json.stateReason === "COMPLETED" ? "completed" : json.stateReason === "NOT_PLANNED" ? "not_planned" : null;
@@ -4426,10 +4857,11 @@ function edgeFromIssueJson(num, json) {
     open: false,
     issueState: state,
     stateReason: reason,
-    closedByActor: null
+    closedByActor: null,
+    resolved: true
   };
 }
-function resolveEdge(id, taskById, factsByTaskId, repo) {
+async function resolveEdge(id, taskById, factsByTaskId, repo, resolveSibling = defaultResolveSiblingTranche) {
   const target = taskById.get(id);
   if (target) {
     const facts = target.issue !== null ? factsByTaskId.get(target.id) : undefined;
@@ -4439,7 +4871,8 @@ function resolveEdge(id, taskById, factsByTaskId, repo) {
       open: facts?.prState === "open",
       issueState: facts?.issueState ?? null,
       stateReason: facts?.stateReason ?? null,
-      closedByActor: facts?.closedByActor ?? null
+      closedByActor: facts?.closedByActor ?? null,
+      resolved: true
     };
   }
   const direct = id.match(DIRECT_ISSUE_REF);
@@ -4447,7 +4880,37 @@ function resolveEdge(id, taskById, factsByTaskId, repo) {
     const num = Number(direct[1]);
     return edgeFromIssueJson(num, fetchIssueState(num, repo));
   }
-  return { issue: null, merged: false, open: false, issueState: null, stateReason: null, closedByActor: null };
+  const qualified = splitSlugQualifiedEdge(id);
+  if (qualified) {
+    const cacheKey = `${repo.owner}/${repo.repo}:${qualified.slug}`;
+    let sibling = siblingTrancheCache.get(cacheKey);
+    if (sibling === undefined) {
+      sibling = await resolveSibling(qualified.slug, repo);
+      siblingTrancheCache.set(cacheKey, sibling);
+    }
+    const siblingTask = sibling?.tasks.get(qualified.bareId);
+    if (sibling && siblingTask) {
+      const facts = siblingTask.issue !== null ? sibling.facts.get(siblingTask.id) : undefined;
+      return {
+        issue: siblingTask.issue,
+        merged: facts?.prState === "merged",
+        open: facts?.prState === "open",
+        issueState: facts?.issueState ?? null,
+        stateReason: facts?.stateReason ?? null,
+        closedByActor: facts?.closedByActor ?? null,
+        resolved: true
+      };
+    }
+  }
+  return {
+    issue: null,
+    merged: false,
+    open: false,
+    issueState: null,
+    stateReason: null,
+    closedByActor: null,
+    resolved: false
+  };
 }
 
 // src/checks/premise-reassert-logic.ts
@@ -4553,13 +5016,13 @@ function checkPremiseReassertion() {
   const premiseFile = process.env.PREMISE_FILE;
   if (!premiseFile)
     return true;
-  const body = existsSync2(premiseFile) ? readFileSync2(premiseFile, "utf8") : null;
+  const body = existsSync2(premiseFile) ? readFileSync3(premiseFile, "utf8") : null;
   const result = reassertPremiseFile(CHECK_NAME, premiseFile, body, (p) => {
     const real = containedRealPath(process.cwd(), p);
     if (real === null)
       return null;
     try {
-      return readFileSync2(real, "utf8");
+      return readFileSync3(real, "utf8");
     } catch {
       return null;
     }
@@ -4573,8 +5036,8 @@ function containedRealPath(root, p) {
   if (abs === null)
     return null;
   try {
-    const real = realpathSync(abs);
-    const realRoot = realpathSync(root);
+    const real = realpathSync2(abs);
+    const realRoot = realpathSync2(root);
     return real === realRoot || real.startsWith(realRoot + sep2) ? real : null;
   } catch {
     return null;
@@ -4619,21 +5082,22 @@ async function main() {
   const issueRationalePass = openIssueMatch ? checkIssueRationale(openIssueMatch.body).status !== "fail" : true;
   const taskById = new Map(tranche.tasks.map((t) => [t.id, t]));
   const factsByTaskId = snapshot.facts;
-  const dependsOn = task.dependsOn.map((dep) => {
-    const r = resolveEdge(dep, taskById, factsByTaskId, repo);
+  const dependsOn = await Promise.all(task.dependsOn.map(async (dep) => {
+    const r = await resolveEdge(dep, taskById, factsByTaskId, repo);
     return {
       id: dep,
       issue: r.issue,
       merged: r.merged,
+      resolved: r.resolved,
       issueState: r.issueState,
       stateReason: r.stateReason,
       closedByActor: r.closedByActor
     };
-  });
-  const conflictsWith = task.conflictsWith.map((c) => {
-    const r = resolveEdge(c, taskById, factsByTaskId, repo);
+  }));
+  const conflictsWith = await Promise.all(task.conflictsWith.map(async (c) => {
+    const r = await resolveEdge(c, taskById, factsByTaskId, repo);
     return { id: c, issue: r.issue, openOrInFlight: r.open };
-  });
+  }));
   const priorTrancheArchival = [];
   const input = {
     trancheSlug,
@@ -4671,6 +5135,9 @@ function recoveryPromptFor(blocker) {
   if (blocker.startsWith("dispatch-gate rationale:")) {
     return "The task's Issue fails the rationale gate. Ask the Planner to complete the eight-field rationale on the Issue body, then re-run `vinaya check dispatch-readiness`.";
   }
+  if (blocker.startsWith("dispatch-gate depends-on:") && blocker.includes("UNRESOLVABLE")) {
+    return "A declared dependency edge could not be resolved to any tranche/task/Issue — check the tranche slug and task id in the edge text, then re-run `vinaya check dispatch-readiness`.";
+  }
   if (blocker.startsWith("dispatch-gate depends-on:")) {
     return "A declared dependency is not merged yet. Do not start this task — wait for the named dependency PR to merge, then re-run `vinaya check dispatch-readiness`.";
   }