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

package/src/release/build-package.js

@@ -0,0 +1,91 @@
+'use strict';
+
+// Build the JavaScript form published to npm in an isolated staging directory. The checkout stays
+// TypeScript so local development and the source CLI keep using Node's native type stripping.
+const fs = require('node:fs');
+const path = require('node:path');
+const { stripTypeScriptTypes } = require('node:module');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+
+const TEXT_EXTENSIONS = new Set(['.js', '.json', '.sh', '.md', '.yaml', '.yml']);
+
+function walkFiles(root        )           {
+  const files           = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const file = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...walkFiles(file));
+    else if (entry.isFile()) files.push(file);
+  }
+  return files;
+}
+
+function buildPackage(outDir        , { repoRoot = REPO_ROOT }                        = {})         {
+  if (typeof stripTypeScriptTypes !== 'function') {
+    throw new Error('Node does not provide node:module.stripTypeScriptTypes');
+  }
+  const packageJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+  const output = path.resolve(outDir);
+  fs.rmSync(output, { recursive: true, force: true });
+  fs.mkdirSync(output, { recursive: true });
+
+  for (const rel of packageJson.files || []) {
+    const source = path.join(repoRoot, rel);
+    if (fs.existsSync(source)) fs.cpSync(source, path.join(output, rel), { recursive: true });
+  }
+  for (const name of ['package.json', 'README.md', 'LICENSE', 'CHANGELOG.md']) {
+    const source = path.join(repoRoot, name);
+    if (fs.existsSync(source)) fs.copyFileSync(source, path.join(output, name));
+  }
+
+  const converted = new Set        ();
+  for (const file of walkFiles(path.join(output, 'src'))) {
+    if (!file.endsWith('.ts') || file.endsWith('.d.ts')) continue;
+    const relative = path.relative(output, file).split(path.sep).join('/');
+    const jsRelative = relative.slice(0, -3) + '.js';
+    const code = fs.readFileSync(file, 'utf8');
+    fs.writeFileSync(path.join(output, jsRelative), stripTypeScriptTypes(code, { mode: 'strip' }));
+    fs.rmSync(file);
+    converted.add(relative);
+  }
+
+  for (const file of walkFiles(output)) {
+    if (!TEXT_EXTENSIONS.has(path.extname(file))) continue;
+    const relative = path.relative(output, file).split(path.sep).join('/');
+    let content = fs.readFileSync(file, 'utf8');
+    content = content.replace(/(['"`])((?:\.\.?\/)[^'"`\n]*?\.ts)\1/g, (whole        , quote        , specifier        ) => {
+      const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(relative), specifier));
+      if (!converted.has(resolved)) return whole;
+      return `${quote}${specifier.slice(0, -3)}.js${quote}`;
+    });
+    for (const rel of [...converted].sort((a, b) => b.length - a.length)) {
+      content = content.split(rel).join(rel.slice(0, -3) + '.js');
+    }
+    fs.writeFileSync(file, content);
+  }
+
+  const remaining = walkFiles(output);
+  const runtimeFiles = ['src', 'bin'].flatMap((directory) => {
+    const root = path.join(output, directory);
+    return fs.existsSync(root) ? walkFiles(root) : [];
+  });
+  const nonDeclarationTs = runtimeFiles.filter((file        ) => file.endsWith('.ts') && !file.endsWith('.d.ts'));
+  if (nonDeclarationTs.length) throw new Error(`staged package retains TypeScript files: ${nonDeclarationTs.join(', ')}`);
+  for (const file of remaining) {
+    if (!TEXT_EXTENSIONS.has(path.extname(file))) continue;
+    const content = fs.readFileSync(file, 'utf8');
+    const unresolved = [...converted].filter((rel) => content.includes(rel));
+    if (unresolved.length) throw new Error(`${path.relative(output, file)} still references converted TypeScript paths: ${unresolved.join(', ')}`);
+  }
+  return output;
+}
+
+if (require.main === module) {
+  const outDir = process.argv[2];
+  if (!outDir) {
+    process.stderr.write('Usage: node src/release/build-package.js <outDir>\n');
+    process.exit(2);
+  }
+  buildPackage(outDir);
+}
+
+module.exports = { buildPackage };

package/src/release/changelog-section.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+// ── One release version, one CHANGELOG section, one GitHub Release body ─────────────────────────
+//
+// `gh release create --generate-notes` lists merged pull requests, and this repository merges
+// locally, so every Release the workflow created carried only a compare link. CHANGELOG.md is
+// where the release text is already written (Keep a Changelog, one `## [X.Y.Z]` heading per
+// version), so the release workflow extracts the tagged version's section from it and passes that
+// as the Release body. A tag whose section is missing or empty fails the job instead of
+// publishing an empty Release.
+//
+// Usage: node src/release/changelog-section.js <version|tag> [CHANGELOG path]
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+
+function escapeRegExp(text        )         {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Returns the body of a version's section: the lines after its `## [version]` heading up to the
+ * next `## [` heading, trimmed. The closing `]` after the version makes 1.2.1 and 1.2.10 distinct.
+ * A leading `v` on the version is ignored. Returns null when the heading is absent or the body is
+ * empty.
+ * @param {string} changelogText
+ * @param {string} version
+ * @returns {string|null}
+ */
+function changelogSection(changelogText        , version        )                {
+  const wanted = String(version).trim().replace(/^v/, '');
+  if (wanted === '') return null;
+  const lines = changelogText.split(/\r?\n/);
+  const heading = new RegExp(`^##\\s+\\[${escapeRegExp(wanted)}\\](\\s|$)`);
+  const start = lines.findIndex((line) => heading.test(line));
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^##\s+\[/.test(lines[i])) { end = i; break; }
+  }
+  const body = lines.slice(start + 1, end).join('\n').trim();
+  return body === '' ? null : body;
+}
+
+if (require.main === module) {
+  const version = process.argv[2];
+  const file = process.argv[3] || path.join(REPO_ROOT, 'CHANGELOG.md');
+  if (!version) {
+    console.error('usage: node src/release/changelog-section.js <version|tag> [CHANGELOG path]');
+    process.exit(1);
+  }
+  let text        ;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (err) {
+    console.error(`cannot read ${file}: ${(err         ).message}`);
+    process.exit(1);
+  }
+  const body = changelogSection(text, version);
+  if (body === null) {
+    console.error(`no non-empty CHANGELOG section for ${String(version).replace(/^v/, '')} in ${file}`);
+    process.exit(1);
+  }
+  process.stdout.write(`${body}\n`);
+}
+
+module.exports = { changelogSection };

package/src/release/{sync-plugin-versions.ts → sync-plugin-versions.js}

@@ -14,7 +14,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 /** Every distribution manifest that repeats the release version, relative to the repo root. */
 const PLUGIN_MANIFESTS = [
@@ -31,14 +31,14 @@ const PLUGIN_MANIFESTS = [
  * @param {Object} [options.fsImpl]
  * @returns {{version: string, updated: Array<string>, unchanged: Array<string>}}
  */
-function syncPluginVersions({ repoRoot = REPO_ROOT, fsImpl = fs }: { repoRoot?: string, fsImpl?: any } = {}): { version: string, updated: string[], unchanged: string[] } {
+function syncPluginVersions({ repoRoot = REPO_ROOT, fsImpl = fs }                                      = {})                                                              {
   const pkg = JSON.parse(fsImpl.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
   if (typeof pkg.version !== 'string' || pkg.version.trim() === '') {
     throw new Error('package.json declares no version to project');
   }
 
-  const updated: string[] = [];
-  const unchanged: string[] = [];
+  const updated           = [];
+  const unchanged           = [];
   for (const rel of PLUGIN_MANIFESTS) {
     const file = path.join(repoRoot, rel);
     const text = fsImpl.readFileSync(file, 'utf8');

package/src/runtime/advice/{cli.ts → cli.js}

@@ -4,19 +4,19 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { finishRuntime, usageError } = require('../cli-result.ts');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
-const { loadAdviceRegistry } = require('./registry.ts');
-const { loadStorageRegistry } = require('../storage/registry.ts');
-const { resolveRoots } = require('../storage/roots.ts');
-const { resolveSetting, writeSetting } = require('./config.ts');
-const { createAdviceClient } = require('./client.ts');
-const { materializeKind, validateQuestionSet, validateStaticAnswer } = require('./kinds.ts');
-const { findPick, appendOutcome } = require('./record.ts');
-const { strengthWords } = require('./strength.ts');
+const { finishRuntime, usageError } = require('../cli-result.js');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { loadAdviceRegistry } = require('./registry.js');
+const { loadStorageRegistry } = require('../storage/registry.js');
+const { resolveRoots } = require('../storage/roots.js');
+const { resolveSetting, writeSetting } = require('./config.js');
+const { createAdviceClient } = require('./client.js');
+const { materializeKind, validateQuestionSet, validateStaticAnswer } = require('./kinds.js');
+const { findPick, appendOutcome } = require('./record.js');
+const { strengthWords } = require('./strength.js');
 
-function loadSources(repoRoot: any) {
-  const read = (name: any) => JSON.parse(fs.readFileSync(path.join(repoRoot, 'core/registry', name), 'utf8'));
+function loadSources(repoRoot     ) {
+  const read = (name     ) => JSON.parse(fs.readFileSync(path.join(repoRoot, 'core/registry', name), 'utf8'));
   return {
     workflows: read('workflows.json'),
     verification: read('verification.json'),
@@ -24,7 +24,7 @@ function loadSources(repoRoot: any) {
   };
 }
 
-function loadRuntime({ projectRoot, global = false }: any = {}) {
+function loadRuntime({ projectRoot, global = false }      = {}) {
   const advice = loadAdviceRegistry({ repoRoot: REPO_ROOT });
   const storage = loadStorageRegistry({ repoRoot: REPO_ROOT });
   const roots = resolveRoots({ registry: storage, projectRoot, global });
@@ -33,7 +33,7 @@ function loadRuntime({ projectRoot, global = false }: any = {}) {
   return { adviceRegistry, adviceError: advice.ok ? null : advice.detail, storage, roots, sources };
 }
 
-function emitResult(result: any, { json, kind }: any) {
+function emitResult(result     , { json, kind }     ) {
   if (result.reason === 'over-limit') {
     return usageError('advise', result.detail || 'request exceeds an advice limit', json);
   }
@@ -50,11 +50,11 @@ function emitResult(result: any, { json, kind }: any) {
   return finishRuntime(0);
 }
 
-function isPresent(value: any) {
+function isPresent(value     ) {
   return value !== undefined && value !== null;
 }
 
-function readState({ state, stateFile, json }: any) {
+function readState({ state, stateFile, json }     ) {
   if (isPresent(state) === isPresent(stateFile)) {
     usageError('advise', 'provide exactly one of --state or --state-file', json);
     return null;
@@ -64,26 +64,26 @@ function readState({ state, stateFile, json }: any) {
     const content = fs.readFileSync(stateFile, 'utf8');
     if (!content.length) throw new Error('file is empty');
     return content;
-  } catch (error: any) {
+  } catch (error     ) {
     usageError('advise', `cannot read state file ${stateFile}: ${error.message}`, json);
     return null;
   }
 }
 
-function readQuestions(file: any, json: any) {
+function readQuestions(file     , json     ) {
   try {
     const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Array.isArray(parsed.questions)) {
       throw new Error('expected an object with a questions array');
     }
     return parsed.questions;
-  } catch (error: any) {
+  } catch (error     ) {
     usageError('advise', `cannot read questions file ${file}: ${error.message}`, json);
     return null;
   }
 }
 
-function parseAskInput(options: any) {
+function parseAskInput(options     ) {
   const hasKind = typeof options.kind === 'string' && options.kind.length > 0;
   const hasQuestionsFile = isPresent(options.questionsFile);
   if (hasKind === hasQuestionsFile) {
@@ -103,7 +103,7 @@ function parseAskInput(options: any) {
   return { state, hasKind, hasQuestionsFile };
 }
 
-function endpointSource(userSetting: any, endpoint: any) {
+function endpointSource(userSetting     , endpoint     ) {
   if (userSetting?.decidedBy?.user) {
     try {
       const file = JSON.parse(fs.readFileSync(userSetting.decidedBy.user, 'utf8'));
@@ -113,7 +113,7 @@ function endpointSource(userSetting: any, endpoint: any) {
   return 'provider default';
 }
 
-function inspectFailure(inspected: any, { endpoint, model, provider }: any) {
+function inspectFailure(inspected     , { endpoint, model, provider }     ) {
   if (inspected.endpoint.state === 'refused') return inspected.endpoint.message;
   if (inspected.endpoint.state !== 'reached') {
     return `advise: Ollama did not answer at ${endpoint}; start it yourself and re-run. Nothing was written.`;
@@ -126,21 +126,21 @@ function inspectFailure(inspected: any, { endpoint, model, provider }: any) {
   }
   if (!inspected.model.decisionCapable) {
     const capable = inspected.models
-      .filter((entry: any) => Array.isArray(entry.capabilities) && entry.capabilities.includes(provider.capability))
-      .map((entry: any) => entry.name);
+      .filter((entry     ) => Array.isArray(entry.capabilities) && entry.capabilities.includes(provider.capability))
+      .map((entry     ) => entry.name);
     return `advise: model ${model} is not decision-capable; decision-capable here: ${capable.length ? capable.join(', ') : 'none'}. Nothing was written.`;
   }
   return null;
 }
 
-function writeFailure(message: any, json: any) {
+function writeFailure(message     , json     ) {
   if (json) console.log(JSON.stringify({ ok: false, error: 'write-failed', message }, null, 2));
   else if (message.startsWith('decision model: endpoint ') || message.startsWith('advise:')) console.error(message);
   else console.error(`advise: ${message}`);
   return finishRuntime(1);
 }
 
-async function handleConfigure(options: any, runtime: any) {
+async function handleConfigure(options     , runtime     ) {
   const { adviceRegistry, adviceError, roots, sources } = runtime;
   const { json, project, global, force } = options;
   const hasModel = typeof options.model === 'string' && options.model.length > 0;
@@ -173,7 +173,7 @@ async function handleConfigure(options: any, runtime: any) {
     return writeFailure('turn the decision model on at user level first; a project cannot enable it', json);
   }
   const providerId = userSetting.provider || 'ollama';
-  const provider = adviceRegistry.providers.find((entry: any) => entry.id === providerId);
+  const provider = adviceRegistry.providers.find((entry     ) => entry.id === providerId);
   if (!provider) return writeFailure(`provider '${providerId}' is not in core/registry/advice.json`, json);
   const endpoint = project
     ? userSetting.endpoint
@@ -197,7 +197,7 @@ async function handleConfigure(options: any, runtime: any) {
   return finishRuntime(0);
 }
 
-async function handleAsk(options: any, runtime: any) {
+async function handleAsk(options     , runtime     ) {
   const parsed = parseAskInput(options);
   if (!parsed) return finishRuntime(2);
   const { adviceRegistry, adviceError, roots, sources } = runtime;
@@ -243,7 +243,7 @@ async function handleAsk(options: any, runtime: any) {
   return emitResult(result, { json: options.json, kind });
 }
 
-function handleOutcome(options: any, runtime: any) {
+function handleOutcome(options     , runtime     ) {
   const { json } = options;
   if (typeof options.pickId !== 'string' || !options.pickId) return usageError('advise', '--pick-id is required', json);
   if (typeof options.actual !== 'string' || !options.actual) return usageError('advise', '--actual is required', json);
@@ -265,7 +265,7 @@ function handleOutcome(options: any, runtime: any) {
   return finishRuntime(0);
 }
 
-async function handleAdviseCommand(options: any = {}) {
+async function handleAdviseCommand(options      = {}) {
   const action = options.actionGiven ? options.action : 'ask';
   if (!['ask', 'outcome', 'configure'].includes(action)) return usageError('advise', `unknown action '${action}'`, options.json);
   try {
@@ -275,7 +275,7 @@ async function handleAdviseCommand(options: any = {}) {
     if (action === 'configure') return await handleConfigure(shaped, runtime);
     if (action === 'outcome') return handleOutcome(shaped, runtime);
     return await handleAsk(shaped, runtime);
-  } catch (error: any) {
+  } catch (error     ) {
     return writeFailure(error?.message || 'advice command failed', options.json);
   }
 }

package/src/runtime/advice/{client.ts → client.js}

@@ -5,27 +5,27 @@
 const fs = require('node:fs');
 const http = require('node:http');
 const https = require('node:https');
-const { resolveSetting } = require('./config.ts');
-const { checkEndpoint } = require('./endpoint-guard.ts');
-const { strengthOf } = require('./strength.ts');
-const { validateQuestionSet, validateStaticAnswer } = require('./kinds.ts');
-const { appendPick, appendMiss } = require('./record.ts');
+const { resolveSetting } = require('./config.js');
+const { checkEndpoint } = require('./endpoint-guard.js');
+const { strengthOf } = require('./strength.js');
+const { validateQuestionSet, validateStaticAnswer } = require('./kinds.js');
+const { appendPick, appendMiss } = require('./record.js');
 
 // Keep this map literal: module reachability must be auditable without dynamic require paths.
-const ADAPTERS: Record<string, any> = Object.freeze({
-  'ollama-systemone': require('./providers/ollama-systemone.ts'),
+const ADAPTERS                      = Object.freeze({
+  'ollama-systemone': require('./providers/ollama-systemone.js'),
 });
 
-function durationSince(startedAt: any) {
+function durationSince(startedAt     ) {
   return Math.max(0, Date.now() - startedAt);
 }
 
-function versionTuple(version: any) {
+function versionTuple(version     ) {
   const match = typeof version === 'string' && version.match(/^v?(\d+)\.(\d+)\.(\d+)/);
   return match ? match.slice(1).map(Number) : null;
 }
 
-function versionAtLeast(version: any, minimum: any) {
+function versionAtLeast(version     , minimum     ) {
   const actual = versionTuple(version);
   const required = versionTuple(minimum);
   if (!actual || !required) return false;
@@ -36,16 +36,16 @@ function versionAtLeast(version: any, minimum: any) {
   return true;
 }
 
-function networkReason(error: any) {
+function networkReason(error     ) {
   return error?.code === 'ADVICE_TIMEOUT' || error?.code === 'ETIMEDOUT' || error?.code === 'ESOCKETTIMEDOUT'
     ? 'timeout' : 'unreachable';
 }
 
-function requestAction({ endpoint, action, pinnedLookup, timeoutMs, httpModule = http, httpsModule = https }: any) {
-  return new Promise<any>((resolve, reject) => {
-    let request: any;
+function requestAction({ endpoint, action, pinnedLookup, timeoutMs, httpModule = http, httpsModule = https }     ) {
+  return new Promise     ((resolve, reject) => {
+    let request     ;
     let settled = false;
-    const finish = (error: any, response?: any) => {
+    const finish = (error     , response      ) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -53,7 +53,7 @@ function requestAction({ endpoint, action, pinnedLookup, timeoutMs, httpModule =
       else resolve(response);
     };
     const timer = setTimeout(() => {
-      const error: any = new Error(`decision model request timed out after ${timeoutMs}ms`);
+      const error      = new Error(`decision model request timed out after ${timeoutMs}ms`);
       error.code = 'ADVICE_TIMEOUT';
       request?.destroy(error);
       finish(error);
@@ -78,25 +78,25 @@ function requestAction({ endpoint, action, pinnedLookup, timeoutMs, httpModule =
           'content-length': Buffer.byteLength(body),
         },
       };
-      request = transport.request(options, (response: any) => {
-        const chunks: any[] = [];
-        response.on('data', (chunk: any) => chunks.push(Buffer.from(chunk)));
-        response.on('error', (error: any) => finish(error));
+      request = transport.request(options, (response     ) => {
+        const chunks        = [];
+        response.on('data', (chunk     ) => chunks.push(Buffer.from(chunk)));
+        response.on('error', (error     ) => finish(error));
         response.on('end', () => finish(null, {
           status: response.statusCode || 0,
           bodyText: Buffer.concat(chunks).toString('utf8'),
         }));
       });
-      request.on('error', (error: any) => finish(error));
+      request.on('error', (error     ) => finish(error));
       if (body === undefined) request.end();
       else request.end(body);
-    } catch (error: any) {
+    } catch (error     ) {
       finish(error);
     }
   });
 }
 
-function emptyAdviceResult(status: any, reason: any, detail: any, setting: any, durationMs: any) {
+function emptyAdviceResult(status     , reason     , detail     , setting     , durationMs     ) {
   return {
     status, reason, detail: detail ?? null,
     provider: setting?.provider ?? null,
@@ -116,14 +116,14 @@ function createAdviceClient({
   httpModule = http,
   httpsModule = https,
   clock = () => new Date(),
-}: any = {}) {
-  async function ask({ questionSet, kind, staticAnswer, caller, taskId = null, record = true }: any = {}) {
+}      = {}) {
+  async function ask({ questionSet, kind, staticAnswer, caller, taskId = null, record = true }      = {}) {
     const startedAt = Date.now();
-    let setting: any = null;
+    let setting      = null;
     const effectiveKind = typeof kind === 'string' && kind ? kind : 'adhoc';
     const shouldRecord = record !== false;
 
-    function unavailable(reason: any, detail: any) {
+    function unavailable(reason     , detail     ) {
       const durationMs = durationSince(startedAt);
       if (shouldRecord && setting?.state === 'on') {
         try { appendMiss({ roots, now: clock, fsImpl, kind: effectiveKind, caller, reason, model: setting.model, durationMs }); }
@@ -138,12 +138,12 @@ function createAdviceClient({
         return emptyAdviceResult('off', setting.reason, setting.notes?.[0] || null, setting, durationSince(startedAt));
       }
 
-      const provider = adviceRegistry?.providers?.find((entry: any) => entry.id === setting.provider);
+      const provider = adviceRegistry?.providers?.find((entry     ) => entry.id === setting.provider);
       const adapter = provider && ADAPTERS[provider.adapter];
       if (!provider || !adapter) return unavailable('config-invalid', `provider adapter '${provider?.adapter || setting.provider}' is unavailable`);
 
       if (effectiveKind !== 'adhoc') {
-        const namedKind = adviceRegistry.kinds?.find((entry: any) => entry.id === effectiveKind);
+        const namedKind = adviceRegistry.kinds?.find((entry     ) => entry.id === effectiveKind);
         if (!namedKind || questionSet?.questions?.length !== 1 || questionSet.questions[0]?.name !== effectiveKind) {
           return unavailable('config-invalid', `question set does not match kind '${effectiveKind}'`);
         }
@@ -185,20 +185,20 @@ function createAdviceClient({
           httpModule,
           httpsModule,
         });
-      } catch (error: any) {
+      } catch (error     ) {
         const reason = networkReason(error);
         return unavailable(reason, error.message);
       }
 
       let parsed;
       try { parsed = adapter.parseReply(response.status, response.bodyText, questionSet); }
-      catch (error: any) { return unavailable('malformed-reply', error.message); }
+      catch (error     ) { return unavailable('malformed-reply', error.message); }
       if (!parsed?.ok) return unavailable(parsed?.reason || 'malformed-reply', parsed?.detail || 'reply could not be parsed');
 
-      const answers = parsed.answers.map((answer: any, index: any) => {
+      const answers = parsed.answers.map((answer     , index     ) => {
         const strength = strengthOf(answer, adviceRegistry.strength);
         const answerStatic = questionSet.questions.length === 1 ? staticAnswer ?? null : null;
-        const result: any = {
+        const result      = {
           name: answer.name,
           kind: effectiveKind,
           type: answer.type,
@@ -237,19 +237,19 @@ function createAdviceClient({
         provider: setting.provider, model: setting.model, endpoint: setting.endpoint,
         decidedBy: setting.decidedBy, durationMs: durationSince(startedAt), answers,
       };
-    } catch (error: any) {
+    } catch (error     ) {
       return unavailable('config-invalid', error?.message || 'advice request failed');
     }
   }
 
-  async function inspect({ endpoint, model, provider: providerId = 'ollama', file, minVersion, timeoutMs }: any = {}) {
-    const unavailable = (state: any, message: any, version: any = null, versionOk = false) => ({
+  async function inspect({ endpoint, model, provider: providerId = 'ollama', file, minVersion, timeoutMs }      = {}) {
+    const unavailable = (state     , message     , version      = null, versionOk = false) => ({
       endpoint: { state, version, versionOk, message: message ?? null },
       models: [],
       model: { installed: false, decisionCapable: false },
     });
     try {
-      const provider = adviceRegistry?.providers?.find((entry: any) => entry.id === providerId);
+      const provider = adviceRegistry?.providers?.find((entry     ) => entry.id === providerId);
       const adapter = provider && ADAPTERS[provider.adapter];
       if (!provider || !adapter) return unavailable('refused', `provider '${providerId}' is unavailable`);
       const probeLimit = Number.isFinite(timeoutMs) ? timeoutMs : adviceRegistry.probeTimeoutMs;
@@ -258,7 +258,7 @@ function createAdviceClient({
       const remaining = () => Math.max(0, budgetMs - (Date.now() - startedAt));
       const endpointCheck = await checkEndpoint(endpoint, { lookup, file, timeoutMs: remaining() });
       if (!endpointCheck.ok) return unavailable(endpointCheck.reason === 'timeout' ? 'unreachable' : 'refused', endpointCheck.message);
-      const requestProbe = (action: any) => {
+      const requestProbe = (action     ) => {
         const left = remaining();
         if (left <= 0) throw Object.assign(new Error('decision model probe budget exhausted'), { code: 'ADVICE_TIMEOUT' });
         return requestAction({
@@ -269,7 +269,7 @@ function createAdviceClient({
 
       let versionResponse;
       try { versionResponse = await requestProbe(adapter.versionRequest()); }
-      catch (error: any) { return unavailable('unreachable', error.message); }
+      catch (error     ) { return unavailable('unreachable', error.message); }
       const version = adapter.parseVersion(versionResponse.status, versionResponse.bodyText)?.version ?? null;
       const minimum = minVersion || provider.minVersion;
       const versionOk = version ? versionAtLeast(version, minimum) : false;
@@ -288,9 +288,9 @@ function createAdviceClient({
         return { endpoint: endpointResult, models, model: { installed: false, decisionCapable: false } };
       }
 
-      const configuredIndex = models.findIndex((entry: any) => adapter.modelMatches(model, entry.name));
-      const fallbackIndexes = models.map((entry: any, index: any) => index)
-        .filter((index: any) => !Array.isArray(models[index].capabilities));
+      const configuredIndex = models.findIndex((entry     ) => adapter.modelMatches(model, entry.name));
+      const fallbackIndexes = models.map((entry     , index     ) => index)
+        .filter((index     ) => !Array.isArray(models[index].capabilities));
       if (configuredIndex >= 0 && fallbackIndexes.includes(configuredIndex)) {
         fallbackIndexes.splice(fallbackIndexes.indexOf(configuredIndex), 1);
         fallbackIndexes.unshift(configuredIndex);
@@ -304,7 +304,7 @@ function createAdviceClient({
           // Keep capabilities unknown when the read-only fallback is unavailable.
         }
       }
-      const match = models.find((entry: any) => adapter.modelMatches(model, entry.name));
+      const match = models.find((entry     ) => adapter.modelMatches(model, entry.name));
       return {
         endpoint: endpointResult,
         models,
@@ -313,7 +313,7 @@ function createAdviceClient({
           decisionCapable: Boolean(match?.capabilities?.includes(provider.capability)),
         },
       };
-    } catch (error: any) {
+    } catch (error     ) {
       return unavailable('unreachable', error?.message || 'decision model inspection failed');
     }
   }