vouchington-tooling 0.78.1 → 0.79.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1163,9 +1163,14 @@ await composeRetrospective({ ...input, journal: { journalLoader } })
1163
1163
  `journalLoader` is a `JournalLoader`; `JournalLoader`, `JournalLoadResult`,
1164
1164
  `JournalEntry`, and `JournalAuditOptions` are exported as types from
1165
1165
  `vouchington-tooling/agent-blackboard`. The `## CI Failures` block grammar has three status
1166
- lines (`failures observed`, `none observed`, `unavailable (<reason>)`).
1167
- Journal-only sandbox and permission entries are journal Markdown entries that hold exactly one
1168
- block, escaped and length-bounded like CI failures, and other entries are ignored:
1166
+ lines (`failures observed`, `none observed`, `unavailable (<reason>)`). An entry may hold several
1167
+ CI-failure blocks, and each top-level block line (`` - ` ``) starts one. A block that names
1168
+ `recurring` or `one-off` with `GitHub Actions` but does not match the grammar is reported as one
1169
+ `unparsed` note counting such blocks, never silently dropped.
1170
+ Journal-only sandbox and permission entries are journal Markdown entries that hold one or more
1171
+ blocks, split the same way, escaped and length-bounded like CI failures. A block that names
1172
+ `sandbox-escalation`, `sandbox-failure`, or `ambiguous-failure` but does not match the grammar is
1173
+ reported as an `unparsed` note; other text is ignored:
1169
1174
 
1170
1175
  ```markdown
1171
1176
  - `sandbox-escalation` — git push — network write blocked
@@ -1,6 +1,6 @@
1
1
  import type { AuditRedactor } from '../audit-journal/text.mts';
2
2
  import type { JournalEntry } from '../audit-journal/types.mts';
3
- /** Journal entries that hold exactly one sandbox or permission block, made paste-safe. */
3
+ /** Journal entries that hold sandbox or permission blocks (several per entry), made paste-safe. */
4
4
  export declare function getConformingSandboxBlocks(entries: Iterable<JournalEntry>, redact?: AuditRedactor, maxBytes?: number): string[];
5
5
  export declare function unavailableSandboxSection(reason: string, blocks?: string[]): string;
6
6
  export declare function journalSandboxSection(blocks: string[]): string;
@@ -44,9 +44,18 @@ function omissionBlock(count) {
44
44
  ' - Disposition: see journal for the omitted blocks',
45
45
  ].join('\n');
46
46
  }
47
- /** Journal entries that hold exactly one sandbox or permission block, made paste-safe. */
47
+ /** Journal text that names a sandbox block type but does not match its grammar. */
48
+ const UNPARSED = {
49
+ marker: /`(?:sandbox-escalation|sandbox-failure|ambiguous-failure)`/,
50
+ note: (count) => [
51
+ `- \`ambiguous-failure\` — unparsed — ${count} journal blocks named a sandbox event but did not match the block grammar; see journal`,
52
+ ' - Evidence: unparsed blocks remain in the session journal',
53
+ ' - Disposition: see journal for the unparsed sandbox blocks',
54
+ ].join('\n'),
55
+ };
56
+ /** Journal entries that hold sandbox or permission blocks (several per entry), made paste-safe. */
48
57
  export function getConformingSandboxBlocks(entries, redact, maxBytes = SANDBOX_BLOCKS_MAX_BYTES) {
49
- return conformingBlocks(entries, matchBlock, Math.min(maxBytes, SANDBOX_BLOCKS_MAX_BYTES), redact, omissionBlock);
58
+ return conformingBlocks(entries, matchBlock, Math.min(maxBytes, SANDBOX_BLOCKS_MAX_BYTES), redact, omissionBlock, UNPARSED);
50
59
  }
51
60
  export function unavailableSandboxSection(reason, blocks = []) {
52
61
  return [`${SANDBOX_SECTION_HEADER}\nStatus: unavailable (${reason})`, ...blocks].join('\n\n');
@@ -5,9 +5,15 @@ import { type AuditRedactor } from './text.mts';
5
5
  export declare function matchAuditBlock(markdown: string, patterns: readonly RegExp[], prefixes: readonly string[], render: AuditRender & {
6
6
  shrinkOrder: readonly number[];
7
7
  }): string | null;
8
+ /** What counts as an audit block that failed to parse, and how to report that many of them. */
9
+ export type UnparsedReport = {
10
+ marker: RegExp;
11
+ note: (count: number) => string;
12
+ };
8
13
  /**
9
14
  * Matches every journal block whole while together they fit `totalBudgetBytes`. Otherwise it keeps
10
15
  * the leading blocks that fit an equal share of the total and appends `omission(count)` — itself a
11
- * conforming block — so dropped groups are always reported, never silent.
16
+ * conforming block — so dropped groups are always reported, never silent. Blocks that name an
17
+ * audit type but do not match the grammar are counted and reported by `unparsed`, never ignored.
12
18
  */
13
- export declare function conformingBlocks(entries: Iterable<JournalEntry>, match: (markdown: string, render: AuditRender) => string | null, totalBudgetBytes: number, redact: AuditRedactor | undefined, omission: (count: number) => string): string[];
19
+ export declare function conformingBlocks(entries: Iterable<JournalEntry>, match: (markdown: string, render: AuditRender) => string | null, totalBudgetBytes: number, redact: AuditRedactor | undefined, omission: (count: number) => string, unparsed?: UnparsedReport): string[];
@@ -43,18 +43,48 @@ export function matchAuditBlock(markdown, patterns, prefixes, render) {
43
43
  const contents = fitFields(safe.map(({ units }) => units), overhead, render.budgetBytes ?? Infinity, render.shrinkOrder);
44
44
  return safe.map(({ prefix }, index) => `${prefix}${contents[index]}`).join('\n');
45
45
  }
46
+ const BLOCK_START = '- `';
47
+ /**
48
+ * One entry may hold several blocks: each top-level block line starts one. Text that does not
49
+ * open with a block is returned whole, so it either matches as a single block or is reported.
50
+ */
51
+ function splitBlocks(markdown) {
52
+ const lines = markdown.replace(/\r\n?/g, '\n').split('\n');
53
+ const first = lines.find((line) => !BLANK.test(line));
54
+ if (first === undefined || !first.startsWith(BLOCK_START))
55
+ return [markdown];
56
+ const chunks = [];
57
+ for (const line of lines.slice(lines.indexOf(first))) {
58
+ if (line.startsWith(BLOCK_START))
59
+ chunks.push([line]);
60
+ else
61
+ chunks.at(-1).push(line);
62
+ }
63
+ return chunks.map((chunk) => chunk.join('\n'));
64
+ }
46
65
  /**
47
66
  * Matches every journal block whole while together they fit `totalBudgetBytes`. Otherwise it keeps
48
67
  * the leading blocks that fit an equal share of the total and appends `omission(count)` — itself a
49
- * conforming block — so dropped groups are always reported, never silent.
68
+ * conforming block — so dropped groups are always reported, never silent. Blocks that name an
69
+ * audit type but do not match the grammar are counted and reported by `unparsed`, never ignored.
50
70
  */
51
- export function conformingBlocks(entries, match, totalBudgetBytes, redact, omission) {
71
+ export function conformingBlocks(entries, match, totalBudgetBytes, redact, omission, unparsed) {
72
+ let unparsedCount = 0;
52
73
  const markdowns = [...entries]
53
74
  .flatMap((entry) => {
54
75
  const data = entry?.data;
55
- return data?.type === 'journal' && typeof data.markdown === 'string' ? [data.markdown] : [];
76
+ return data?.type === 'journal' && typeof data.markdown === 'string'
77
+ ? splitBlocks(data.markdown)
78
+ : [];
56
79
  })
57
- .filter((markdown) => match(markdown, { redact }) !== null);
80
+ .filter((markdown) => {
81
+ if (match(markdown, { redact }) !== null)
82
+ return true;
83
+ if (unparsed?.marker.test(markdown))
84
+ unparsedCount++;
85
+ return false;
86
+ });
58
87
  const { rendered, omitted } = selectWithin(markdowns, totalBudgetBytes, byteLength(omission(markdowns.length)) + 2, 2, MIN_BLOCK_SHARE_BYTES, (markdown, budgetBytes) => match(markdown, { redact, budgetBytes }));
59
- return omitted ? [...rendered, omission(omitted)] : rendered;
88
+ const blocks = omitted ? [...rendered, omission(omitted)] : rendered;
89
+ return unparsed && unparsedCount ? [...blocks, unparsed.note(unparsedCount)] : blocks;
60
90
  }
@@ -28,6 +28,16 @@ function omissionGroup(count) {
28
28
  ' - Disposition: see journal for the omitted failure groups',
29
29
  ].join('\n');
30
30
  }
31
+ /** Journal text that names a CI failure group but does not match the block grammar. */
32
+ const UNPARSED = {
33
+ marker: /`(?:recurring|one-off)` — `GitHub Actions`/,
34
+ note: (count) => [
35
+ `- \`one-off\` — \`GitHub Actions\` — ${count} journal blocks named a CI failure but did not match the block grammar; see journal`,
36
+ ' - Evidence: unparsed blocks remain in the session journal',
37
+ ' - Root diagnostic: not parsed; the journal text did not match the documented block grammar',
38
+ ' - Disposition: see journal for the unparsed failure blocks',
39
+ ].join('\n'),
40
+ };
31
41
  export function isConformingCiFailureBlock(markdown) {
32
42
  if (markdown.length > CI_FAILURE_BLOCK_MAX_BYTES ||
33
43
  Buffer.byteLength(markdown) > CI_FAILURE_BLOCK_MAX_BYTES)
@@ -35,7 +45,7 @@ export function isConformingCiFailureBlock(markdown) {
35
45
  return matchBlock(markdown) !== null;
36
46
  }
37
47
  export function getConformingGroups(entries, redact, maxBytes = CI_SECTION_MAX_BYTES) {
38
- return conformingBlocks(entries, matchBlock, Math.min(maxBytes, CI_SECTION_MAX_BYTES), redact, omissionGroup);
48
+ return conformingBlocks(entries, matchBlock, Math.min(maxBytes, CI_SECTION_MAX_BYTES), redact, omissionGroup, UNPARSED);
39
49
  }
40
50
  export function incompleteCiSection(markdownBlocks) {
41
51
  return [
@@ -3,6 +3,7 @@ import type { RunTextCommand } from '../gh-cli/exec.mts';
3
3
  import type { GhRunner } from './pr-gh.mts';
4
4
  import type { PolicySpawner } from './policy-spawn.mts';
5
5
  import { type SnapshotRegistry } from './snapshot-registry.mts';
6
+ import { type InstallInfo } from './install-info.mts';
6
7
  export type ServerEnvironment = {
7
8
  /** The launch directory's worktree top level, or undefined when it is not inside one. */
8
9
  launchRoot: string | undefined;
@@ -25,6 +26,8 @@ export type ServerEnvironment = {
25
26
  };
26
27
  /** Test seam: a fresh registry stands in for a server restart. Defaults to the process's own. */
27
28
  snapshots?: SnapshotRegistry;
29
+ /** The server's own version and install location, captured at startup. */
30
+ install?: InstallInfo;
28
31
  };
29
32
  export type ToolCallResult = {
30
33
  content: Array<{
@@ -10,9 +10,11 @@ import { snapshotPartition } from "./handlers-snapshot-partition.mjs";
10
10
  import { sessionArchive, sessionEnsure, snapshotExport } from "./handlers-session.mjs";
11
11
  import { handlePrCreate, handlePrUpdate, handlePrValidate } from "./handlers-pr.mjs";
12
12
  import { createSnapshotRegistry } from "./snapshot-registry.mjs";
13
+ import { captureInstall, installSuffix } from "./install-info.mjs";
13
14
  import { TOOLS } from "./tools.mjs";
14
15
  import { resolveWorktree } from "./worktree.mjs";
15
16
  const PROCESS_SNAPSHOTS = createSnapshotRegistry();
17
+ const PROCESS_INSTALL = captureInstall();
16
18
  const HANDLERS = {
17
19
  journal_append: journalAppend,
18
20
  journal_entries: journalEntries,
@@ -81,6 +83,10 @@ export async function callTool(name, rawArguments, environment) {
81
83
  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
82
84
  }
83
85
  catch (error) {
84
- return { isError: true, content: [{ type: 'text', text: describeError(error) }] };
86
+ const install = environment.install ?? PROCESS_INSTALL;
87
+ return {
88
+ isError: true,
89
+ content: [{ type: 'text', text: describeError(error) + installSuffix(error, install) }],
90
+ };
85
91
  }
86
92
  }
@@ -0,0 +1,11 @@
1
+ /** What the running server knows about its own install, captured once at startup. */
2
+ export type InstallInfo = {
3
+ name: string;
4
+ version: string;
5
+ /** Absolute path of the package directory this server was loaded from. */
6
+ location: string;
7
+ };
8
+ export declare function captureInstall(version?: string): InstallInfo;
9
+ export declare function describeInstall(install: InstallInfo): string;
10
+ /** The suffix appended to every tool error so a stale or swapped install is obvious. */
11
+ export declare function installSuffix(error: unknown, install: InstallInfo): string;
@@ -0,0 +1,45 @@
1
+ import { isAbsolute, relative, sep } from 'node:path';
2
+ import { fileURLToPath } from 'node:url';
3
+ import { readInstalledVersion } from "../cli/installed-version.mjs";
4
+ const PACKAGE_NAME = 'vouchington-tooling';
5
+ export function captureInstall(version = readInstalledVersion()) {
6
+ return {
7
+ name: PACKAGE_NAME,
8
+ version,
9
+ location: fileURLToPath(new URL('../../', import.meta.url)).replace(/\/$/, ''),
10
+ };
11
+ }
12
+ export function describeInstall(install) {
13
+ return `${install.name} ${install.version} (${install.location})`;
14
+ }
15
+ const MISSING_FILE = /ERR_MODULE_NOT_FOUND|Cannot find module|ENOENT|no such file/i;
16
+ /**
17
+ * The missing target only: the ENOENT `path`, else the first quoted specifier in the message
18
+ * (`Cannot find module '<x>'`, `Cannot find package '<x>'`), never the "imported from" importer.
19
+ */
20
+ function missingTarget(error, message) {
21
+ const path = error?.path;
22
+ if (typeof path === 'string')
23
+ return path;
24
+ return /'([^']+)'/.exec(message)?.[1];
25
+ }
26
+ /** True only for a missing-file failure whose missing target is inside the server's own install. */
27
+ function isInstallSwapped(error, install) {
28
+ const code = error?.code;
29
+ const message = error instanceof Error ? error.message : String(error);
30
+ const text = `${typeof code === 'string' ? code : ''} ${message}`;
31
+ if (!MISSING_FILE.test(text))
32
+ return false;
33
+ const target = missingTarget(error, message);
34
+ if (target === undefined || !isAbsolute(target))
35
+ return false;
36
+ const rel = relative(install.location, target);
37
+ return rel !== '' && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
38
+ }
39
+ /** The suffix appended to every tool error so a stale or swapped install is obvious. */
40
+ export function installSuffix(error, install) {
41
+ const swapped = isInstallSwapped(error, install)
42
+ ? ' The server install changed underneath it: reconnect the server (`/mcp` in Claude Code, or restart Codex).'
43
+ : '';
44
+ return `${swapped}\n[${describeInstall(install)}]`;
45
+ }
@@ -1,4 +1,6 @@
1
1
  import type { Args } from './args.mts';
2
+ /** A pull request number as digits, from a digit string or a positive safe integer. */
3
+ export declare function prNumber(value: unknown): string | undefined;
2
4
  /**
3
5
  * Checks `compose.facts`: either `{ status, reason }` (unassessed) or a live collection selector,
4
6
  * never both. Returns whether live collection was requested.
@@ -1,5 +1,11 @@
1
1
  /** A plain branch name: no scheme or colon, no leading dash, no `..`. */
2
2
  const BRANCH = /^(?!-)(?!.*\.\.)[A-Za-z0-9._/-]+$/;
3
+ /** A pull request number as digits, from a digit string or a positive safe integer. */
4
+ export function prNumber(value) {
5
+ if (typeof value === 'number')
6
+ return Number.isSafeInteger(value) && value > 0 ? String(value) : undefined;
7
+ return typeof value === 'string' && /^\d+$/.test(value) ? value : undefined;
8
+ }
3
9
  /**
4
10
  * Checks `compose.facts`: either `{ status, reason }` (unassessed) or a live collection selector,
5
11
  * never both. Returns whether live collection was requested.
@@ -15,8 +21,8 @@ export function checkFactsInput(facts) {
15
21
  throw new Error('compose.facts.reason requires a status');
16
22
  // The collector trusts these types; a string "false" must not read as noPr: true.
17
23
  // gh accepts a pull request URL for either, which would reach another repository.
18
- if ('pr' in facts && (typeof facts.pr !== 'string' || !/^\d+$/.test(facts.pr)))
19
- throw new Error('compose.facts.pr must be a pull request number string');
24
+ if ('pr' in facts && prNumber(facts.pr) === undefined)
25
+ throw new Error('compose.facts.pr must be a pull request number (positive integer or string)');
20
26
  if ('branch' in facts && (typeof facts.branch !== 'string' || !BRANCH.test(facts.branch)))
21
27
  throw new Error('compose.facts.branch must be a branch name');
22
28
  if ('noPr' in facts && typeof facts.noPr !== 'boolean')
@@ -3,7 +3,7 @@ import { rejectUnknown } from "./args.mjs";
3
3
  import { inspectHarnessEnvironment, selectHarnessSession, } from "../agent-harness-identity/index.mjs";
4
4
  import { SESSION_ID } from "../retrospective-transcript/resolve-transcript-file.mjs";
5
5
  import { serverJournalLoader } from "./journal-read.mjs";
6
- import { checkFactsInput } from "./retrospective-facts-input.mjs";
6
+ import { checkFactsInput, prNumber } from "./retrospective-facts-input.mjs";
7
7
  import { spawnPolicy } from "./policy-spawn.mjs";
8
8
  const HARNESSES = ['codex', 'claude', 'cursor', 'grok'];
9
9
  const COMPOSE_KEYS = [
@@ -117,7 +117,11 @@ function transcriptInput(transcript, base) {
117
117
  }
118
118
  function factsInput(facts, base) {
119
119
  return checkFactsInput(facts)
120
- ? { ...facts, execute: worktreeExecutor(base.worktree, base.env) }
120
+ ? {
121
+ ...facts,
122
+ ...('pr' in facts ? { pr: prNumber(facts.pr) } : {}),
123
+ execute: worktreeExecutor(base.worktree, base.env),
124
+ }
121
125
  : facts;
122
126
  }
123
127
  /** Builds the retrospective markdown with `composeRetrospective`, rejecting unknown input keys. */
@@ -1,4 +1,5 @@
1
1
  import { assertBlackboardInstalled, loadMcpSdk } from "./sdk.mjs";
2
+ import { captureInstall } from "./install-info.mjs";
2
3
  import { createMcpServer } from "./server.mjs";
3
4
  import { launchWorktreeRoot, runIsolatedGit } from "./worktree.mjs";
4
5
  /**
@@ -15,6 +16,7 @@ export async function runMcpServer(options) {
15
16
  launchRoot,
16
17
  env: options.env,
17
18
  runGit,
19
+ install: captureInstall(options.version),
18
20
  ...(options.resolveFrom === undefined ? {} : { resolveFrom: options.resolveFrom }),
19
21
  ...(options.blackboard === undefined ? {} : { blackboard: options.blackboard }),
20
22
  };
@@ -1,2 +1,9 @@
1
1
  import { type CodexSegment } from './shared.mts';
2
+ export type CodexSegmentOutcome = {
3
+ segment: CodexSegment;
4
+ } | {
5
+ reason: string;
6
+ };
7
+ /** Segments a Codex rollout, or says why its owned boundary cannot be established. */
8
+ export declare function explainCodexSegment(lines: string[]): CodexSegmentOutcome;
2
9
  export declare function segmentCodex(lines: string[]): CodexSegment | undefined;
@@ -42,17 +42,18 @@ function retainHighWater(previous, current) {
42
42
  cacheCreation: 0,
43
43
  };
44
44
  }
45
- export function segmentCodex(lines) {
45
+ /** Segments a Codex rollout, or says why its owned boundary cannot be established. */
46
+ export function explainCodexSegment(lines) {
46
47
  const content = lines.filter(Boolean);
47
48
  const sessionMeta = parseLines(content.slice(0, 1))[0];
48
49
  if (sessionMeta?.type !== 'session_meta')
49
- return { lines: content, baseline: emptyTokens() };
50
+ return { segment: { lines: content, baseline: emptyTokens() } };
50
51
  if (!hasInheritedParent(sessionMeta))
51
- return { lines: content.slice(1), baseline: emptyTokens() };
52
+ return { segment: { lines: content.slice(1), baseline: emptyTokens() } };
52
53
  const timestamp = asRecord(sessionMeta.payload)?.timestamp;
53
54
  const timestampMs = typeof timestamp === 'string' ? Date.parse(timestamp) : Number.NaN;
54
55
  if (!Number.isFinite(timestampMs))
55
- return undefined;
56
+ return { reason: 'the inherited child session_meta has no valid timestamp' };
56
57
  const ownedIndex = content.findIndex((line, index) => {
57
58
  if (index === 0)
58
59
  return false;
@@ -60,14 +61,17 @@ export function segmentCodex(lines) {
60
61
  return record ? isOwnedTaskStart(record, timestampMs) : false;
61
62
  });
62
63
  if (ownedIndex === -1)
63
- return undefined;
64
- let baseline;
64
+ return { reason: 'no task_started at or after the child session start was recorded' };
65
+ // A child that inherited no token totals starts from zero, as a fresh subagent does.
66
+ let baseline = emptyTokens();
65
67
  for (const record of parseLines(content.slice(1, ownedIndex))) {
66
68
  const current = usage(record);
67
69
  if (current)
68
- baseline = retainHighWater(baseline ?? emptyTokens(), current);
70
+ baseline = retainHighWater(baseline, current);
69
71
  }
70
- if (!baseline)
71
- return undefined;
72
- return { lines: content.slice(ownedIndex), baseline };
72
+ return { segment: { lines: content.slice(ownedIndex), baseline } };
73
+ }
74
+ export function segmentCodex(lines) {
75
+ const outcome = explainCodexSegment(lines);
76
+ return 'segment' in outcome ? outcome.segment : undefined;
73
77
  }
@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
3
3
  import { homedir } from 'node:os';
4
4
  import { basename, dirname, join } from 'node:path';
5
5
  import { codexChildren, codexIdentity, computeCodex } from "./codex.mjs";
6
- import { segmentCodex } from "./codex-segment.mjs";
6
+ import { explainCodexSegment } from "./codex-segment.mjs";
7
7
  import { computeClaude } from "./claude.mjs";
8
8
  import { formatTranscriptFacts, formatUnavailable } from "./format.mjs";
9
9
  import { globFrom, resolveTranscriptFile, SESSION_ID, } from "./resolve-transcript-file.mjs";
@@ -68,7 +68,7 @@ function matchesChildIdentity(lines, threadId, agentPath) {
68
68
  const threadMatches = identity.threadId?.toLowerCase() === threadId.toLowerCase();
69
69
  return threadMatches && identity.agentPath.replace(/\/$/, '') === agentPath;
70
70
  }
71
- async function codexSubagents(lines, sessionsDir, ownerPath, visited = new Set()) {
71
+ async function codexSubagents(lines, sessionsDir, ownerPath, visited, failure) {
72
72
  const result = [];
73
73
  for (const edge of codexChildren(lines, ownerPath)) {
74
74
  if (visited.has(edge.threadId))
@@ -83,11 +83,13 @@ async function codexSubagents(lines, sessionsDir, ownerPath, visited = new Set()
83
83
  hasMalformedInteriorRecord(child) ||
84
84
  !matchesChildIdentity(child, edge.threadId, edge.agentPath))
85
85
  return undefined;
86
- const segment = segmentCodex(child);
87
- if (!segment)
86
+ const outcome = explainCodexSegment(child);
87
+ if ('reason' in outcome) {
88
+ failure.reason = outcome.reason;
88
89
  return undefined;
89
- result.push({ ...segment, partial: partialCapture(child) });
90
- const nested = await codexSubagents(segment.lines, sessionsDir, edge.agentPath, visited);
90
+ }
91
+ result.push({ ...outcome.segment, partial: partialCapture(child) });
92
+ const nested = await codexSubagents(outcome.segment.lines, sessionsDir, edge.agentPath, visited, failure);
91
93
  if (!nested)
92
94
  return undefined;
93
95
  result.push(...nested);
@@ -121,15 +123,18 @@ export async function runRetrospectiveTranscriptReport(options) {
121
123
  };
122
124
  }
123
125
  const identity = codexIdentity(lines);
124
- const root = segmentCodex(lines);
125
- if (!root)
126
- return unavailable('could not segment Codex transcript');
126
+ const rootOutcome = explainCodexSegment(lines);
127
+ if ('reason' in rootOutcome)
128
+ return unavailable(`could not segment Codex transcript: ${rootOutcome.reason}`);
129
+ const root = rootOutcome.segment;
127
130
  const codexHome = (options.env ?? process.env).CODEX_HOME;
131
+ const unresolved = 'could not resolve a referenced Codex child transcript';
132
+ const failure = {};
128
133
  const subagents = await codexSubagents(root.lines, options.codexSessionsDir ??
129
134
  (options.jsonlPath ? dirname(resolved.path) : undefined) ??
130
- join(codexHome || join(homedir(), '.codex'), 'sessions'), identity.agentPath, new Set([identity.threadId ?? resolved.sessionId].filter((threadId) => SESSION_ID.test(threadId))));
135
+ join(codexHome || join(homedir(), '.codex'), 'sessions'), identity.agentPath, new Set([identity.threadId ?? resolved.sessionId].filter((id) => SESSION_ID.test(id))), failure);
131
136
  if (!subagents)
132
- return unavailable('could not resolve a referenced Codex child transcript');
137
+ return unavailable(failure.reason ? `${unresolved}: could not segment it (${failure.reason})` : unresolved);
133
138
  return {
134
139
  markdown: formatTranscriptFacts(resolved.sessionId, computeCodex(root.lines, subagents, root.baseline)),
135
140
  coverage: partialCapture(lines) || subagents.some((segment) => segment.partial)
@@ -1,78 +1,74 @@
1
1
  export declare function loadPostgresParser(caller: string): Promise<{
2
2
  default: typeof import("no-mistakes");
3
- analyzeTypeScriptModules(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TypeScriptModulesOptions>): Promise<import("no-mistakes").TypeScriptModulesReport>;
4
3
  parsePostgresSql(source: import("no-mistakes").PostgresSqlSource): Promise<import("no-mistakes").PostgresSqlFacts>;
5
4
  parsePostgresSql(sources: import("no-mistakes").PostgresSqlSource[]): Promise<import("no-mistakes").PostgresSqlFacts[]>;
6
- dependencies(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraversePathsOptions>): Promise<import("no-mistakes").ImportClosureResult>;
7
- dependencies(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseGraphOptions>): Promise<import("no-mistakes").DependencyResult>;
8
- dependents(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseOptions>): Promise<import("no-mistakes").DependencyResult>;
9
- related(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseOptions>): Promise<import("no-mistakes").DependencyResult>;
10
- analyzeProject(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").AnalyzeProjectOptions>): Promise<import("no-mistakes").AnalyzeProjectResult>;
11
- writePlanningImpactArtifacts(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").WritePlanningImpactArtifactsOptions>): Promise<import("no-mistakes").PlanningImpactArtifacts>;
12
- symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsSignatureImpactOptions>): Promise<import("no-mistakes").SignatureImpactResult>;
13
- symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsListOptions>): Promise<import("no-mistakes").SymbolsResult>;
14
- symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsOptions>): Promise<import("no-mistakes").SymbolsResult | import("no-mistakes").SignatureImpactResult>;
15
- importUsages(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImportUsagesOptions>): Promise<import("no-mistakes").ImportUsagesResult>;
16
- importers(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImportersOptions>): Promise<import("no-mistakes").ImportersResult>;
17
- exportsOf(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ExportsOfOptions>): Promise<import("no-mistakes").ExportsOfResult>;
18
- deadExports(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").DeadExportsOptions>): Promise<import("no-mistakes").DeadExportsResult>;
19
- callSites(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CallSitesOptions>): Promise<import("no-mistakes").CallSitesResult>;
20
- resolveCheck(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ResolveCheckOptions>): Promise<import("no-mistakes").ResolveCheckResult>;
21
- resolveCheck(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ResolveCheckFilesOptions>): Promise<import("no-mistakes").ResolveCheckBatchResult>;
22
- fetches(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").FetchesOptions>): Promise<import("no-mistakes").FetchReport>;
23
- flow(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").FlowOptions>): Promise<import("no-mistakes").FlowReport>;
24
- check(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CheckOptions>): Promise<import("no-mistakes").CheckReport>;
25
- resolveConfig(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ResolvedConfig>;
26
- validateMermaidMarkdown(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").MermaidValidationOptions>): Promise<import("no-mistakes").MermaidValidationResult>;
27
- testsPlan(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanOptions>): Promise<import("no-mistakes").TestPlan>;
28
- testsImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsImpactOptions>): Promise<import("no-mistakes").TestPlan>;
29
- testsTargets(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsTargetsOptions>): Promise<import("no-mistakes").TestsTargetsReport>;
30
- testsWhy(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsWhyOptions>): Promise<Record<string, import("no-mistakes").WhyStep[]>>;
5
+ dependencies(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraversePathsOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ImportClosureResult>>;
6
+ dependencies(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseGraphOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").DependencyResult>>;
7
+ dependents(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").DependencyResult>>;
8
+ related(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").DependencyResult>>;
9
+ analyzeProject(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").AnalyzeProjectOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").AnalyzeProjectResult>>;
10
+ writePlanningImpactArtifacts(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").WritePlanningImpactArtifactsOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").PlanningImpactArtifacts>>;
11
+ symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsSignatureImpactOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").SignatureImpactResult>>;
12
+ symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsListOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").SymbolsResult>>;
13
+ symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").SymbolsResult | import("no-mistakes").SignatureImpactResult>>;
14
+ importUsages(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImportUsagesOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ImportUsagesResult>>;
15
+ importers(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImportersOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ImportersResult>>;
16
+ exportsOf(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ExportsOfOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ExportsOfResult>>;
17
+ deadExports(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").DeadExportsOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").DeadExportsResult>>;
18
+ callSites(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CallSitesOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").CallSitesResult>>;
19
+ resolveCheck(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ResolveCheckOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ResolveCheckResult>>;
20
+ resolveCheck(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ResolveCheckFilesOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ResolveCheckBatchResult>>;
21
+ fetches(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").FetchesOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").FetchReport>>;
22
+ flow(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").FlowOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").FlowReport>>;
23
+ check(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CheckOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").CheckReport>>;
24
+ resolveConfig(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ResolvedConfig>>;
25
+ validateMermaidMarkdown(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").MermaidValidationOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").MermaidValidationResult>>;
26
+ testsPlan(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").TestPlan>>;
27
+ testsImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsImpactOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").TestPlan>>;
28
+ testsTargets(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsTargetsOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").TestsTargetsReport>>;
29
+ testsWhy(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsWhyOptions>): Promise<import("no-mistakes").WithInvocationResult<Record<string, import("no-mistakes").WhyStep[]>>>;
31
30
  testsComment(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<string>;
32
- testsGraph(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<import("no-mistakes").TestGraph>;
31
+ testsGraph(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").TestGraph>>;
33
32
  testsGraphMermaid(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<string>;
34
- playwrightCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<unknown>;
33
+ playwrightCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<import("no-mistakes").PlaywrightCoverageReport>;
35
34
  playwrightEdges(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<unknown>;
36
35
  playwrightRelated(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightRelatedOptions>): Promise<unknown>;
37
36
  playwrightTests(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<unknown>;
38
- queues(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueReport>;
37
+ queues(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").QueueReport>>;
39
38
  queueEdges(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueEdge[]>;
40
39
  queueRelated(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueEdge[]>;
41
40
  queueCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueCheckFinding[]>;
42
- serverRoutes(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ServerRoutesReport>;
41
+ serverRoutes(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ServerRoutesReport>>;
43
42
  serverRouteList(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<unknown[]>;
44
43
  serverRouteEdges(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").GraphEdge[]>;
45
44
  serverRouteRelated(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").GraphEdge[]>;
46
- serverContracts(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ServerContractsReport>;
45
+ serverContracts(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ServerContractsReport>>;
47
46
  reactAnalyze(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ReactComponentFacts[]>;
48
47
  reactCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ReactViolation[]>;
49
48
  reactUsages(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions & {
50
49
  target: string;
51
- }>): Promise<import("no-mistakes").ReactUsagesReport>;
52
- generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions & {
53
- coverage: "ordering";
54
- }>): Promise<import("no-mistakes").PostgresOrderingCatalog>;
55
- generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions & {
56
- coverage?: "complete";
57
- }>): Promise<import("no-mistakes").PostgresCompleteCatalog>;
58
- generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions>): Promise<import("no-mistakes").PostgresCatalog>;
50
+ }>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ReactUsagesReport>>;
51
+ extractExecutedPostgresSql: typeof import("no-mistakes").extractExecutedPostgresSql;
52
+ diagnosticsSnapshot(options: {
53
+ id: string;
54
+ }): Promise<import("no-mistakes").DiagnosticsProgressSnapshot | null>;
59
55
  lockfileDiff(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").LockfileDiffOptions>): Promise<import("no-mistakes").LockfileDiffEntry[]>;
60
- ciImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiImpactOptions>): Promise<import("no-mistakes").CiImpactReport>;
61
- ciEnv(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiEnvOptions>): Promise<import("no-mistakes").CiEnvReport>;
62
- ciTopology(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiTopologyOptions>): Promise<import("no-mistakes").WorkflowTopology>;
63
- ciTopologyImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiTopologyImpactOptions>): Promise<import("no-mistakes").CiTopologyImpactReport>;
56
+ ciImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiImpactOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").CiImpactReport>>;
57
+ ciEnv(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiEnvOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").CiEnvReport>>;
58
+ ciTopology(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiTopologyOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").WorkflowTopology>>;
59
+ ciTopologyImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiTopologyImpactOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").CiTopologyImpactReport>>;
64
60
  createWorkflowTopologyIndex(topology: import("no-mistakes").WorkflowTopology): import("no-mistakes").WorkflowTopologyIndex;
65
- impactedChecks(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImpactedChecksOptions>): Promise<import("no-mistakes").ImpactedChecksReport>;
66
- dataPw(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").DataPwOptions>): Promise<import("no-mistakes").DataPwReport>;
67
- effects(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").EffectsOptions>): Promise<import("no-mistakes").EffectsReport>;
68
- rscCallers(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").RscCallersOptions>): Promise<import("no-mistakes").RscCallersReport>;
69
- registryExtension(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").RegistryExtensionOptions>): Promise<import("no-mistakes").RegistryExtensionReport>;
61
+ impactedChecks(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImpactedChecksOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ImpactedChecksReport>>;
62
+ dataPw(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").DataPwOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").DataPwReport>>;
63
+ effects(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").EffectsOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").EffectsReport>>;
64
+ rscCallers(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").RscCallersOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").RscCallersReport>>;
65
+ registryExtension(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").RegistryExtensionOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").RegistryExtensionReport>>;
70
66
  infraResourceRefs(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").InfraOptions & {
71
67
  address: string;
72
68
  }>): Promise<import("no-mistakes").ResourceRefRow[]>;
73
69
  infraOutputs(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").InfraOptions & {
74
70
  moduleDir: string;
75
- }>): Promise<import("no-mistakes").ModuleOutputsResult>;
71
+ }>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").ModuleOutputsResult>>;
76
72
  infraTestFor(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").InfraOptions & {
77
73
  tfFile: string;
78
74
  }>): Promise<import("no-mistakes").TestForRow[]>;
@@ -83,4 +79,13 @@ export declare function loadPostgresParser(caller: string): Promise<{
83
79
  file: string;
84
80
  }>): Promise<import("no-mistakes").SwiftTestTargetRow[]>;
85
81
  version(): Promise<string>;
82
+ testsAudit(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsAuditOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").TestAuditReport>>;
83
+ generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions & {
84
+ coverage: "ordering";
85
+ }>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").PostgresOrderingCatalog>>;
86
+ generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions & {
87
+ coverage?: "complete";
88
+ }>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").PostgresCompleteCatalog>>;
89
+ generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").PostgresCatalog>>;
90
+ analyzeTypeScriptModules(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TypeScriptModulesOptions>): Promise<import("no-mistakes").WithInvocationResult<import("no-mistakes").TypeScriptModulesReport>>;
86
91
  }>;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "vouchington-tooling",
3
- "version": "0.78.1",
3
+ "version": "0.79.0",
4
4
  "description": "Vouchington CLI and extractable tooling libraries.",
5
5
  "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
6
6
  "bugs": {
@@ -499,7 +499,7 @@
499
499
  "dependencies": {
500
500
  "@types/mdast": "4.0.4",
501
501
  "@types/unist": "3.0.3",
502
- "@typescript-eslint/parser": "^8.71.2",
502
+ "@typescript-eslint/parser": "^8.72.0",
503
503
  "agent-blackboard": "^0.7.0",
504
504
  "coverage-check": "0.18.0",
505
505
  "csv-parse": "7.0.3",
@@ -525,7 +525,7 @@
525
525
  "@vouchington/worker-runtime": "0.2.1",
526
526
  "glide-mq": "^0.19.0",
527
527
  "next": "16.4.2",
528
- "no-mistakes": "0.83.0",
528
+ "no-mistakes": "0.101.0",
529
529
  "pg": "8.23.1",
530
530
  "react": "19.3.1",
531
531
  "react-dom": "19.3.1",