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

package/src/runtime/{capability-router.ts → capability-router.js}

@@ -5,39 +5,39 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
-const { validateCapabilityProviders } = require('../registry/index.ts');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+const { validateCapabilityProviders } = require('../registry/index.js');
 
 // Mirrors bin/doflow.js's own REPO_ROOT computation, relative to this file's location, so
 // handleRouteCommand resolves the same repo root it did before relocation. (D8)
 
 /** POSIX single-quote escaping, for the DISPLAY string only — execution always uses the argv
  * vector, never a shell string, so retrieved data can never become shell syntax (review R5). */
-function shellQuote(word: any): string {
+function shellQuote(word     )         {
   const text = String(word);
   if (text !== '' && /^[A-Za-z0-9_@%+=:,.\/-]+$/.test(text)) return text;
   return `'${text.replace(/'/g, `'\\''`)}'`;
 }
 
-function parseYamlFile(filePath: string, fsImpl: any = fs): any {
+function parseYamlFile(filePath        , fsImpl      = fs)      {
   try {
     const text = fsImpl.readFileSync(filePath, 'utf8');
     return JSON.parse(text);
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`Failed to parse registry file '${filePath}': ${error.message}`);
   }
 }
 
 class CapabilityRouter {
-  fsImpl: any;
-  repoRoot: string;
-  projectRoot: string;
-  registryDir: string;
-  binaryChecker: ((binary: string) => boolean) | null;
-  binaryCache: Map<string, boolean>;
-  capabilities!: Record<string, any>;
-  routes!: Record<string, any>;
+  fsImpl     ;
+  repoRoot        ;
+  projectRoot        ;
+  registryDir        ;
+  binaryChecker                                      ;
+  binaryCache                      ;
+  capabilities                      ;
+  routes                      ;
 
   /**
    * @param {Object} [options]
@@ -48,7 +48,7 @@ class CapabilityRouter {
    * @param {Object} [options.fsImpl]
    * @param {Function} [options.binaryChecker]
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     this.fsImpl = options.fsImpl || fs;
     this.repoRoot = options.repoRoot || REPO_ROOT;
     // Two roots, deliberately distinct (review A3, surfaced by R5's tests): `repoRoot` locates the
@@ -68,7 +68,7 @@ class CapabilityRouter {
     }
   }
 
-  loadRegistries(): void {
+  loadRegistries()       {
     const capsPath = path.join(this.registryDir, 'capabilities.json');
     const routesPath = path.join(this.registryDir, 'routes.json');
     
@@ -78,7 +78,7 @@ class CapabilityRouter {
     this.capabilities = capsData.capabilities || {};
     // A provider without a valid `sourceMode` cannot be told apart from an index-backed one, so the
     // file is refused whole rather than loaded with a guess (068).
-    const providerErrors: string[] = [];
+    const providerErrors           = [];
     validateCapabilityProviders(this.capabilities, providerErrors);
     if (providerErrors.length > 0) {
       throw new Error(`Invalid registry file '${capsPath}':\n- ${providerErrors.join('\n- ')}`);
@@ -91,13 +91,13 @@ class CapabilityRouter {
    * @param {string} binary
    * @returns {boolean}
    */
-  isBinaryAvailable(binary: string): boolean {
+  isBinaryAvailable(binary        )          {
     if (!binary) return false;
     if (this.binaryChecker) {
       return this.binaryChecker(binary);
     }
     if (this.binaryCache.has(binary)) {
-      return this.binaryCache.get(binary) as boolean;
+      return this.binaryCache.get(binary)           ;
     }
     try {
       const isWin = process.platform === 'win32';
@@ -116,7 +116,7 @@ class CapabilityRouter {
    * @param {Array<string>} checkCommand
    * @returns {{ ok: boolean, output?: string, error?: string }}
    */
-  executeSmokeCheck(checkCommand: any): { ok: boolean; output?: string; error?: string } {
+  executeSmokeCheck(checkCommand     )                                                   {
     if (!Array.isArray(checkCommand) || checkCommand.length === 0) {
       return { ok: true };
     }
@@ -128,7 +128,7 @@ class CapabilityRouter {
         stdio: ['ignore', 'pipe', 'pipe'],
       });
       return { ok: true, output: stdout.trim() };
-    } catch (error: any) {
+    } catch (error     ) {
       return { ok: false, error: error.message };
     }
   }
@@ -139,13 +139,13 @@ class CapabilityRouter {
    * @param {boolean} [deepCheck=false]
    * @returns {{ status: 'HEALTHY'|'UNAVAILABLE', details?: string }}
    */
-  evaluateProviderHealth(provider: any, deepCheck: boolean = false): any {
+  evaluateProviderHealth(provider     , deepCheck          = false)      {
     if (!provider) return { status: 'UNAVAILABLE', details: 'No provider declared' };
 
     // Declared / installed / responsive are DISTINCT facts (review R5): `facts` reports each one
     // as true, false, or null-for-not-measured, so "healthy" can never silently mean only
     // "declared in the registry". The summary `status` stays for existing callers.
-    const facts: { declared: boolean; installed: boolean | null; responsive: boolean | null } = { declared: true, installed: null, responsive: null };
+    const facts                                                                               = { declared: true, installed: null, responsive: null };
 
     // `native.test` has no binary — its installedness is whether this project's manifests declare
     // a test command at all. Reporting HEALTHY without that check routed verify-runtime-behavior
@@ -205,16 +205,16 @@ class CapabilityRouter {
    * @param {boolean} [options.deepCheck=false]
    * @returns {{ capabilityId: string, provider: Object|null, status: string, fallbackProviders: Array<Object> }}
    */
-  resolveCapability(capabilityId: string, { deepCheck = false }: { deepCheck?: boolean } = {}): any {
+  resolveCapability(capabilityId        , { deepCheck = false }                          = {})      {
     const capability = this.capabilities[capabilityId];
     if (!capability) {
       throw new Error(`Unknown capability '${capabilityId}'`);
     }
 
     const providers = capability.providers || [];
-    let selectedProvider: any = null;
+    let selectedProvider      = null;
     let selectedStatus = 'UNAVAILABLE';
-    const fallbackProviders: any[] = [];
+    const fallbackProviders        = [];
 
     for (let i = 0; i < providers.length; i++) {
       const prov = providers[i];
@@ -255,16 +255,16 @@ class CapabilityRouter {
    * @param {Object} params
    * @returns {Object}
    */
-  formatExecution(intent: string, provider: any, params: any = {}): any {
+  formatExecution(intent        , provider     , params      = {})      {
     const query = params.query || params.symbol || params.concept || '';
     const targetPath = params.path || '.';
     // The MCP tool name comes from the provider's registry descriptor (`mcp: {server, tool}`), so a
     // new MCP-backed provider needs no code change here. A caller may pass a bare `{ id }`, so fall
     // back to the registry entry with that id.
     const mcp = provider.mcp
-      || Object.values(this.capabilities).flatMap((cap: any) => cap.providers || []).find((p: any) => p.id === provider.id && p.mcp)?.mcp;
+      || Object.values(this.capabilities).flatMap((cap     ) => cap.providers || []).find((p     ) => p.id === provider.id && p.mcp)?.mcp;
     const mcpTool = mcp ? { mcpTool: `mcp__${mcp.server}__${mcp.tool}` } : {};
-    const withDisplay = (result: any) => ({ ...mcpTool, ...result, ...(result.argv ? { cliCommand: result.argv.map(shellQuote).join(' ') } : {}) });
+    const withDisplay = (result     ) => ({ ...mcpTool, ...result, ...(result.argv ? { cliCommand: result.argv.map(shellQuote).join(' ') } : {}) });
 
     if (provider.id === 'semble.search') {
       const content = params.content || 'code';
@@ -338,9 +338,9 @@ class CapabilityRouter {
   /** The project's own test entrypoint, read from its manifests by the shared command detector —
    * the same detector `doflow verify` uses, so the two agree. Returns null when no manifest
    * declares one: a wrong guess here becomes a command the model runs. */
-  detectTestCommand(): string | null {
+  detectTestCommand()                {
     try {
-      const { detectCommands } = require('./command-detect.ts');
+      const { detectCommands } = require('./command-detect.js');
       const detected = detectCommands({ projectRoot: this.projectRoot });
       return detected.commands?.test?.command || null;
     } catch {
@@ -355,7 +355,7 @@ class CapabilityRouter {
    * @param {Object} [options={}]
    * @returns {Object} RetrievalPlan
    */
-  resolveIntent(intentId: string, params: any = {}, { deepCheck = false }: { deepCheck?: boolean } = {}): any {
+  resolveIntent(intentId        , params      = {}, { deepCheck = false }                          = {})      {
     const route = this.routes[intentId];
     if (!route) {
       throw new Error(`Unknown route/intent '${intentId}'`);
@@ -372,7 +372,7 @@ class CapabilityRouter {
         selectedProvider: primaryResolution.provider,
         status: primaryResolution.status,
         execution: this.formatExecution(intentId, primaryResolution.provider, params),
-        fallbackChain: (route.fallback || []).map((fbCap: string) => ({
+        fallbackChain: (route.fallback || []).map((fbCap        ) => ({
           capability: fbCap,
           resolved: this.resolveCapability(fbCap, { deepCheck }),
         })),
@@ -408,7 +408,7 @@ class CapabilityRouter {
       selectedProvider: null,
       status: 'UNAVAILABLE',
       execution: null,
-      fallbackChain: (route.fallback || []).map((cap: string) => ({ capability: cap, status: 'UNAVAILABLE' })),
+      fallbackChain: (route.fallback || []).map((cap        ) => ({ capability: cap, status: 'UNAVAILABLE' })),
     };
   }
 
@@ -417,8 +417,8 @@ class CapabilityRouter {
    * @param {boolean} [deepCheck=false]
    * @returns {Array<Object>}
    */
-  getAllCapabilitiesHealth(deepCheck: boolean = false): any[] {
-    const report: any[] = [];
+  getAllCapabilitiesHealth(deepCheck          = false)        {
+    const report        = [];
     for (const [capId, cap] of Object.entries(this.capabilities)) {
       const resolution = this.resolveCapability(capId, { deepCheck });
       report.push({
@@ -448,16 +448,16 @@ class CapabilityRouter {
  * @param {string} [options.projectRoot]
  * @returns {number} exit code
  */
-function handleRouteCommand({ intent, query, check = false, json = false, projectRoot }: any = {}): number {
+function handleRouteCommand({ intent, query, check = false, json = false, projectRoot }      = {})         {
   const router = new CapabilityRouter({ repoRoot: REPO_ROOT, projectRoot });
   if (typeof intent !== 'string' || intent.trim() === '') {
     return usageError('route', `--intent is required. Declared intents: ${Object.keys(router.routes).join(', ')}`, json);
   }
 
-  let resolution: any;
+  let resolution     ;
   try {
     resolution = router.resolveIntent(intent, { query, path: projectRoot || '.' }, { deepCheck: check });
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('route', `${error.message}. Declared intents: ${Object.keys(router.routes).join(', ')}`, json, error);
   }
 

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

@@ -5,7 +5,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
-const { BASE_FILE } = require('./worktree.ts');
+const { BASE_FILE } = require('./worktree.js');
 
 // The checkouts of one repository: the main working tree and its linked worktrees.
 //
@@ -15,9 +15,9 @@ const { BASE_FILE } = require('./worktree.ts');
 // source that names every checkout, and it is asked once per process.
 
 /** realpath(cwd) -> listCheckouts result. */
-const cache = new Map<string, any>();
+const cache = new Map             ();
 
-function realOrNull(p: string, fsImpl: any): string | null {
+function realOrNull(p        , fsImpl     )                {
   try {
     return fsImpl.realpathSync(p);
   } catch {
@@ -25,7 +25,7 @@ function realOrNull(p: string, fsImpl: any): string | null {
   }
 }
 
-function failed(reason: string, detail: string): any {
+function failed(reason        , detail        )      {
   return {
     ok: false, reason, detail, current: null, main: null, mainReason: null, others: [], isLinked: false, sandbox: false,
   };
@@ -46,17 +46,17 @@ function failed(reason: string, detail: string): any {
  * @returns {{ok: boolean, reason: string|null, detail: string|null, current: string|null, main: string|null,
  *   mainReason: string|null, others: Array<string>, isLinked: boolean, sandbox: boolean}}
  */
-function listCheckouts({ cwd, exec = spawnSync, fsImpl = fs }: { cwd: string; exec?: any; fsImpl?: any }): any {
+function listCheckouts({ cwd, exec = spawnSync, fsImpl = fs }                                           )      {
   const realCwd = realOrNull(cwd, fsImpl) || path.resolve(cwd);
   if (cache.has(realCwd)) return cache.get(realCwd);
 
-  let res: any;
+  let res     ;
   try {
     res = exec('git', ['-C', realCwd, 'worktree', 'list', '--porcelain'], { encoding: 'utf8', timeout: 10000 });
-  } catch (error: any) {
+  } catch (error     ) {
     res = { error };
   }
-  let result: any;
+  let result     ;
   if (res && res.error) {
     result = res.error.code === 'ENOENT'
       ? failed('git-unavailable', String(res.error.message || '').trim().slice(0, 200))
@@ -71,8 +71,8 @@ function listCheckouts({ cwd, exec = spawnSync, fsImpl = fs }: { cwd: string; ex
   return result;
 }
 
-function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
-  const entries: Array<{ real: string | null; bare: boolean; sandbox: boolean }> = [];
+function fromPorcelain(stdout        , realCwd        , fsImpl     )      {
+  const entries                                                                  = [];
   for (const block of stdout.split(/\n\s*\n/)) {
     const lines = block.split('\n').filter(Boolean);
     if (lines.length === 0 || !lines[0].startsWith('worktree ')) continue;
@@ -84,7 +84,7 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
     });
   }
 
-  let current: any = null;
+  let current      = null;
   for (const e of entries) {
     if (e.real === null || e.bare) continue;
     if ((realCwd === e.real || realCwd.startsWith(e.real + path.sep)) && (current === null || e.real.length > current.real.length)) {
@@ -93,8 +93,8 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
   }
   const sandbox = Boolean(current && current.sandbox);
   const first = entries[0];
-  let main: string | null = null;
-  let mainReason: string | null = null;
+  let main                = null;
+  let mainReason                = null;
   if (sandbox) mainReason = 'sandbox';
   else if (first && first.bare) mainReason = 'bare';
   else if (!first || first.real === null) mainReason = 'missing';
@@ -102,7 +102,7 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
 
   const others = sandbox ? [] : entries
     .filter((e) => e.real !== null && !e.bare && !e.sandbox && e !== current)
-    .map((e) => e.real as string);
+    .map((e) => e.real          );
   const currentPath = current ? current.real : null;
   return {
     ok: true,
@@ -118,7 +118,7 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
 }
 
 /** Forgets every memoized `listCheckouts` result (tests that rebuild a repository in place). */
-function clearCheckoutCache(): void {
+function clearCheckoutCache()       {
   cache.clear();
 }
 
@@ -138,8 +138,8 @@ function clearCheckoutCache(): void {
  * @returns {{status: 'found'|'missing'|'ambiguous', file: string|null, root: string|null,
  *   origin: 'current'|'other'|null, candidates: Array<string>}}
  */
-function findStateFile({ stateRoot, relPath, exec = spawnSync, fsImpl = fs }: { stateRoot: string; relPath: any; exec?: any; fsImpl?: any }): any {
-  const at = (root: string, isCurrent: boolean): string | null => {
+function findStateFile({ stateRoot, relPath, exec = spawnSync, fsImpl = fs }                                                               )      {
+  const at = (root        , isCurrent         )                => {
     const rel = typeof relPath === 'function' ? relPath(root, isCurrent) : relPath;
     for (const candidate of Array.isArray(rel) ? rel : [rel]) {
       if (typeof candidate !== 'string' || candidate === '') continue;
@@ -148,21 +148,21 @@ function findStateFile({ stateRoot, relPath, exec = spawnSync, fsImpl = fs }: {
     }
     return null;
   };
-  const missing = { status: 'missing', file: null, root: null, origin: null, candidates: [] as string[] };
+  const missing = { status: 'missing', file: null, root: null, origin: null, candidates: []             };
 
   const here = at(stateRoot, true);
   if (here) return { status: 'found', file: here, root: stateRoot, origin: 'current', candidates: [] };
 
   const checkouts = listCheckouts({ cwd: stateRoot, exec, fsImpl });
   if (!checkouts.ok || checkouts.sandbox) return missing;
-  const matches: Array<{ file: string; root: string }> = [];
-  for (const root of checkouts.others as string[]) {
+  const matches                                        = [];
+  for (const root of checkouts.others            ) {
     const file = at(root, false);
     if (file) matches.push({ file, root });
   }
   if (matches.length === 0) return missing;
   if (matches.length > 1) {
-    return { status: 'ambiguous', file: null, root: null, origin: null, candidates: matches.map((m: { file: string }) => m.file) };
+    return { status: 'ambiguous', file: null, root: null, origin: null, candidates: matches.map((m                  ) => m.file) };
   }
   return { status: 'found', file: matches[0].file, root: matches[0].root, origin: 'other', candidates: [] };
 }

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

@@ -6,11 +6,11 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 // Shared with EvidenceLedger so both stores enforce one definition of a safe task id.
-const { assertSafeTaskId, EvidenceLedger } = require('./evidence-ledger.ts');
-const { updateTaskState, readTaskState, mergeRecords } = require('./task-state.ts');
-const { taskStoreDir } = require('./task-scope.ts');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { assertSafeTaskId, EvidenceLedger } = require('./evidence-ledger.js');
+const { updateTaskState, readTaskState, mergeRecords } = require('./task-state.js');
+const { taskStoreDir } = require('./task-scope.js');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 const CLAIM_STATUSES = new Set([
   'hypothesis',
@@ -38,15 +38,15 @@ const CLAIM_STATUSES = new Set([
 const TERMINAL_CLAIM_STATUSES = new Set(['retracted', 'superseded']);
 
 class ClaimsManager {
-  declare fsImpl: any;
-  declare evidenceLedger: any;
-  declare repoRoot: any;
-  declare fixedStateDir: any;
-  declare slug: any;
-  declare stateDir: any;
-  declare claimsMap: Map<any, any>;
-  declare baseline: Map<any, any>;
-  declare seq: number;
+                      
+                              
+                        
+                             
+                    
+                        
+                                   
+                                  
+                      
   /**
    * @param {Object} [options]
    * @param {Object} [options.evidenceLedger]
@@ -55,7 +55,7 @@ class ClaimsManager {
    * @param {string} [options.slug] feature whose namespace the records live under (see task-scope.js)
    * @param {Object} [options.fsImpl]
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     this.fsImpl = options.fsImpl || fs;
     this.evidenceLedger = options.evidenceLedger || null;
     this.repoRoot = options.repoRoot || REPO_ROOT;
@@ -68,7 +68,7 @@ class ClaimsManager {
   }
 
   /** Where this task's claims file lives: beside its evidence, in the feature's namespace when it has one. */
-  fileFor(taskId: any) {
+  fileFor(taskId     ) {
     const dir = this.fixedStateDir
       || taskStoreDir({ projectRoot: this.repoRoot, store: 'evidence', taskId, slug: this.slug });
     return path.join(dir, `${assertSafeTaskId(taskId)}_claims.json`);
@@ -87,7 +87,7 @@ class ClaimsManager {
    * @param {Object} item - { statement, taskId, status, id, role }
    * @returns {string} claimId
    */
-  addClaim(item: any): string {
+  addClaim(item     )         {
     if (!item || typeof item !== 'object') {
       throw new Error('Claim item must be an object');
     }
@@ -125,7 +125,7 @@ class ClaimsManager {
    * @param {string} id
    * @returns {Object|null}
    */
-  getClaim(id: string) {
+  getClaim(id        ) {
     return this.claimsMap.get(id) || null;
   }
 
@@ -135,7 +135,7 @@ class ClaimsManager {
    * @param {string} evidenceId
    * @param {'supports'|'contradicts'} [relation='supports']
    */
-  linkEvidence(claimId: string, evidenceId: string, relation = 'supports') {
+  linkEvidence(claimId        , evidenceId        , relation = 'supports') {
     const claim = this.claimsMap.get(claimId);
     if (!claim) {
       throw new Error(`Unknown claim '${claimId}'`);
@@ -174,7 +174,7 @@ class ClaimsManager {
    * @param {string} claimId
    * @returns {'hypothesis'|'supported'|'conflicted'|'invalidated'|'unknown'}
    */
-  evaluateClaim(claimId: string) {
+  evaluateClaim(claimId        ) {
     const claim = this.claimsMap.get(claimId);
     if (!claim) {
       throw new Error(`Unknown claim '${claimId}'`);
@@ -193,22 +193,28 @@ class ClaimsManager {
     }
 
     let hasFreshSupport = false;
-    let hasFreshContradiction = false;
     let hasStaleSupport = false;
+    let hasFreshContradiction = false;
+    let hasUnknownContradiction = false;
 
     for (const evId of claim.supportingEvidence) {
       const ev = this.evidenceLedger ? this.evidenceLedger.getEvidence(evId) : null;
       if (!ev || ev.freshness?.status === 'STALE') {
         hasStaleSupport = true;
-      } else {
+      } else if (ev.freshness?.status === 'FRESH') {
         hasFreshSupport = true;
       }
     }
 
     for (const evId of claim.contradictingEvidence) {
       const ev = this.evidenceLedger ? this.evidenceLedger.getEvidence(evId) : null;
-      if (ev && ev.freshness?.status !== 'STALE') {
-        hasFreshContradiction = true;
+      if (ev) {
+        const status = ev.freshness?.status;
+        if (status === 'FRESH') {
+          hasFreshContradiction = true;
+        } else if (status !== 'STALE') {
+          hasUnknownContradiction = true;
+        }
       }
     }
 
@@ -219,9 +225,12 @@ class ClaimsManager {
       // settled. Support that has merely gone stale still counts as support, so a claim that once
       // had backing stays 'conflicted' rather than being declared false on a technicality.
       claim.status = claim.supportingEvidence.length === 0 ? 'rejected' : 'conflicted';
+    } else if (hasUnknownContradiction) {
+      // A contradiction whose freshness is unknown cannot prove the claim false, so it never yields 'rejected' (DEC-016).
+      claim.status = claim.supportingEvidence.length > 0 ? 'conflicted' : 'hypothesis';
     } else if (hasFreshSupport) {
       claim.status = 'supported';
-    } else if (hasStaleSupport && !hasFreshSupport) {
+    } else if (hasStaleSupport) {
       claim.status = 'invalidated';
     } else {
       claim.status = 'hypothesis';
@@ -239,7 +248,7 @@ class ClaimsManager {
    * @param {string} [supersededBy]
    * @returns {string} the new status
    */
-  finalizeClaim(claimId: string, status: any, supersededBy?: string): string {
+  finalizeClaim(claimId        , status     , supersededBy         )         {
     const claim = this.claimsMap.get(claimId);
     if (!claim) {
       throw new Error(`Unknown claim '${claimId}'`);
@@ -260,7 +269,7 @@ class ClaimsManager {
    * @param {string} claimId
    * @returns {string} the new status
    */
-  retractClaim(claimId: string): string {
+  retractClaim(claimId        )         {
     return this.finalizeClaim(claimId, 'retracted');
   }
 
@@ -273,7 +282,7 @@ class ClaimsManager {
    * @param {string} replacedBy
    * @returns {string} the new status
    */
-  supersedeClaim(claimId: string, replacedBy: string): string {
+  supersedeClaim(claimId        , replacedBy        )         {
     // The target is checked first: validating the replacement before the claim being superseded
     // reported a missing replacement when the caller had actually mistyped the target, sending them
     // to fix the wrong id.
@@ -307,7 +316,7 @@ class ClaimsManager {
    * @param {string} [taskId]
    * @returns {Array<Object>}
    */
-  getClaims(taskId: string) {
+  getClaims(taskId        ) {
     const results = [];
     for (const claim of this.claimsMap.values()) {
       if (!taskId || claim.taskId === taskId) {
@@ -322,13 +331,13 @@ class ClaimsManager {
    * @param {string} [taskId='default']
    * @returns {string} filePath
    */
-  save(taskId = 'default'): string {
+  save(taskId = 'default')         {
     const targetFile = this.fileFor(taskId);
-    let merged: any;
+    let merged     ;
     const file = updateTaskState({
       fsImpl: this.fsImpl,
       file: targetFile,
-      build: (disk: any) => {
+      build: (disk     ) => {
         merged = mergeRecords(this.getClaims(taskId), disk?.claims || [], this.baseline);
         return { taskId, updatedAt: new Date().toISOString(), claimsCount: merged.length, claims: merged };
       },
@@ -345,7 +354,7 @@ class ClaimsManager {
    * @param {string} [taskId='default']
    * @returns {number}
    */
-  load(taskId = 'default'): number {
+  load(taskId = 'default')         {
     const targetFile = this.fileFor(taskId);
     const data = readTaskState(this.fsImpl, targetFile);
     if (data && Array.isArray(data.claims)) {
@@ -385,7 +394,7 @@ class ClaimsManager {
  * @param {string} [options.slug] feature the task belongs to, when not the branch's
  * @returns {number} exit code
  */
-function handleClaimCommand({ taskId, action = 'list', statement, claimId, evidenceId, replacedBy, relation = 'supports', role, json = false, stateRoot, slug }: any = {}): number {
+function handleClaimCommand({ taskId, action = 'list', statement, claimId, evidenceId, replacedBy, relation = 'supports', role, json = false, stateRoot, slug }      = {})         {
   const root = stateRoot || process.cwd();
   const ledger = new EvidenceLedger({ repoRoot: root, slug });
   ledger.load(taskId);
@@ -437,7 +446,7 @@ function handleClaimCommand({ taskId, action = 'list', statement, claimId, evide
     } else {
       return usageError('claim', `unknown --action '${action}'. Valid: list, add, link, retract, supersede`, json);
     }
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('claim', error.message, json, error);
   }
 

package/src/runtime/{cli-result.ts → cli-result.js}

@@ -11,12 +11,19 @@
  * it, and requires only the mask module.
  */
 
+const EXIT                         = Object.freeze({
+  OK: 0,
+  EMPTY: 1,
+  USAGE: 2,
+  OVERFLOW: 3,
+});
+
 /**
  * Sets the process exit code.
  * @param {number} code
  * @returns {number} the code, for chaining
  */
-function finishRuntime(code: number): number {
+function finishRuntime(code        )         {
   process.exitCode = code;
   return code;
 }
@@ -29,8 +36,8 @@ function finishRuntime(code: number): number {
  * @param {string} command the verb or installer command name
  * @param {number} exit the exit status the caller is about to produce
  */
-function captureCaught(error: any, command: string, exit: number): void {
-  try { require('./failure/capture.ts').captureError(error, { command, exit }); } catch { /* capture is best-effort */ }
+function captureCaught(error     , command        , exit        )       {
+  try { require('./failure/capture.js').captureError(error, { command, exit }); } catch { /* capture is best-effort */ }
 }
 
 /**
@@ -45,11 +52,11 @@ function captureCaught(error: any, command: string, exit: number): void {
  * @param {Error} [error]
  * @returns {number} 2 (USAGE error exit code)
  */
-function usageError(verb: string, message: string, json?: boolean, error?: Error): number {
-  if (error !== undefined) captureCaught(error, verb, 2);
-  if (json) console.log(JSON.stringify({ ok: false, status: 'USAGE', exitCode: 2, error: 'usage', summary: message }, null, 2));
+function usageError(verb        , message        , json          , error        )         {
+  if (error !== undefined) captureCaught(error, verb, EXIT.USAGE);
+  if (json) console.log(JSON.stringify({ ok: false, status: 'USAGE', exitCode: EXIT.USAGE, error: 'usage', summary: message }, null, 2));
   else console.error(`doflow ${verb}: ${message}`);
-  return finishRuntime(2);
+  return finishRuntime(EXIT.USAGE);
 }
 
-module.exports = { finishRuntime, usageError, captureCaught };
+module.exports = { finishRuntime, usageError, captureCaught, EXIT };