@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.4

package/src/runtime/{locator-resolve.ts → locator-resolve.js}

@@ -33,10 +33,10 @@ const RESOLUTION_REASONS = new Set([
  * every language in the repository, and a parser per language is a far larger thing than the
  * question being asked.
  */
-function findSymbolLines(lines: string[], symbol: string): number[] {
+function findSymbolLines(lines          , symbol        )           {
   const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const pattern = new RegExp(`(?:^|[^A-Za-z0-9_$])${escaped}(?:[^A-Za-z0-9_$]|$)`);
-  const hits: number[] = [];
+  const hits           = [];
   for (let i = 0; i < lines.length; i += 1) {
     if (pattern.test(lines[i])) hits.push(i + 1);
   }
@@ -52,10 +52,10 @@ function findSymbolLines(lines: string[], symbol: string): number[] {
  *
  * @returns {{lines: string[]}|{missing: true}}
  */
-function readTargetLines(locator: any, root: string, impl: any): { lines: string[] } | { missing: true } {
+function readTargetLines(locator     , root        , impl     )                                          {
   const target = path.isAbsolute(locator.file) ? locator.file : path.join(root, locator.file);
 
-  let content: string;
+  let content        ;
   try {
     if (!impl.existsSync(target)) return { missing: true };
     content = impl.readFileSync(target, 'utf8');
@@ -78,7 +78,7 @@ function readTargetLines(locator: any, root: string, impl: any): { lines: string
  * already reports. Only absence is unresolvable — that distinction is the whole of this function
  * and is easier to see with nothing else around it.
  */
-function checkSymbol(lines: string[], symbol: string): any {
+function checkSymbol(lines          , symbol        )      {
   const symbolLines = findSymbolLines(lines, symbol);
   if (symbolLines.length === 0) {
     return { resolved: false, reason: 'symbol-absent', actual: { lines: lines.length, symbolLines: [] } };
@@ -105,7 +105,7 @@ const NOT_CHECKABLE = { resolved: true, reason: 'not-checkable', actual: null };
  *   `actual` names what the file does offer, so a caller can build a message the writer can act on:
  *   `{ lines }` for a line miss, `{ symbolLines }` for a symbol miss.
  */
-function resolveLocator({ locator, repoRoot, fsImpl }: any = {}): { resolved: boolean; reason: string | null; actual: any } {
+function resolveLocator({ locator, repoRoot, fsImpl }      = {})                                                            {
   if (!locator || typeof locator !== 'object' || Array.isArray(locator)) return { ...NOT_CHECKABLE };
   // A uri-only locator, or an empty locator on a non-extracted item. Nothing readable here.
   if (!locator.file) return { ...NOT_CHECKABLE };
@@ -130,7 +130,7 @@ function resolveLocator({ locator, repoRoot, fsImpl }: any = {}): { resolved: bo
  * @param {{resolved: boolean, reason: (string|null), actual: (Object|null)}} result
  * @returns {string|null}
  */
-function describeResolution(locator: any, result: any): string | null {
+function describeResolution(locator     , result     )                {
   if (!result || result.resolved) return null;
   const file = (locator && locator.file) || '(no file)';
   switch (result.reason) {

package/src/runtime/{mask.ts → mask.js}

@@ -52,10 +52,10 @@ const KEY_VALUE_BODY = new RegExp(`(${KEY_NAME}["']?[ \\t]*[=:][ \\t]*)("[^"\\r\
 const AUTH_HEADER = /((?:Proxy-)?Authorization:)[ \t]*([^\r\n]*)/gi;
 const SECRET_FLAG = /(--(?:password|passwd|token|secret|api-key|client-secret)(?:=|[ \t]+))("[^"\r\n]*"|'[^'\r\n]*'|[^\s"']+)/gi;
 
-function escapeRegExp(text: string): string { return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function escapeRegExp(text        )         { return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 
 /** The home directory to abbreviate: an absolute path other than the file system root. */
-function homeOf(options?: any): string | null {
+function homeOf(options      )                {
   const raw = options && 'home' in options ? options.home : process.env.HOME;
   if (typeof raw !== 'string' || !raw.startsWith('/')) return null;
   const home = raw.replace(/\/+$/, '');
@@ -63,12 +63,12 @@ function homeOf(options?: any): string | null {
 }
 
 /** A run of 32 or more characters that is a path: starts with `/`, `~` or `.` and has no part of 32+. */
-function isPathRun(run: string, before: string | undefined): boolean {
+function isPathRun(run        , before                    )          {
   if (!(run.startsWith('/') || before === '~' || before === '.')) return false;
-  return run.split('/').every((part: string) => part.length < 32);
+  return run.split('/').every((part        ) => part.length < 32);
 }
 
-function looksLikeSecretRun(run: string, minDigits: number): boolean {
+function looksLikeSecretRun(run        , minDigits        )          {
   const digits = (run.match(/[0-9]/g) || []).length;
   const upper = (run.match(/[A-Z]/g) || []).length;
   const lower = (run.match(/[a-z]/g) || []).length;
@@ -84,14 +84,14 @@ function looksLikeSecretRun(run: string, minDigits: number): boolean {
 const KEY_VALUE_40 = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{40}(?![A-Za-z0-9+/])/g;
 
 /** Masks the 40-character values inside a run that did not qualify as a whole. */
-function mask40(run: string, before: string | undefined): string {
-  return run.replace(KEY_VALUE_40, (value: string, index: number) => (
+function mask40(run        , before                    )         {
+  return run.replace(KEY_VALUE_40, (value        , index        ) => (
     looksLikeSecretRun(value, 1) && !isPathRun(value, index === 0 ? before : run[index - 1]) ? MASKED : value));
 }
 
-function isMasked(value: string): boolean { return value.replace(/^["']|["']$/g, '') === MASKED; }
+function isMasked(value        )          { return value.replace(/^["']|["']$/g, '') === MASKED; }
 
-function count(text: string, token: string): number { return text.split(token).length - 1; }
+function count(text        , token        )         { return text.split(token).length - 1; }
 
 /**
  * Masks `text` with a profile.
@@ -102,7 +102,7 @@ function count(text: string, token: string): number { return text.split(token).l
  * @returns {{text: string, masked: number}} `masked` counts the values replaced: the net growth in
  *   the number of `<masked>`, `<email>` and `<ip>` markers, so a value two rules both reach counts once
  */
-function mask(text: any, profile: 'line' | 'body', options: any = {}): { text: string; masked: number } {
+function mask(text     , profile                 , options      = {})                                   {
   if (profile !== 'line' && profile !== 'body') throw new TypeError(`unknown mask profile '${profile}'`);
   const input = text == null ? '' : String(text);
   let out = input;
@@ -119,33 +119,33 @@ function mask(text: any, profile: 'line' | 'body', options: any = {}): { text: s
   // 3. Bearer tokens and URL credentials.
   out = out.replace(BEARER, `$1$2${MASKED}`).replace(URL_CREDENTIALS, `://${MASKED}@`);
   // 4. Key=value, unquoted, when the value is not plain letters.
-  out = out.replace(KEY_VALUE_LINE, (match: string, key: string, separator: string, value: string) => (
+  out = out.replace(KEY_VALUE_LINE, (match        , key        , separator        , value        ) => (
     isMasked(value) || value.startsWith(MASKED) || !/[^A-Za-z]/.test(value) ? match : `${key}${separator}${MASKED}`));
   // 5. Long secret-looking runs that are not paths.
-  out = out.replace(LONG_RUN, (run: string, offset: number) => (
+  out = out.replace(LONG_RUN, (run        , offset        ) => (
     looksLikeSecretRun(run, 2) && !isPathRun(run, out[offset - 1]) ? MASKED : mask40(run, out[offset - 1])));
   // 6. Email addresses and IPv4 addresses.
   out = out.replace(EMAIL_ADDRESS, EMAIL).replace(IPV4, IP);
 
   if (profile === 'body') {
     // 7. Key and value, quoted or not, whatever the value looks like.
-    out = out.replace(KEY_VALUE_BODY, (match: string, head: string, value: string) => {
+    out = out.replace(KEY_VALUE_BODY, (match        , head        , value        ) => {
       if (isMasked(value) || value.startsWith(MASKED)) return match;
       const quote = value[0] === '"' || value[0] === "'" ? value[0] : '';
       return `${head}${quote}${MASKED}${quote}`;
     });
     // 8. Authorization headers: everything after the colon.
-    out = out.replace(AUTH_HEADER, (match: string, name: string, rest: string) => (rest === '' || rest === MASKED ? match : `${name} ${MASKED}`));
+    out = out.replace(AUTH_HEADER, (match        , name        , rest        ) => (rest === '' || rest === MASKED ? match : `${name} ${MASKED}`));
     // 9. Secret-bearing command-line flags.
-    out = out.replace(SECRET_FLAG, (match: string, flag: string, value: string) => (isMasked(value) ? match : `${flag}${MASKED}`));
+    out = out.replace(SECRET_FLAG, (match        , flag        , value        ) => (isMasked(value) ? match : `${flag}${MASKED}`));
   }
 
   const masked = Math.max(0, [MASKED, EMAIL, IP].reduce((sum, token) => sum + count(out, token) - count(input, token), 0));
   return { text: out, masked };
 }
 
-const maskLine = (text: any, options?: any) => mask(text, 'line', options);
-const maskBody = (text: any, options?: any) => mask(text, 'body', options);
+const maskLine = (text     , options      ) => mask(text, 'line', options);
+const maskBody = (text     , options      ) => mask(text, 'body', options);
 
 const ABSOLUTE_PATH = /(?<![A-Za-z0-9_.:/~-])(?:~(?![A-Za-z0-9_])\/?|\/)[^\s"'`<>:;,()[\]{}]*|[A-Za-z]:\\[^\s"'`<>:;,()[\]{}]*/g;
 
@@ -154,7 +154,7 @@ const ABSOLUTE_PATH = /(?<![A-Za-z0-9_.:/~-])(?:~(?![A-Za-z0-9_])\/?|\/)[^\s"'`<
  * @param {*} text
  * @returns {string}
  */
-function normalise(text: any): string {
+function normalise(text     )         {
   let out = text == null ? '' : String(text);
   out = out.replace(ABSOLUTE_PATH, '<path>');                                          // 10
   out = out.replace(/"[^"]*"|(?<![A-Za-z0-9])'[^']*'|`[^`]*`/g, '"..."');              // 11
@@ -168,7 +168,7 @@ function normalise(text: any): string {
  * a path with a long mixed-case segment would otherwise be masked by rule 5 as `<masked>` while a
  * short one becomes `<path>`.
  */
-function normaliseMessage(text: any, options?: any): string {
+function normaliseMessage(text     , options      )         {
   const paths = (text == null ? '' : String(text)).replace(ABSOLUTE_PATH, '<path>');
   return normalise(maskLine(paths, options).text);
 }
@@ -193,14 +193,14 @@ const REPLACEMENT = '\uFFFD';
  * @param {{keepLineBreaks?: boolean}} [options]
  * @returns {T}
  */
-function printSafe(value: any, options: { keepLineBreaks?: boolean } = {}): any {
+function printSafe(value     , options                               = {})      {
   if (typeof value === 'string') {
     const spaced = options.keepLineBreaks ? value : value.replace(PRINT_LINE_BREAK, ' ');
     return spaced.replace(PRINT_CONTROL, REPLACEMENT);
   }
-  if (Array.isArray(value)) return value.map((item: any) => printSafe(item, options));
+  if (Array.isArray(value)) return value.map((item     ) => printSafe(item, options));
   if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
-    const out: Record<string, any> = {};
+    const out                      = {};
     for (const key of Object.keys(value)) out[key] = printSafe(value[key], options);
     return out;
   }

package/src/runtime/{mcp-consultations.ts → mcp-consultations.js}

@@ -20,7 +20,7 @@ const OUTCOME_STATES = Object.freeze(['consulted-used', 'consulted-nothing-usabl
 
 /** Five distinct labels (NFR-007). `no-outcome` is derived, never stored. A skipped outcome's
  * text surfaces append its reason: see `outcomeLabel`. */
-const OUTCOME_LABELS: Readonly<Record<string, string>> = Object.freeze({
+const OUTCOME_LABELS                                   = Object.freeze({
   'consulted-used': 'consulted, used',
   'consulted-nothing-usable': 'consulted, nothing usable',
   skipped: 'skipped',
@@ -28,7 +28,7 @@ const OUTCOME_LABELS: Readonly<Record<string, string>> = Object.freeze({
   'no-outcome': 'no outcome recorded',
 });
 
-const FLAG_TOKEN_STATE: Readonly<Record<string, string>> = Object.freeze({
+const FLAG_TOKEN_STATE                                   = Object.freeze({
   used: 'consulted-used',
   'nothing-usable': 'consulted-nothing-usable',
   unavailable: 'unavailable',
@@ -41,11 +41,11 @@ const CONTENT_LIMIT = 500;
 const SCHEMA = 1;
 
 // used > nothing usable > unavailable > skipped (IC-008 rule 2).
-const PRECEDENCE: Readonly<Record<string, number>> = Object.freeze({
+const PRECEDENCE                                   = Object.freeze({
   'consulted-used': 4, 'consulted-nothing-usable': 3, unavailable: 2, skipped: 1,
 });
 
-function outcomeLabel(outcome: any): string {
+function outcomeLabel(outcome     )         {
   const label = OUTCOME_LABELS[outcome.state];
   return outcome.state === 'skipped' && outcome.reason ? `${label}: ${outcome.reason}` : label;
 }
@@ -54,7 +54,7 @@ function outcomeLabel(outcome: any): string {
  * Parse one outcome token (IC-005 flag token). Returns `{ state, reason? }` or `{ error }`.
  * @param {string} token
  */
-function parseOutcomeToken(token: any): any {
+function parseOutcomeToken(token     )      {
   const text = String(token ?? '').trim();
   if (Object.hasOwn(FLAG_TOKEN_STATE, text)) return { state: FLAG_TOKEN_STATE[text] };
   if (text === 'skipped' || text === 'skipped:') return { error: 'skipped needs a reason: skipped:<reason>' };
@@ -72,10 +72,10 @@ function parseOutcomeToken(token: any): any {
  * @param {string[]|string|undefined} values
  * @returns {{ outcomes: Map<string, {state: string, reason?: string}>, ignored: Array<{value: string, reason: string}> }}
  */
-function parseMcpOutcomeFlags(values?: string[] | string | null): { outcomes: Map<string, any>; ignored: Array<{ value: string; reason: string }> } {
-  const list: any[] = values === undefined || values === null ? [] : ([] as any[]).concat(values);
-  const outcomes = new Map<string, any>();
-  const ignored: Array<{ value: string; reason: string }> = [];
+function parseMcpOutcomeFlags(values                           )                                                                                    {
+  const list        = values === undefined || values === null ? [] : ([]         ).concat(values);
+  const outcomes = new Map             ();
+  const ignored                                           = [];
   for (const raw of list) {
     const value = String(raw);
     const at = value.indexOf('=');
@@ -94,7 +94,7 @@ function parseMcpOutcomeFlags(values?: string[] | string | null): { outcomes: Ma
 
 /** Strip a leading `- `, `**...**` emphasis and a line-wide pair of backticks, so
  * `- **Tools used:** a` and `` `Tools used: a` `` both read as `Tools used: a`. */
-function plainLine(line: string): string {
+function plainLine(line        )         {
   let text = line.trim().replace(/^-\s+/, '');
   if (text.startsWith('**')) text = text.slice(2).replace('**', '');
   if (text.startsWith('`Tools used:') && text.endsWith('`')) text = text.slice(1, -1);
@@ -102,8 +102,8 @@ function plainLine(line: string): string {
 }
 
 /** Split on commas outside parentheses, so a note like `(a, b)` stays with its entry. */
-function splitEntries(body: string): string[] {
-  const pieces: string[] = [];
+function splitEntries(body        )           {
+  const pieces           = [];
   let depth = 0;
   let current = '';
   for (const char of body) {
@@ -116,7 +116,7 @@ function splitEntries(body: string): string[] {
 }
 
 /** One entry with a trailing ` (note)` and a surrounding pair of backticks removed. */
-function plainEntry(piece: string): string {
+function plainEntry(piece        )         {
   let text = piece.trim().replace(/\s+\([^()]*\)$/, '').trim();
   if (text.length > 1 && text.startsWith('`') && text.endsWith('`')) text = text.slice(1, -1).trim();
   return text;
@@ -127,7 +127,7 @@ function plainEntry(piece: string): string {
  * @param {string} text report text
  * @returns {null | { line: number, raw: string, entries: Array<{name: string, state?: string, reason?: string, raw: string, valid: boolean}> }}
  */
-function parseToolsUsed(text: any): any {
+function parseToolsUsed(text     )      {
   const lines = String(text ?? '').split('\n');
   let found = -1;
   for (let i = 0; i < lines.length; i += 1) {
@@ -136,7 +136,7 @@ function parseToolsUsed(text: any): any {
   if (found === -1) return null;
   const raw = lines[found].replace(/\s+$/, '').trim();
   const body = plainLine(lines[found]).slice('Tools used:'.length).trim();
-  const entries: any[] = [];
+  const entries        = [];
   if (body !== '' && body !== 'none') {
     for (const piece of splitEntries(body)) {
       const entry = plainEntry(piece);
@@ -154,9 +154,9 @@ function parseToolsUsed(text: any): any {
 }
 
 /** Server ids the registry knows: `mcp` servers plus every provider's `mcp.server`. */
-function knownServerIds(registry: any): Set<string> {
-  const ids = new Set<string>((registry?.mcp || []).map((server: any) => server.id));
-  for (const capability of Object.values(registry?.capabilities || {}) as any[]) {
+function knownServerIds(registry     )              {
+  const ids = new Set        ((registry?.mcp || []).map((server     ) => server.id));
+  for (const capability of Object.values(registry?.capabilities || {})         ) {
     for (const provider of capability?.providers || []) {
       if (provider?.mcp?.server) ids.add(provider.mcp.server);
     }
@@ -168,17 +168,17 @@ function knownServerIds(registry: any): Set<string> {
  * Servers a stage run names (IC-001 meaning). Sorted.
  * @param {{registry: object, skill: string, stageId?: string, taskId?: string, requests?: {list: Function}}} input
  */
-function namedServers({ registry, skill, stageId, taskId, requests }: any): string[] {
-  let researchRequested: boolean | undefined;
-  const hasRequest = (): boolean => {
+function namedServers({ registry, skill, stageId, taskId, requests }     )           {
+  let researchRequested                     ;
+  const hasRequest = ()          => {
     if (researchRequested === undefined) {
-      let list: any = [];
+      let list      = [];
       try { list = requests && taskId ? requests.list(taskId) : []; } catch { list = []; }
-      researchRequested = Array.isArray(list) && list.some((request: any) => request && request.stageId === stageId);
+      researchRequested = Array.isArray(list) && list.some((request     ) => request && request.stageId === stageId);
     }
     return researchRequested;
   };
-  const named = new Set<string>();
+  const named = new Set        ();
   for (const server of registry?.mcp || []) {
     for (const step of server.steps || []) {
       if (step.expectedWhen === 'research-request') {
@@ -191,7 +191,7 @@ function namedServers({ registry, skill, stageId, taskId, requests }: any): stri
   return [...named].sort();
 }
 
-const bySortKey = (a: any, b: any): number => (a < b ? -1 : a > b ? 1 : 0);
+const bySortKey = (a     , b     )         => (a < b ? -1 : a > b ? 1 : 0);
 
 /**
  * Resolve a stage run's MCP consultations (IC-008).
@@ -213,11 +213,11 @@ const bySortKey = (a: any, b: any): number => (a < b ? -1 : a > b ? 1 : 0);
 function resolveConsultations({
   taskId = null, stageId = null, skill, flags, registry, ledger, requests,
   briefRecords = [], readReport, reach, addCommand, harnessName, since = null,
-}: any = {}): { record: any; warnings: any[]; notices: any[]; evidenceToAdd: any[] } {
-  const warnings: any[] = [];
-  const notices: any[] = [];
-  const evidenceToAdd: any[] = [];
-  const registered = new Set((registry?.mcp || []).map((server: any) => server.id));
+}      = {})                                                                         {
+  const warnings        = [];
+  const notices        = [];
+  const evidenceToAdd        = [];
+  const registered = new Set((registry?.mcp || []).map((server     ) => server.id));
   const known = knownServerIds(registry);
   const named = namedServers({ registry, skill, stageId, taskId, requests });
 
@@ -232,28 +232,28 @@ function resolveConsultations({
 
   // Rule 2: Tools used lines in the reports of this run's briefs. Records with no stage are never
   // ingested (design A6).
-  const toolsUsed: any[] = [];
-  const fromReports = new Map<string, any[]>();
+  const toolsUsed        = [];
+  const fromReports = new Map               ();
   const records = (Array.isArray(briefRecords) ? briefRecords : [])
-    .filter((record: any) => record && stageId && taskId && record.stage === stageId && record.runTaskId === taskId);
-  const reports: Array<{ id: string; report: string }> = [];
+    .filter((record     ) => record && stageId && taskId && record.stage === stageId && record.runTaskId === taskId);
+  const reports                                        = [];
   for (const record of records) {
     for (const task of record.tasks || []) {
       if (task && typeof task.id === 'string' && typeof task.report === 'string') reports.push({ id: task.id, report: task.report });
     }
   }
   reports.sort((a, b) => bySortKey(a.id, b.id) || bySortKey(a.report, b.report));
-  const existing = new Map<string, any[]>();
-  const existingFor = (id: string): any[] => {
+  const existing = new Map               ();
+  const existingFor = (id        )        => {
     if (!existing.has(id)) {
-      let items: any[] = [];
+      let items        = [];
       try { items = ledger ? ledger.queryEvidence({ taskId: id }) : []; } catch { items = []; }
-      existing.set(id, items.filter((item: any) => item && item.status === 'active'));
+      existing.set(id, items.filter((item     ) => item && item.status === 'active'));
     }
-    return existing.get(id) as any[];
+    return existing.get(id)         ;
   };
   for (const { id, report } of reports) {
-    let text: any = null;
+    let text      = null;
     try { text = typeof readReport === 'function' ? readReport(report) : null; } catch { text = null; }
     if (typeof text !== 'string') {
       toolsUsed.push({ taskId: id, status: 'no-report', report });
@@ -274,9 +274,9 @@ function resolveConsultations({
     }
     const source = { provider: 'dispatched-agent', capability: 'tools-used' };
     const content = parsed.raw.slice(0, CONTENT_LIMIT);
-    const duplicate = existingFor(id).find((item: any) => item.source?.provider === source.provider
+    const duplicate = existingFor(id).find((item     ) => item.source?.provider === source.provider
       && item.source?.capability === source.capability && item.content === content);
-    const inBatch = evidenceToAdd.some((item: any) => item.taskId === id && item.content === content);
+    const inBatch = evidenceToAdd.some((item     ) => item.taskId === id && item.content === content);
     if (duplicate) {
       toolsUsed.push({ taskId: id, status: 'already-recorded', evidenceId: duplicate.id });
     } else if (inBatch) {
@@ -301,10 +301,10 @@ function resolveConsultations({
 
   // Rule 3: evidence attributed to a server by `source.provider`, observed during this stage run:
   // after `since` (the previous stage's completion or the run start) when the caller knows it.
-  const evidenceServers = new Set<string>();
-  const inThisStage = (item: any): boolean => since === null || (typeof item.freshness?.observedAt === 'string' && item.freshness.observedAt > since);
+  const evidenceServers = new Set        ();
+  const inThisStage = (item     )          => since === null || (typeof item.freshness?.observedAt === 'string' && item.freshness.observedAt > since);
   if (ledger && taskId) {
-    let items: any[] = [];
+    let items        = [];
     try { items = ledger.queryEvidence({ taskId }); } catch { items = []; }
     for (const item of items) {
       if (item && item.status === 'active' && known.has(item.source?.provider) && inThisStage(item)) evidenceServers.add(item.source.provider);
@@ -313,8 +313,8 @@ function resolveConsultations({
 
   // Rule 4: a brief record for this stage that expected the server and found it unreachable. The
   // brief writes `unreachable` only where every config the harness merges was read (IC-017).
-  const unreachable = new Map<string, any>();
-  const reachableOn = new Map<string, any>();
+  const unreachable = new Map             ();
+  const reachableOn = new Map             ();
   for (const record of records) {
     for (const expected of record.expected || []) {
       if (!expected || typeof expected.server !== 'string') continue;
@@ -324,16 +324,16 @@ function resolveConsultations({
   }
 
   /** Who has a server the run asserted unavailable: the brief's harness, else an installed one. */
-  const nameOf = (id: any): string => (typeof harnessName === 'function' && harnessName(id)) || id;
-  const contradiction = (server: string): string | null => {
+  const nameOf = (id     )         => (typeof harnessName === 'function' && harnessName(id)) || id;
+  const contradiction = (server        )                => {
     if (reachableOn.has(server)) {
       const id = reachableOn.get(server);
       return id ? nameOf(id) : 'an installed harness';
     }
-    let has: any = null;
+    let has      = null;
     try { has = reach && typeof reach.anyHarnessHas === 'function' ? reach.anyHarnessHas(server) : null; } catch { has = null; }
     if (has !== true) return null;
-    let name: any = null;
+    let name      = null;
     try { name = typeof reach.harnessWith === 'function' ? reach.harnessWith(server) : null; } catch { name = null; }
     return name || 'an installed harness';
   };
@@ -341,14 +341,14 @@ function resolveConsultations({
   const candidates = new Set([
     ...named, ...parsedFlags.outcomes.keys(), ...fromReports.keys(), ...evidenceServers, ...unreachable.keys(),
   ]);
-  const outcomes: any[] = [];
+  const outcomes        = [];
   for (const server of [...candidates].sort()) {
-    let outcome: any = null;
+    let outcome      = null;
     const flag = parsedFlags.outcomes.get(server);
     if (flag) {
       outcome = { server, state: flag.state, ...(flag.reason ? { reason: flag.reason } : {}), source: 'flag' };
     } else if (fromReports.has(server)) {
-      const best = (fromReports.get(server) as any[]).reduce((a: any, b: any) => (PRECEDENCE[b.state] > PRECEDENCE[a.state] ? b : a));
+      const best = (fromReports.get(server)         ).reduce((a     , b     ) => (PRECEDENCE[b.state] > PRECEDENCE[a.state] ? b : a));
       outcome = {
         server, state: best.state, ...(best.reason ? { reason: best.reason } : {}), source: 'tools-used', taskId: best.taskId,
       };

package/src/runtime/{mcp-reach.ts → mcp-reach.js}

@@ -17,16 +17,16 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { readLedger } = require('../state/index.ts');
-const { resolveAdapter } = require('../adapters/index.ts');
-const { evaluateReach } = require('./reach.ts');
+const { readLedger } = require('../state/index.js');
+const { resolveAdapter } = require('../adapters/index.js');
+const { evaluateReach } = require('./reach.js');
 
-const SCOPE_ORDER: Record<string, number> = { project: 0, global: 1 };
+const SCOPE_ORDER                         = { project: 0, global: 1 };
 
 /** Every server id the answer covers: the MCP catalog, then each provider's own MCP server. */
-function serverIdsOf(registry: any) {
-  const ids = (registry.mcp || []).map((server: any) => server.id);
-  for (const capability of (Object.values(registry.capabilities || {}) as any[])) {
+function serverIdsOf(registry     ) {
+  const ids = (registry.mcp || []).map((server     ) => server.id);
+  for (const capability of (Object.values(registry.capabilities || {})         )) {
     for (const provider of capability.providers || []) if (provider.mcp?.server) ids.push(provider.mcp.server);
   }
   return [...new Set(ids)];
@@ -34,16 +34,16 @@ function serverIdsOf(registry: any) {
 
 /** The MCP file an adapter's discovery could not read and the fixed reason it gives, or null.
  * Reasons come from the adapters (invalid JSON, wrong shape), never from file content. */
-function unreadableDetail(discovery: any) {
-  for (const [file, read] of (Object.entries(discovery.mcpSnapshot || {}) as [string, any][])) if (read?.ok === false) return { detail: read.reason, file };
-  for (const [file, read] of (Object.entries(discovery.mcp || {}) as [string, any][])) if (read?.doc?.ok === false) return { detail: read.doc.reason, file };
+function unreadableDetail(discovery     ) {
+  for (const [file, read] of (Object.entries(discovery.mcpSnapshot || {})                   )) if (read?.ok === false) return { detail: read.reason, file };
+  for (const [file, read] of (Object.entries(discovery.mcp || {})                   )) if (read?.doc?.ok === false) return { detail: read.doc.reason, file };
   if (discovery.settings?.error) return { detail: 'invalid JSON', ...(discovery.paths?.settings ? { file: discovery.paths.settings } : {}) };
   return null;
 }
 
 /** A server is absent (`not-taken`, `not-selected`) only where the adapter read every source its
  * harness merges (`mcpComplete: true`); anywhere else absence is no proof and the state is unknown. */
-function stateOf(row: any, id: any) {
+function stateOf(row     , id     ) {
   if (row.selected.has(id)) return 'selected';
   if (row.configured?.includes(id)) return 'configured';
   if (row.unreadable || row.configured === null || !row.complete) return 'unknown';
@@ -59,14 +59,14 @@ function stateOf(row: any, id: any) {
  * @param {Object} options.adapters adapter registry (`buildAdapterRegistry()`)
  * @returns {{harnesses: Object[], unreadable: Object[]}} plain data; `anyHarnessHas` and `addCommand` ride along unenumerated
  */
-function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs, adapters }: any) {
+function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs, adapters }     ) {
   const serverIds = serverIdsOf(registry);
-  const catalogIds = (registry.mcp || []).map((server: any) => server.id);
-  const harnessOrder = registry.harnesses.map((harness: any) => harness.id);
+  const catalogIds = (registry.mcp || []).map((server     ) => server.id);
+  const harnessOrder = registry.harnesses.map((harness     ) => harness.id);
   const { rows: reached } = evaluateReach({ registry, projectRoot, homeDir, fsImpl });
 
   const ledgers = new Map();
-  const ledgerOf = ({ scope, installRoot }: any) => {
+  const ledgerOf = ({ scope, installRoot }     ) => {
     const key = `${scope}\0${installRoot}`;
     if (!ledgers.has(key)) {
       let ledger = null;
@@ -78,12 +78,12 @@ function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs,
 
   const unreadable = [];
   const seen = new Set();
-  const rows: any[] = [];
+  const rows        = [];
   for (const { harness: id, scope, installRoot } of reached) {
     const key = `${id}\0${scope}\0${installRoot}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    const harness = registry.harnesses.find((item: any) => item.id === id);
+    const harness = registry.harnesses.find((item     ) => item.id === id);
     const ledger = ledgerOf({ scope, installRoot });
     const mcp = harness.capabilities?.mcp;
     const row = {
@@ -91,7 +91,7 @@ function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs,
       catalog: mcp?.status === 'supported' ? 'taken' : 'not-taken',
       note: mcp?.note ?? mcp?.verification,
       selected: new Set((ledger?.resources || [])
-        .filter((resource: any) => resource.harness === id && resource.kind === 'mcp-server').map((resource: any) => resource.identity)),
+        .filter((resource     ) => resource.harness === id && resource.kind === 'mcp-server').map((resource     ) => resource.identity)),
       configured: null,
       complete: false,
       unreadable: false,
@@ -104,7 +104,7 @@ function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs,
       row.complete = discovery.mcpComplete === true;
       const found = unreadableDetail(discovery);
       if (found) { row.unreadable = true; unreadable.push({ harness: id, scope, ...found }); }
-    } catch (error: any) {
+    } catch (error     ) {
       row.unreadable = true;
       unreadable.push({ harness: id, scope, detail: error.message });
     }
@@ -115,7 +115,7 @@ function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs,
 
   const result = {
     harnesses: rows.map((row) => {
-      const entry: any = { id: row.id, scope: row.scope, catalog: row.catalog };
+      const entry      = { id: row.id, scope: row.scope, catalog: row.catalog };
       if (row.catalog === 'not-taken' && row.note) entry.note = row.note;
       entry.servers = Object.fromEntries(serverIds.map((server) => [server, stateOf(row, server)]));
       return entry;
@@ -126,15 +126,15 @@ function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs,
   /** `true` when a server is selected or configured on some installed harness, `false` only when
    * every installed harness read every source it merges and says it is absent, `null` (unknown)
    * otherwise, including when none is installed. */
-  const anyHarnessHas = (server: any) => {
+  const anyHarnessHas = (server     ) => {
     const states = rows.map((row) => stateOf(row, server));
     if (states.some((state) => state === 'selected' || state === 'configured')) return true;
     return states.length > 0 && states.every((state) => state === 'not-selected' || state === 'not-taken') ? false : null;
   };
 
   /** The command that adds `serverId` for a harness at a scope, or where to configure it by hand. */
-  const addCommand = (harnessId: any, scope: any, serverId: any) => {
-    const harness = registry.harnesses.find((item: any) => item.id === harnessId);
+  const addCommand = (harnessId     , scope     , serverId     ) => {
+    const harness = registry.harnesses.find((item     ) => item.id === harnessId);
     const name = harness?.displayName || harnessId;
     if (harness?.capabilities?.mcp?.status !== 'supported') {
       return `configure it in ${name}'s own MCP settings; DoFlow's catalog does not reach it`;
@@ -144,7 +144,7 @@ function mcpReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs,
     }
     const chosen = new Set([serverId]);
     for (const row of rows) if (row.id === harnessId && row.scope === scope) for (const id of row.selected) chosen.add(id);
-    return `doflow install${scope === 'global' ? ' -g' : ''} --target ${harnessId} --mcp ${catalogIds.filter((id: any) => chosen.has(id)).join(',')}`;
+    return `doflow install${scope === 'global' ? ' -g' : ''} --target ${harnessId} --mcp ${catalogIds.filter((id     ) => chosen.has(id)).join(',')}`;
   };
 
   Object.defineProperties(result, {