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

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

@@ -4,17 +4,17 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { resolveRoots } = require('../storage/roots.ts');
+const { resolveRoots } = require('../storage/roots.js');
 
 const SETTING_FILE = 'decision-model.json';
 const PROJECT_NOTE = 'a project cannot enable the decision model or choose its endpoint';
 const KNOWN_KEYS = new Set(['schema', 'enabled', 'provider', 'endpoint', 'model']);
 
-function isObject(value: any): boolean {
+function isObject(value     )          {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function offResult(reason: string, decidedBy: any, notes: string[] = [], setting: any = {}): any {
+function offResult(reason        , decidedBy     , notes           = [], setting      = {})      {
   return {
     state: 'off', reason,
     provider: setting.provider ?? null,
@@ -26,24 +26,24 @@ function offResult(reason: string, decidedBy: any, notes: string[] = [], setting
   };
 }
 
-function readJson(file: string | null, fsImpl: any): { exists: boolean; value?: any; error?: any } {
+function readJson(file               , fsImpl     )                                                {
   if (!file) return { exists: false };
   try {
     return { exists: true, value: JSON.parse(fsImpl.readFileSync(file, 'utf8')) };
-  } catch (error: any) {
+  } catch (error     ) {
     if (error?.code === 'ENOENT') return { exists: false };
     return { exists: true, error };
   }
 }
 
-function parseUserSetting(value: any, adviceRegistry: any): any {
+function parseUserSetting(value     , adviceRegistry     )      {
   if (!isObject(value)) return { error: 'user setting must be a JSON object' };
   if (value.schema !== 1) return { error: 'user setting schema must be 1' };
   if (typeof value.enabled !== 'boolean') return { error: 'user setting enabled must be a boolean' };
 
   const providers = Array.isArray(adviceRegistry?.providers) ? adviceRegistry.providers : [];
   const providerId = value.provider === undefined ? 'ollama' : value.provider;
-  const provider = providers.find((item: any) => item?.id === providerId);
+  const provider = providers.find((item     ) => item?.id === providerId);
   if (typeof providerId !== 'string' || !provider) return { error: `user setting provider '${providerId}' is not in advice.json providers` };
 
   let endpoint = provider.defaultEndpoint;
@@ -70,13 +70,13 @@ function parseUserSetting(value: any, adviceRegistry: any): any {
   };
 }
 
-function parseProjectSetting(value: any): any {
+function parseProjectSetting(value     )      {
   if (!isObject(value)) return { error: 'project setting must be a JSON object' };
   if (value.schema !== 1) return { error: 'project setting schema must be 1' };
   if (value.enabled !== undefined && typeof value.enabled !== 'boolean') return { error: 'project setting enabled must be a boolean' };
   if (value.model !== undefined && (typeof value.model !== 'string' || !value.model.trim())) return { error: 'project setting model must be a non-empty string' };
 
-  const notes: string[] = [];
+  const notes           = [];
   if (value.enabled === true) notes.push(`project key 'enabled' ignored: ${PROJECT_NOTE}`);
   for (const key of ['endpoint', 'provider']) {
     if (Object.hasOwn(value, key)) notes.push(`project key '${key}' ignored: ${PROJECT_NOTE}`);
@@ -95,12 +95,12 @@ function resolveSetting({
   global = false,
   env = process.env,
   fsImpl = fs,
-}: any = {}): any {
-  const notes: string[] = [];
+}      = {})      {
+  const notes           = [];
   let resolvedRoots = roots;
   try {
     if (!resolvedRoots) resolvedRoots = resolveRoots({ registry: storageRegistry, projectRoot, global, env });
-  } catch (error: any) {
+  } catch (error     ) {
     return offResult('config-invalid', { user: null, project: null }, [`storage roots could not be resolved: ${error.message}`]);
   }
   const userFile = resolvedRoots?.['config-home'] ? path.join(resolvedRoots['config-home'], SETTING_FILE) : null;
@@ -149,19 +149,19 @@ function resolveSetting({
   };
 }
 
-function writeSetting({ file, setting, level = 'user', force = false, fsImpl = fs }: any = {}): any {
+function writeSetting({ file, setting, level = 'user', force = false, fsImpl = fs }      = {})      {
   if (typeof file !== 'string' || !file || !isObject(setting)) {
     return { ok: false, reason: 'config-invalid', detail: 'file and setting object are required' };
   }
   const directory = path.dirname(file);
-  let existing: any = {};
+  let existing      = {};
   try {
     if (fsImpl.existsSync(file)) {
       try {
         const parsed = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
         if (!isObject(parsed)) throw new Error('setting must be a JSON object');
         existing = parsed;
-      } catch (error: any) {
+      } catch (error     ) {
         if (!force) return { ok: false, reason: 'config-invalid', detail: `${file}: ${error.message}` };
       }
     }
@@ -181,7 +181,7 @@ function writeSetting({ file, setting, level = 'user', force = false, fsImpl = f
       try { if (fsImpl.existsSync(temporary)) fsImpl.unlinkSync(temporary); } catch { /* keep the primary result */ }
     }
     return { ok: true, file, setting: output };
-  } catch (error: any) {
+  } catch (error     ) {
     return { ok: false, reason: 'config-invalid', detail: `${file}: ${error.message}` };
   }
 }

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

@@ -3,64 +3,64 @@
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 
 const fs = require('node:fs');
-const { resolveRoots } = require('../storage/roots.ts');
-const { loadStorageRegistry } = require('../storage/registry.ts');
-const { loadAdviceRegistry } = require('./registry.ts');
-const { resolveSetting } = require('./config.ts');
-const { createAdviceClient } = require('./client.ts');
-const { readWindow } = require('./record.ts');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
+const { resolveRoots } = require('../storage/roots.js');
+const { loadStorageRegistry } = require('../storage/registry.js');
+const { loadAdviceRegistry } = require('./registry.js');
+const { resolveSetting } = require('./config.js');
+const { createAdviceClient } = require('./client.js');
+const { readWindow } = require('./record.js');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
 
 const WINDOW_DAYS = 90;
-const DONE_PHRASES: Record<string, string> = Object.freeze({
+const DONE_PHRASES                         = Object.freeze({
   'classify-verdict': 'accepted class',
   'brief-record': 'tier the brief named',
   caller: 'value the caller recorded',
 });
 
-function selectedStore(roots: any) {
+function selectedStore(roots     ) {
   if (roots?.['project-state']) return { id: 'advice-picks-project', root: roots['project-state'] };
   return { id: 'advice-picks-user', root: roots?.['user-state'] || null };
 }
 
-function latestCall(records: any) {
-  const calls = records.filter(({ record }: any) => record.type === 'pick' || record.type === 'miss');
+function latestCall(records     ) {
+  const calls = records.filter(({ record }     ) => record.type === 'pick' || record.type === 'miss');
   if (!calls.length) return null;
-  const record = calls.reduce((latest: any, entry: any) => !latest || String(entry.record.at).localeCompare(String(latest.record.at)) >= 0
+  const record = calls.reduce((latest     , entry     ) => !latest || String(entry.record.at).localeCompare(String(latest.record.at)) >= 0
     ? entry : latest).record;
   return record.type === 'pick'
     ? { at: record.at, status: 'answered', reason: null }
     : { at: record.at, status: 'unavailable', reason: record.reason || null };
 }
 
-function agreementRows(registry: any, records: any) {
-  const picks = records.filter(({ record }: any) => record.type === 'pick');
+function agreementRows(registry     , records     ) {
+  const picks = records.filter(({ record }     ) => record.type === 'pick');
   const outcomes = new Map();
   for (const { record } of records) {
     if (record.type !== 'outcome' || typeof record.pickId !== 'string') continue;
     const current = outcomes.get(record.pickId);
     if (!current || String(record.at).localeCompare(String(current.at)) >= 0) outcomes.set(record.pickId, record);
   }
-  const misses = records.filter(({ record }: any) => record.type === 'miss');
-  const ids = [...(registry.kinds || []).map((kind: any) => kind.id)];
-  if (picks.some(({ record }: any) => record.kind === 'adhoc')) ids.push('adhoc');
+  const misses = records.filter(({ record }     ) => record.type === 'miss');
+  const ids = [...(registry.kinds || []).map((kind     ) => kind.id)];
+  if (picks.some(({ record }     ) => record.kind === 'adhoc')) ids.push('adhoc');
   return ids.map((kind) => {
-    const kindPicks = picks.filter(({ record }: any) => record.kind === kind);
-    const completed = kindPicks.map(({ record }: any) => ({ pick: record.pick, outcome: outcomes.get(record.pickId) }))
-      .filter(({ outcome }: any) => outcome);
-    const sources = [...new Set(completed.map(({ outcome }: any) => outcome.source).filter((source: any) => DONE_PHRASES[source]))];
+    const kindPicks = picks.filter(({ record }     ) => record.kind === kind);
+    const completed = kindPicks.map(({ record }     ) => ({ pick: record.pick, outcome: outcomes.get(record.pickId) }))
+      .filter(({ outcome }     ) => outcome);
+    const sources = [...new Set(completed.map(({ outcome }     ) => outcome.source).filter((source     ) => DONE_PHRASES[source]))];
     return {
       kind,
       picks: kindPicks.length,
       withOutcome: completed.length,
-      matched: completed.filter(({ pick, outcome }: any) => outcome.actual === pick).length,
-      unavailable: misses.filter(({ record }: any) => record.kind === kind).length,
+      matched: completed.filter(({ pick, outcome }     ) => outcome.actual === pick).length,
+      unavailable: misses.filter(({ record }     ) => record.kind === kind).length,
       outcomeSources: sources,
     };
   });
 }
 
-function offReason(setting: any) {
+function offReason(setting     ) {
   if (setting.reason === 'not-configured') return 'not configured';
   if (setting.reason === 'config-invalid') return `unreadable setting in ${setting.decidedBy?.user || setting.decidedBy?.project || 'decision-model.json'}`;
   if (setting.reason === 'project-disabled') return `switched off in ${setting.decidedBy?.project}`;
@@ -69,7 +69,7 @@ function offReason(setting: any) {
 
 async function buildAdviceDoctor({ repoRoot = REPO_ROOT, projectRoot = process.cwd(), env = process.env, fsImpl = fs,
   adviceRegistry: suppliedRegistry, storageRegistry: suppliedStorage, client: suppliedClient, lookup, httpModule, httpsModule,
-  probeTimeoutMs, doctorBudgetMs, now = () => new Date() }: any = {}) {
+  probeTimeoutMs, doctorBudgetMs, now = () => new Date() }      = {}) {
   try {
     const root = repoRoot;
     const loaded = suppliedRegistry ? { ok: true, registry: suppliedRegistry } : loadAdviceRegistry({ repoRoot: root, fsImpl });
@@ -97,15 +97,15 @@ async function buildAdviceDoctor({ repoRoot = REPO_ROOT, projectRoot = process.c
         doctorBudgetMs: doctorBudgetMs ?? registry.doctorBudgetMs };
       const client = suppliedClient || createAdviceClient({ adviceRegistry: effectiveRegistry, roots, fsImpl, lookup, httpModule, httpsModule });
       inspection = await client.inspect({ endpoint: setting.endpoint, model: setting.model, provider: setting.provider,
-        file: setting.decidedBy?.user, minVersion: registry.providers.find((p: any) => p.id === setting.provider)?.minVersion,
+        file: setting.decidedBy?.user, minVersion: registry.providers.find((p     ) => p.id === setting.provider)?.minVersion,
         timeoutMs: probeTimeoutMs ?? registry.probeTimeoutMs });
-      const provider = registry.providers.find((p: any) => p.id === setting.provider) || {};
+      const provider = registry.providers.find((p     ) => p.id === setting.provider) || {};
       decisionModel = {
         setting: { state: 'on', reason: null, decidedBy: setting.decidedBy, modelFrom: setting.modelFrom, notes: setting.notes || [] },
         endpoint: { url: setting.endpoint, state: inspection.endpoint.state, version: inspection.endpoint.version,
           minVersion: provider.minVersion || null, versionOk: inspection.endpoint.versionOk, message: inspection.endpoint.message },
         model: { name: setting.model, installed: inspection.model.installed, decisionCapable: inspection.model.decisionCapable },
-        decisionModels: inspection.models.filter((model: any) => model.capabilities?.includes(provider.capability)).map((model: any) => model.name),
+        decisionModels: inspection.models.filter((model     ) => model.capabilities?.includes(provider.capability)).map((model     ) => model.name),
         lastCall: latestCall(window.records),
       };
     } else {
@@ -117,7 +117,7 @@ async function buildAdviceDoctor({ repoRoot = REPO_ROOT, projectRoot = process.c
       };
     }
     return { decisionModel, advice, _inspection: inspection, _offReason: setting.state === 'off' ? offReason(setting) : null };
-  } catch (error: any) {
+  } catch (error     ) {
     return { decisionModel: { setting: { state: 'off', reason: 'config-invalid', decidedBy: { user: null, project: null }, modelFrom: null, notes: [error.message] },
       endpoint: { url: null, state: 'not-checked', version: null, minVersion: null, versionOk: false, message: null },
       model: { name: null, installed: false, decisionCapable: false }, decisionModels: [], lastCall: null },
@@ -125,7 +125,7 @@ async function buildAdviceDoctor({ repoRoot = REPO_ROOT, projectRoot = process.c
   }
 }
 
-function printAdviceDoctor(report: any) {
+function printAdviceDoctor(report     ) {
   const decision = report.decisionModel;
   const inspection = report._inspection;
   console.log('\n[Decision Model] — advisory, never blocking');
@@ -156,10 +156,10 @@ function printAdviceDoctor(report: any) {
   }
 
   console.log('\n[Advice Agreement] — picks kept for 90 days in this project; agreement with what was done, not correctness');
-  if (!report.advice.kinds.some((row: any) => row.picks) && !report.advice.unreadableLines) console.log('  No picks recorded here.');
+  if (!report.advice.kinds.some((row     ) => row.picks) && !report.advice.unreadableLines) console.log('  No picks recorded here.');
   for (const row of report.advice.kinds) {
     if (!row.picks) { console.log(`  ${row.kind.padEnd(17)}no picks recorded`); continue; }
-    const phrases = row.outcomeSources.map((source: any) => DONE_PHRASES[source]).filter(Boolean);
+    const phrases = row.outcomeSources.map((source     ) => DONE_PHRASES[source]).filter(Boolean);
     const done = phrases.length ? ` (done = ${phrases.join(' or ')})` : '';
     console.log(`  ${row.kind.padEnd(17)}${row.picks} picks, ${row.withOutcome} with a known outcome, matched ${row.matched} of ${row.withOutcome}${done}; ${row.unavailable} calls unavailable`);
   }

package/src/runtime/advice/{endpoint-guard.ts → endpoint-guard.js}

@@ -4,17 +4,17 @@
 
 const dns = require('node:dns');
 
-function displayEndpoint(value: any): string {
+function displayEndpoint(value     )         {
   return typeof value === 'string' ? value : String(value ?? '');
 }
 
-function ipv4Octets(address: any): number[] | null {
+function ipv4Octets(address     )                  {
   if (typeof address !== 'string' || !/^\d{1,3}(?:\.\d{1,3}){3}$/.test(address)) return null;
   const octets = address.split('.').map(Number);
   return octets.every((octet) => octet >= 0 && octet <= 255) ? octets : null;
 }
 
-function ipv6Words(address: any): number[] | null {
+function ipv6Words(address     )                  {
   if (typeof address !== 'string' || !address.includes(':')) return null;
   let value = address.toLowerCase();
   if (value.includes('.')) {
@@ -27,7 +27,7 @@ function ipv6Words(address: any): number[] | null {
   }
   const doubleColon = value.indexOf('::');
   if (doubleColon !== -1 && value.indexOf('::', doubleColon + 2) !== -1) return null;
-  let words: string[];
+  let words          ;
   if (doubleColon === -1) {
     words = value.split(':');
     if (words.length !== 8) return null;
@@ -42,7 +42,7 @@ function ipv6Words(address: any): number[] | null {
   return words.map((word) => Number.parseInt(word, 16));
 }
 
-function isLoopback(address: any): boolean {
+function isLoopback(address     )          {
   const octets = ipv4Octets(address);
   if (octets) return octets[0] === 127;
   const words = ipv6Words(address);
@@ -53,25 +53,25 @@ function isLoopback(address: any): boolean {
   return (words[6] >> 8) === 127;
 }
 
-function literalFamily(address: any): 4 | 6 {
+function literalFamily(address     )        {
   return ipv4Octets(address) ? 4 : 6;
 }
 
-function isLiteralIp(host: any): boolean {
+function isLiteralIp(host     )          {
   return Boolean(ipv4Octets(host) || ipv6Words(host));
 }
 
-function refuse(value: any, file?: string): { ok: false; message: string } {
+function refuse(value     , file         )                                 {
   return {
     ok: false,
     message: `decision model: endpoint ${value} refused: only loopback addresses are allowed (127.0.0.0/8, ::1); set in ${file || 'provider default'}`,
   };
 }
 
-function lookupAll(host: string, lookup: any, timeoutMs?: number): Promise<any> {
+function lookupAll(host        , lookup     , timeoutMs         )               {
   return new Promise((resolve, reject) => {
     let settled = false;
-    const finish = (error: any, addresses?: any) => {
+    const finish = (error     , addresses      ) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -80,10 +80,10 @@ function lookupAll(host: string, lookup: any, timeoutMs?: number): Promise<any>
     };
     const timer = Number.isFinite(timeoutMs) ? setTimeout(() => {
       finish(Object.assign(new Error('decision model DNS validation timed out'), { code: 'ADVICE_TIMEOUT' }));
-    }, Math.max(0, timeoutMs as number)) : undefined;
+    }, Math.max(0, timeoutMs          )) : undefined;
     try {
       const returned = lookup(host, { all: true, verbatim: true }, finish);
-      if (returned && typeof returned.then === 'function') returned.then((addresses: any) => finish(null, addresses), finish);
+      if (returned && typeof returned.then === 'function') returned.then((addresses     ) => finish(null, addresses), finish);
       else if (Array.isArray(returned)) finish(null, returned);
     } catch (error) {
       finish(error);
@@ -91,8 +91,8 @@ function lookupAll(host: string, lookup: any, timeoutMs?: number): Promise<any>
   });
 }
 
-function pinnedLookup(address: string, family: number) {
-  return (hostname: string, options: any, callback?: any) => {
+function pinnedLookup(address        , family        ) {
+  return (hostname        , options     , callback      ) => {
     if (typeof options === 'function') {
       callback = options;
       options = {};
@@ -103,9 +103,9 @@ function pinnedLookup(address: string, family: number) {
   };
 }
 
-async function checkEndpoint(value: any, { lookup = dns.lookup, file, timeoutMs }: any = {}): Promise<any> {
+async function checkEndpoint(value     , { lookup = dns.lookup, file, timeoutMs }      = {})               {
   const display = displayEndpoint(value);
-  let url: any;
+  let url     ;
   try { url = new URL(display); } catch { return refuse(display, file); }
   if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return refuse(display, file);
 
@@ -116,17 +116,17 @@ async function checkEndpoint(value: any, { lookup = dns.lookup, file, timeoutMs
     return { ok: true, address: host, family, pinnedLookup: pinnedLookup(host, family) };
   }
 
-  let addresses: any;
-  try { addresses = await lookupAll(host, lookup, timeoutMs); } catch (error: any) {
+  let addresses     ;
+  try { addresses = await lookupAll(host, lookup, timeoutMs); } catch (error     ) {
     if (error?.code === 'ADVICE_TIMEOUT') return { ok: false, reason: 'timeout', message: error.message };
     return refuse(display, file);
   }
   if (!Array.isArray(addresses) || addresses.length === 0) return refuse(display, file);
-  const checked: any[] = addresses.map((entry: any) => {
+  const checked        = addresses.map((entry     ) => {
     if (!entry || typeof entry.address !== 'string') return null;
     return { address: entry.address, family: literalFamily(entry.address) };
   });
-  if (checked.some((entry: any) => !entry || !isLoopback(entry.address))) return refuse(display, file);
+  if (checked.some((entry     ) => !entry || !isLoopback(entry.address))) return refuse(display, file);
   const first = checked[0];
   return { ok: true, address: first.address, family: first.family, pinnedLookup: pinnedLookup(first.address, first.family) };
 }

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

@@ -2,20 +2,20 @@
 
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 
-function isObject(value: any): boolean {
+function isObject(value     )          {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function invalid(detail: string, reason: string = 'config-invalid'): { ok: false; reason: string; detail: string } {
+function invalid(detail        , reason         = 'config-invalid')                                                {
   return { ok: false, reason, detail };
 }
 
-function optionCount(question: any): number {
+function optionCount(question     )         {
   if (question.type === 'score') return Array.isArray(question.criteria) ? question.criteria.length : 0;
   return question.type === 'choice' ? Object.keys(question.options || {}).length : 2;
 }
 
-function checkOptionRange(count: number, limits: any, owner: string): { ok: false; reason: string; detail: string } | null {
+function checkOptionRange(count        , limits     , owner        )                                                       {
   if (!Number.isInteger(limits?.minOptions) || !Number.isInteger(limits?.maxOptions)) {
     return invalid(`${owner} cannot be built: invalid limits in core/registry/advice.json`);
   }
@@ -28,16 +28,16 @@ function checkOptionRange(count: number, limits: any, owner: string): { ok: fals
   return null;
 }
 
-function criteriaFrom(source: string, sources: any): Record<string, any> | null {
-  let entries: [string, any][];
+function criteriaFrom(source        , sources     )                             {
+  let entries                 ;
   if (source === 'workflows.classes') {
     const classes = sources?.workflows?.classes;
     if (!isObject(classes)) return null;
-    entries = Object.entries(classes).map(([id, item]: [string, any]) => [id, item?.description]);
+    entries = Object.entries(classes).map(([id, item]               ) => [id, item?.description]);
   } else if (source === 'verification.riskLevels') {
     const levels = sources?.verification?.riskLevels;
     if (!isObject(levels)) return null;
-    entries = Object.entries(levels).map(([id, item]: [string, any]) => [id, item?.description]);
+    entries = Object.entries(levels).map(([id, item]               ) => [id, item?.description]);
   } else {
     return null;
   }
@@ -45,21 +45,21 @@ function criteriaFrom(source: string, sources: any): Record<string, any> | null
   return Object.fromEntries(entries);
 }
 
-function materializeKind(kindId: string, { adviceRegistry, sources = {}, server }: any = {}): any {
+function materializeKind(kindId        , { adviceRegistry, sources = {}, server }      = {})      {
   const kinds = adviceRegistry?.kinds;
   if (!Array.isArray(kinds)) return invalid('kinds are missing from core/registry/advice.json');
-  const kind = kinds.find((entry: any) => entry?.id === kindId);
+  const kind = kinds.find((entry     ) => entry?.id === kindId);
   if (!kind) return invalid(`unknown kind '${kindId}'`, 'usage-error');
 
   const serverSource = kind.criteriaFrom === 'mcp.servers[].trigger';
   if (server !== undefined && !serverSource) return invalid('--server is valid only for mcp-need', 'usage-error');
 
-  let question: any;
+  let question     ;
   if (serverSource) {
     if (typeof server !== 'string' || !server.trim()) return invalid('--server is required for mcp-need', 'usage-error');
     const servers = sources?.mcp?.servers;
     if (!Array.isArray(servers)) return invalid('mcp.servers is missing from core/registry/mcp.json');
-    const match = servers.find((entry: any) => entry?.id === server);
+    const match = servers.find((entry     ) => entry?.id === server);
     if (!match) return invalid(`server '${server}' is not present in core/registry/mcp.json`, 'usage-error');
     if (typeof match.trigger !== 'string' || !match.trigger.trim()) return invalid(`mcp.servers.${server}.trigger is missing`);
     question = { name: kind.id, type: 'yesno', instructions: match.trigger, no: kind.no, yes: kind.yes };
@@ -82,7 +82,7 @@ function materializeKind(kindId: string, { adviceRegistry, sources = {}, server
   return { ok: true, kind: kind.id, question };
 }
 
-function validateQuestionSet(questionSet: any, { adviceRegistry }: any = {}): any {
+function validateQuestionSet(questionSet     , { adviceRegistry }      = {})      {
   const limits = adviceRegistry?.limits;
   if (!isObject(limits)) return invalid('limits are missing from core/registry/advice.json');
   if (!isObject(questionSet)) return invalid('question set must be an object (core/registry/advice.json limits.minQuestions)');
@@ -95,7 +95,7 @@ function validateQuestionSet(questionSet: any, { adviceRegistry }: any = {}): an
     return invalid(`question count exceeds ${limits.maxQuestions} (core/registry/advice.json limits.maxQuestions)`);
   }
 
-  let namePattern: RegExp;
+  let namePattern        ;
   try { namePattern = new RegExp(limits.questionName); } catch {
     return invalid('questionName does not compile (core/registry/advice.json limits.questionName)');
   }
@@ -128,7 +128,7 @@ function validateQuestionSet(questionSet: any, { adviceRegistry }: any = {}): an
       if (!Array.isArray(question.criteria)) return invalid(`${prefix}.criteria must be an array of criterion strings (core/registry/advice.json limits.minOptions)`);
       const rangeError = checkOptionRange(question.criteria.length, limits, `${prefix}.criteria`);
       if (rangeError) return rangeError;
-      if (question.criteria.some((criterion: any) => typeof criterion !== 'string' || !criterion.trim())) {
+      if (question.criteria.some((criterion     ) => typeof criterion !== 'string' || !criterion.trim())) {
         return invalid(`${prefix}.criteria must be non-empty strings (core/registry/advice.json limits.minOptions)`);
       }
       if (new Set(question.criteria).size !== question.criteria.length) {
@@ -141,7 +141,7 @@ function validateQuestionSet(questionSet: any, { adviceRegistry }: any = {}): an
   return { ok: true, questionSet };
 }
 
-function validateStaticAnswer(question: any, value: any): { ok: boolean; reason?: string; detail?: string } {
+function validateStaticAnswer(question     , value     )                                                    {
   if (value === undefined || value === null) return { ok: true };
   const validOptions = question?.type === 'choice'
     ? Object.keys(question.options || {})

package/src/runtime/advice/providers/{ollama-systemone.ts → ollama-systemone.js}

@@ -7,7 +7,7 @@ const VERSION_PATH = '/api/version';
 const TAGS_PATH = '/api/tags';
 const SHOW_PATH = '/api/show';
 
-function parseJson(bodyText: any): any {
+function parseJson(bodyText     )      {
   if (typeof bodyText !== 'string') return null;
   try {
     const value = JSON.parse(bodyText);
@@ -17,12 +17,12 @@ function parseJson(bodyText: any): any {
   }
 }
 
-function failure(reason: string, detail: string): { ok: false; reason: string; detail: string } {
+function failure(reason        , detail        )                                                {
   return { ok: false, reason, detail };
 }
 
-function buildRequest(questionSet: any, { model }: any = {}): { method: string; path: string; body: any } {
-  const questions = Object.fromEntries(questionSet.questions.map((question: any) => {
+function buildRequest(questionSet     , { model }      = {})                                              {
+  const questions = Object.fromEntries(questionSet.questions.map((question     ) => {
     if (question.type === 'choice') {
       return [question.name, {
         type: 'choice',
@@ -52,19 +52,19 @@ function buildRequest(questionSet: any, { model }: any = {}): { method: string;
 
 const SCORE_TOLERANCE = 1e-6;
 
-function inUnit(value: any): boolean {
+function inUnit(value     )          {
   return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
 }
 
-function parseScore(question: any, value: any): any {
-  const bad = (detail: string) => failure('malformed-reply', detail);
+function parseScore(question     , value     )      {
+  const bad = (detail        ) => failure('malformed-reply', detail);
   const { criteria, name } = question;
   const last = criteria.length - 1;
   if (value.type !== 'score') return bad(`answer for ${name} is not a score`);
-  const keys: string[] = criteria.map((criterion: any, index: number) => String(index));
-  const exact = (object: any) => object && typeof object === 'object' && !Array.isArray(object)
+  const keys           = criteria.map((criterion     , index        ) => String(index));
+  const exact = (object     ) => object && typeof object === 'object' && !Array.isArray(object)
     && Object.keys(object).length === keys.length && keys.every((key) => Object.hasOwn(object, key));
-  if (!exact(value.legend) || keys.some((key: string, index: number) => value.legend[key] !== criteria[index])) {
+  if (!exact(value.legend) || keys.some((key        , index        ) => value.legend[key] !== criteria[index])) {
     return bad(`legend for ${name} does not match its criteria`);
   }
   if (!exact(value.probabilities)) return bad(`probabilities for ${name} do not match its criteria`);
@@ -89,7 +89,7 @@ function parseScore(question: any, value: any): any {
   };
 }
 
-function parseReply(status: number, bodyText: any, questionSet: any): any {
+function parseReply(status        , bodyText     , questionSet     )      {
   if (status === 400) {
     const parsed = parseJson(bodyText);
     return failure('endpoint-rejected', typeof parsed?.error === 'string' ? parsed.error : 'Ollama rejected the request');
@@ -108,7 +108,7 @@ function parseReply(status: number, bodyText: any, questionSet: any): any {
     return failure('malformed-reply', 'reply has no answers object');
   }
 
-  const answers: any[] = [];
+  const answers        = [];
   for (const question of questionSet.questions) {
     const value = parsed.answers[question.name];
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -159,7 +159,7 @@ function versionRequest() {
   return { method: 'GET', path: VERSION_PATH };
 }
 
-function parseVersion(status: number, bodyText: any): { version: string } | null {
+function parseVersion(status        , bodyText     )                             {
   const parsed = status === 200 ? parseJson(bodyText) : null;
   return typeof parsed?.version === 'string' && parsed.version.trim() ? { version: parsed.version.trim() } : null;
 }
@@ -168,31 +168,31 @@ function listRequest() {
   return { method: 'GET', path: TAGS_PATH };
 }
 
-function parseList(status: number, bodyText: any): any[] {
+function parseList(status        , bodyText     )        {
   const parsed = status === 200 ? parseJson(bodyText) : null;
   if (!Array.isArray(parsed?.models)) return [];
   return parsed.models
-    .filter((model: any) => model && typeof model.name === 'string' && model.name.trim())
-    .map((model: any) => ({
+    .filter((model     ) => model && typeof model.name === 'string' && model.name.trim())
+    .map((model     ) => ({
       name: model.name,
-      capabilities: Array.isArray(model.capabilities) && model.capabilities.every((capability: any) => typeof capability === 'string')
+      capabilities: Array.isArray(model.capabilities) && model.capabilities.every((capability     ) => typeof capability === 'string')
         ? model.capabilities : null,
     }));
 }
 
-function showRequest(name: string): { method: string; path: string; body: any } {
+function showRequest(name        )                                              {
   return { method: 'POST', path: SHOW_PATH, body: { model: name } };
 }
 
-function parseShow(status: number, bodyText: any): { capabilities: string[] } | null {
+function parseShow(status        , bodyText     )                                    {
   const parsed = status === 200 ? parseJson(bodyText) : null;
-  return Array.isArray(parsed?.capabilities) && parsed.capabilities.every((capability: any) => typeof capability === 'string')
+  return Array.isArray(parsed?.capabilities) && parsed.capabilities.every((capability     ) => typeof capability === 'string')
     ? { capabilities: parsed.capabilities }
     : null;
 }
 
 /** A configured name without a tag also matches Ollama's listed `<name>:latest` form. */
-function modelMatches(configured: any, listed: any): boolean {
+function modelMatches(configured     , listed     )          {
   return configured === listed || (typeof configured === 'string' && !configured.includes(':') && listed === `${configured}:latest`);
 }