@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/src/runtime/mcp-consultations.js

@@ -164,11 +164,33 @@ function knownServerIds(registry     )              {
   return ids;
 }
 
+const MANIFEST_PATTERNS = Object.freeze([
+  /(?:^|[\\/])package(?:-lock)?\.json$/,
+  /(?:^|[\\/])pnpm-lock\.yaml$/,
+  /(?:^|[\\/])yarn\.lock$/,
+  /(?:^|[\\/])Cargo\.(?:toml|lock)$/,
+  /(?:^|[\\/])go\.(?:mod|sum)$/,
+  /(?:^|[\\/])requirements.*\.txt$/,
+  /(?:^|[\\/])pyproject\.toml$/,
+  /(?:^|[\\/])poetry\.lock$/,
+  /(?:^|[\\/])Gemfile(?:\.lock)?$/,
+  /(?:^|[\\/])composer\.(?:json|lock)$/,
+  /(?:^|[\\/])build\.gradle(?:\.kts)?$/,
+  /(?:^|[\\/])pom\.xml$/,
+  /(?:^|[\\/])Package\.swift$/,
+  /(?:^|[\\/])Podfile(?:\.lock)?$/,
+]);
+
+function touchesManifest(files           )          {
+  if (!Array.isArray(files) || files.length === 0) return false;
+  return files.some((f) => MANIFEST_PATTERNS.some((pattern) => pattern.test(f)));
+}
+
 /**
  * Servers a stage run names (IC-001 meaning). Sorted.
- * @param {{registry: object, skill: string, stageId?: string, taskId?: string, requests?: {list: Function}}} input
+ * @param {{registry: object, skill: string, stageId?: string, taskId?: string, requests?: {list: Function}, taskClass?: string, diffFiles?: string[]}} input
  */
-function namedServers({ registry, skill, stageId, taskId, requests }     )           {
+function namedServers({ registry, skill, stageId, taskId, requests, taskClass, diffFiles }     )           {
   let researchRequested                     ;
   const hasRequest = ()          => {
     if (researchRequested === undefined) {
@@ -178,12 +200,21 @@ function namedServers({ registry, skill, stageId, taskId, requests }     )
     }
     return researchRequested;
   };
+
+  const isDependencyChange = taskClass === 'dependency-change';
+  const hasManifestDiff = touchesManifest(diffFiles);
+
   const named = new Set        ();
   for (const server of registry?.mcp || []) {
     for (const step of server.steps || []) {
-      if (step.expectedWhen === 'research-request') {
-        if (hasRequest()) named.add(server.id);
-      } else if (step.skill === skill) {
+      if (step.skill !== skill) continue;
+      if (!step.expectedWhen) {
+        named.add(server.id);
+      } else if (step.expectedWhen === 'research-request' && hasRequest()) {
+        named.add(server.id);
+      } else if (step.expectedWhen === 'dependency-change' && isDependencyChange) {
+        named.add(server.id);
+      } else if (step.expectedWhen === 'manifest-review' && hasManifestDiff) {
         named.add(server.id);
       }
     }
@@ -213,13 +244,14 @@ const bySortKey = (a     , b     )         => (a < b ? -1 : a > b ? 1 : 0);
 function resolveConsultations({
   taskId = null, stageId = null, skill, flags, registry, ledger, requests,
   briefRecords = [], readReport, reach, addCommand, harnessName, since = null,
+  taskClass = null, diffFiles = [],
 }      = {})                                                                         {
   const warnings        = [];
   const notices        = [];
   const evidenceToAdd        = [];
   const registered = new Set((registry?.mcp || []).map((server     ) => server.id));
   const known = knownServerIds(registry);
-  const named = namedServers({ registry, skill, stageId, taskId, requests });
+  const named = namedServers({ registry, skill, stageId, taskId, requests, taskClass, diffFiles });
 
   // Rule 1: flags.
   const parsedFlags = parseMcpOutcomeFlags(flags);
@@ -408,5 +440,7 @@ module.exports = {
   parseMcpOutcomeFlags,
   parseToolsUsed,
   namedServers,
+  touchesManifest,
+  MANIFEST_PATTERNS,
   resolveConsultations,
 };

package/src/runtime/model-router.js

@@ -39,22 +39,58 @@ function availableProviderIds({ fsImpl = fs }                   = {})
     .map(([id]) => id);
 }
 
+function normalizeFamilyList(value     )           {
+  const values = Array.isArray(value) ? value : [value];
+  return [...new Set(values.flatMap((entry) => String(entry ?? '').split(',').map((family) => family.trim().toLowerCase()).filter(Boolean)))];
+}
+
+// families is a hand-kept stopgap; the model-facts registry (roadmap row 105) supersedes it and this field is removed then.
+/** An unknown family is not evidence that a provider can review outside the author's family. */
+function familyInfo(families     , excludedFamilies             )                                                                                               {
+  const declared = Array.isArray(families) ? families : [];
+  const hasUnknown = declared.length === 0
+    || declared.some((family) => typeof family !== 'string' || !/^[a-z][a-z0-9-]*$/.test(family) || family === 'unknown');
+  const overlapsAuthor = declared.some((family) => typeof family === 'string'
+    && family !== 'unknown' && /^[a-z][a-z0-9-]*$/.test(family) && excludedFamilies.has(family));
+  const familyRelation = overlapsAuthor ? 'overlaps-author' : hasUnknown ? 'unverified' : 'cross-family';
+  const sameFamily = declared.length > 0 && declared.every((family) => typeof family === 'string' && excludedFamilies.has(family));
+  return {
+    families: [...declared],
+    familyVerified: familyRelation === 'cross-family',
+    familyRelation,
+    sameFamily,
+  };
+}
+
 /**
  * Resolve one role to ranked candidates.
  * Ordering: available first, then preferred-tier match, then fallback-tier match, registry order
- * breaking ties. `exclude` drops provider ids entirely (e.g. the implementer when the role is
- * review with require:different-family) and is reported back rather than hidden.
+ * breaking ties. `exclude` drops provider ids entirely; `excludeFamilies` drops providers whose
+ * complete, known catalogue is within the excluded model families. Unknown catalogues are kept
+ * unverified rather than being presented as cross-family.
  * Availability unknown stays null — absence of evidence is not reported as absent.
  */
-function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }      = {})      {
+function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [], excludeFamilies }      = {})      {
   const role = (registry.modelRoles || []).find((entry     ) => entry.id === roleId);
   if (!role) {
     throw new Error(`Unknown model role '${roleId}'; valid: ${(registry.modelRoles || []).map((r     ) => r.id).join(', ')}`);
   }
   const excluded = new Set(exclude);
+  const familyMode = excludeFamilies !== undefined && excludeFamilies !== null;
+  const normalizedFamilies = familyMode ? normalizeFamilyList(excludeFamilies) : [];
+  if (familyMode && normalizedFamilies.length === 0) {
+    throw new Error('--exclude-family requires at least one family name');
+  }
+  const excludedFamilies = new Set(normalizedFamilies);
   const candidates        = [];
+  const familyExcluded           = [];
   for (const [index, provider] of (registry.modelProviders || []).entries()) {
     if (excluded.has(provider.id)) continue;
+    const family = familyInfo(provider.families, excludedFamilies);
+    if (familyMode && family.sameFamily) {
+      familyExcluded.push(provider.id);
+      continue;
+    }
     const tiers = provider.tiers ?? [];
     candidates.push({
       id: provider.id,
@@ -64,6 +100,7 @@ function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }
       available: isAvailable ? Boolean(isAvailable(provider.id)) : null,
       servesPreferredTier: role.prefer ? tiers.includes(role.prefer) : null,
       servesFallbackTier: role.fallback ? tiers.includes(role.fallback) : null,
+      ...(familyMode ? { families: family.families, familyRelation: family.familyRelation, familyVerified: family.familyVerified } : {}),
       _index: index,
     });
   }
@@ -79,12 +116,19 @@ function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }
     return 0;
   });
   for (const candidate of candidates) delete candidate._index;
-  return {
+  const result      = {
     roleId,
     policy: { prefer: role.prefer ?? null, fallback: role.fallback ?? null, require: role.require ?? null },
     candidates,
     excluded: [...excluded],
   };
+  // Keep the established result shape byte-for-byte for callers that do not request family
+  // filtering. Family metadata is included whenever that comparison is requested.
+  if (familyMode) {
+    result.excludedFamilies = [...excludedFamilies];
+    result.familyExcluded = familyExcluded;
+  }
+  return result;
 }
 
 /**
@@ -118,7 +162,7 @@ function resolveRetrievalSlot({ registry, slotId, isAvailable = null }      = {}
 
 /** CLI handler for `doflow model-role`. Read-only advisory routing; exits 1 on an unknown role
  * because a silently-empty candidate list would read as "no providers" rather than "bad input". */
-function handleModelRoleCommand({ role, exclude, json = false, repoRoot }      = {})                     {
+function handleModelRoleCommand({ role, exclude, excludeFamilies, json = false, repoRoot }      = {})                     {
   if (!role) return usageError('model-role', '--role is required (one of the roles in core/registry/models.json)', json);
   const registry = (() => {
     try { return loadRegistry({ repoRoot: repoRoot || REPO_ROOT }); }
@@ -127,20 +171,48 @@ function handleModelRoleCommand({ role, exclude, json = false, repoRoot }      =
   if (!registry) return undefined;
   const available = new Set(availableProviderIds());
   try {
+    const excludedProviderIds = Array.isArray(exclude) ? exclude : String(exclude ?? '').split(',').map((s        ) => s.trim()).filter(Boolean);
+    const requestedFamilies = excludeFamilies === undefined || excludeFamilies === null ? null : normalizeFamilyList(excludeFamilies);
+    if (requestedFamilies !== null) {
+      const knownFamilies = [...new Set((registry.modelProviders || []).flatMap((provider     ) => provider.families || []))]
+        .filter((family)                   => typeof family === 'string' && family !== 'unknown').sort();
+      const knownSet = new Set(knownFamilies);
+      const unknownFamilies = requestedFamilies.filter((family) => !knownSet.has(family));
+      if (requestedFamilies.length === 0) {
+        return usageError('model-role', `--exclude-family requires at least one family name; known families: ${knownFamilies.join(', ') || '(none)'}`, json);
+      }
+      if (requestedFamilies.includes('unknown')) {
+        return usageError('model-role', `unknown cannot be excluded because it names missing knowledge; known families: ${knownFamilies.join(', ') || '(none)'}`, json);
+      }
+      if (unknownFamilies.length) {
+        return usageError('model-role', `unknown family name${unknownFamilies.length === 1 ? '' : 's'}: ${unknownFamilies.join(', ')}; known families: ${knownFamilies.join(', ') || '(none)'}`, json);
+      }
+    }
     const resolution = resolveModelRole({
       registry,
       roleId: role,
       isAvailable: (providerId        ) => available.has(providerId),
-      exclude: Array.isArray(exclude) ? exclude : String(exclude ?? '').split(',').map((s        ) => s.trim()).filter(Boolean),
+      exclude: excludedProviderIds,
+      ...(requestedFamilies === null ? {} : { excludeFamilies: requestedFamilies }),
     });
     if (json) console.log(JSON.stringify(resolution, null, 2));
     else {
       console.log(`Role '${resolution.roleId}' — prefer:${resolution.policy.prefer ?? '—'} fallback:${resolution.policy.fallback ?? '—'} require:${resolution.policy.require ?? '—'}`);
       for (const candidate of resolution.candidates) {
         const availability = candidate.available === null ? '?' : candidate.available ? 'yes' : 'no';
-        console.log(`  ${candidate.available ? '*' : ' '} ${candidate.id} (${candidate.kind}, via ${candidate.backendCli ?? 'hosted'}) available=${availability}${resolution.policy.prefer && candidate.servesPreferredTier ? ` serves ${resolution.policy.prefer}` : ''}`);
+        const familyStatus = requestedFamilies === null ? ''
+          : ` ${candidate.familyRelation}`;
+        console.log(`  ${candidate.available ? '*' : ' '} ${candidate.id} (${candidate.kind}, via ${candidate.backendCli ?? 'hosted'}) available=${availability}${resolution.policy.prefer && candidate.servesPreferredTier ? ` serves ${resolution.policy.prefer}` : ''}${familyStatus}`);
       }
       if (resolution.excluded.length) console.log(`Excluded: ${resolution.excluded.join(', ')}`);
+      if (requestedFamilies !== null) {
+        const familySet = new Set(requestedFamilies);
+        const providerExcluded = new Set(excludedProviderIds);
+        const sameFamily = (registry.modelProviders || []).filter((provider     ) => !providerExcluded.has(provider.id)
+          && familyInfo(provider.families, familySet).sameFamily);
+        for (const provider of sameFamily) console.log(`  ${provider.id} same-family (excluded)`);
+        if (resolution.excludedFamilies.length) console.log(`Excluded families: ${resolution.excludedFamilies.join(', ')}`);
+      }
     }
     return finishRuntime(0);
   } catch (error     ) {

package/src/runtime/models/catalogue.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { PROBES, HARNESS_IDS } = require('../worker/probes/index.js');
+const { configHome } = require('../config-home.js');
+
+                                                                              
+                                                                     
+                                                            
+
+                               
+             
+                       
+                  
+ 
+
+                               
+                                        
+                   
+ 
+
+                                    
+                    
+                 
+                     
+                         
+                         
+                             
+                             
+                                 
+                                     
+                       
+                       
+ 
+
+                                                
+
+                                    
+                  
+                   
+                                             
+ 
+
+function getProjectCataloguePath(projectRoot        )         {
+  return path.join(projectRoot, '.doflow', 'state', 'models', 'catalogue.json');
+}
+
+function getUserCataloguePath(homeDir         , env      = process.env)         {
+  if (homeDir) {
+    return path.join(homeDir, '.config', 'doflow', 'state', 'models-observed.json');
+  }
+  const { dir } = configHome(env);
+  const baseDir = dir || path.join(os.homedir(), '.config', 'doflow');
+  return path.join(baseDir, 'state', 'models-observed.json');
+}
+
+function resolveProjectRoot(projectRoot         , fsImpl      = fs)                {
+  if (projectRoot) return path.resolve(projectRoot);
+  try {
+    const { projectRoot: findRoot } = require('../lifecycle/root.js');
+    const root = findRoot(process.cwd());
+    if (root && fsImpl.existsSync(path.join(root, '.doflow'))) return root;
+  } catch {
+    // fallback
+  }
+  if (fsImpl.existsSync(path.join(process.cwd(), '.doflow'))) {
+    return process.cwd();
+  }
+  return null;
+}
+
+function readCatalogue(
+  projectRoot         ,
+  options                                                = {}
+)                           {
+  const fsImpl = options.fsImpl || fs;
+  const root = projectRoot ? path.resolve(projectRoot) : resolveProjectRoot(undefined, fsImpl);
+
+  if (root) {
+    const projPath = getProjectCataloguePath(root);
+    if (fsImpl.existsSync(projPath)) {
+      try {
+        const raw = fsImpl.readFileSync(projPath, 'utf8');
+        return JSON.parse(raw);
+      } catch (err     ) {
+        if (err instanceof SyntaxError) {
+          const corrupt = `${projPath}.corrupt-${Date.now()}`;
+          try {
+            fsImpl.renameSync(projPath, corrupt);
+          } catch {
+            // best-effort
+          }
+          return null;
+        }
+        return null;
+      }
+    }
+  }
+
+  // Fallback to user cache
+  const userPath = getUserCataloguePath(options.homeDir, options.env);
+  if (fsImpl.existsSync(userPath)) {
+    try {
+      const raw = fsImpl.readFileSync(userPath, 'utf8');
+      return JSON.parse(raw);
+    } catch (err     ) {
+      if (err instanceof SyntaxError) {
+        const corrupt = `${userPath}.corrupt-${Date.now()}`;
+        try {
+          fsImpl.renameSync(userPath, corrupt);
+        } catch {
+          // best-effort
+        }
+        return null;
+      }
+      return null;
+    }
+  }
+
+  return null;
+}
+
+function writeCatalogue(
+  catalogue                   ,
+  projectRoot         ,
+  options                                                = {}
+)       {
+  const fsImpl = options.fsImpl || fs;
+  const root = projectRoot ? path.resolve(projectRoot) : resolveProjectRoot(undefined, fsImpl);
+  const targetPath = root ? getProjectCataloguePath(root) : getUserCataloguePath(options.homeDir, options.env);
+
+  const targetDir = path.dirname(targetPath);
+  fsImpl.mkdirSync(targetDir, { recursive: true });
+
+  const tmpPath = `${targetPath}.${process.pid}.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`;
+  fsImpl.writeFileSync(tmpPath, JSON.stringify(catalogue, null, 2), 'utf8');
+  fsImpl.renameSync(tmpPath, targetPath);
+}
+
+async function syncHarness(
+  harnessId        ,
+  options                                                                                                              = {}
+)                             {
+  const probe = PROBES[harnessId];
+  if (!probe) {
+    return {
+      harnessId,
+      binary: harnessId,
+      installed: false,
+      version: null,
+      loginState: 'unsupported',
+      reloginHint: null,
+      detectedMode: 'unverified',
+      derivedBilling: 'unknown',
+      offeredModels: [],
+      lastSyncedAt: new Date().toISOString(),
+    };
+  }
+
+  return await probe(options);
+}
+
+async function syncAllHarnesses(
+  options                                                                                                              = {}
+)                             {
+  const results                                    = {};
+  for (const id of HARNESS_IDS) {
+    results[id] = await syncHarness(id, options);
+  }
+
+  const catalogue                    = {
+    version: 1,
+    syncedAt: new Date().toISOString(),
+    harnesses: results,
+  };
+
+  writeCatalogue(catalogue, options.projectRoot, options);
+  return catalogue;
+}
+
+module.exports = {
+  getProjectCataloguePath,
+  getUserCataloguePath,
+  readCatalogue,
+  writeCatalogue,
+  syncHarness,
+  syncAllHarnesses,
+};

package/src/runtime/models/command.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const { readCatalogue, writeCatalogue, syncHarness, syncAllHarnesses } = require('./catalogue.js');
+const { readAllowedModels } = require('../worker/models.js');
+const { finishRuntime, usageError } = require('../cli-result.js');
+const { HARNESS_IDS } = require('../worker/probes/index.js');
+
+async function handleModelsCommand({
+  action,
+  actionGiven,
+  positional,
+  harness,
+  model,
+  json = false,
+  projectRoot = process.cwd(),
+  env = process.env,
+}     )                  {
+  const act = actionGiven ? action : (action || (positional && positional[0]) || 'list');
+
+  if (act === 'sync') {
+    if (harness) {
+      if (!HARNESS_IDS.includes(harness)) {
+        return usageError('models', `unknown harness '${harness}'; expected one of: ${HARNESS_IDS.join(', ')}`, json);
+      }
+      const res = await syncHarness(harness, { projectRoot });
+      const catalogue = readCatalogue(projectRoot) || {
+        version: 1,
+        syncedAt: new Date().toISOString(),
+        harnesses: {},
+      };
+      catalogue.harnesses[harness] = res;
+      catalogue.syncedAt = new Date().toISOString();
+      writeCatalogue(catalogue, projectRoot);
+
+      if (json) {
+        console.log(JSON.stringify(res, null, 2));
+      } else {
+        const hint = res.loginState === 'logged-out' && res.reloginHint ? ` (re-login: ${res.reloginHint})` : '';
+        console.log(`Synced harness '${harness}': ${res.loginState}${hint}, mode: ${res.detectedMode}, billing: ${res.derivedBilling}, models: ${res.offeredModels.length}`);
+      }
+      return finishRuntime(0);
+    }
+
+    const catalogue = await syncAllHarnesses({ projectRoot });
+    if (json) {
+      console.log(JSON.stringify(catalogue, null, 2));
+    } else {
+      console.log(`Synced ${Object.keys(catalogue.harnesses).length} harness(es) at ${catalogue.syncedAt}`);
+      for (const [id, h] of Object.entries(catalogue.harnesses)) {
+        const hint = h.loginState === 'logged-out' && h.reloginHint ? ` (re-login: ${h.reloginHint})` : '';
+        console.log(`  ${id.padEnd(14)} ${h.loginState.padEnd(12)} mode: ${h.detectedMode.padEnd(14)} billing: ${h.derivedBilling.padEnd(9)} models: ${h.offeredModels.length}${hint}`);
+      }
+    }
+    return finishRuntime(0);
+  }
+
+  if (act === 'list') {
+    const catalogue = readCatalogue(projectRoot);
+    const allowed = readAllowedModels({ env, projectRoot }) || [];
+    const rows        = [];
+
+    if (catalogue && catalogue.harnesses) {
+      for (const [harnessId, h] of Object.entries(catalogue.harnesses)) {
+        for (const m of h.offeredModels || []) {
+          rows.push({
+            harness: harnessId,
+            model: m.id,
+            displayName: m.displayName || m.id,
+            loginState: h.loginState,
+            status: allowed.includes(m.id) ? 'enabled' : 'listed',
+          });
+        }
+      }
+    }
+
+    if (rows.length === 0) {
+      if (json) console.log(JSON.stringify({ models: [] }, null, 2));
+      else console.log('No observed models. Run `doflow models --action sync` to probe worker pool.');
+      return finishRuntime(0);
+    }
+
+    if (json) {
+      console.log(JSON.stringify(rows, null, 2));
+    } else {
+      console.log(`Observed Models (${rows.length}):`);
+      console.log(`  ${'HARNESS'.padEnd(14)} ${'MODEL'.padEnd(28)} ${'LOGIN'.padEnd(12)} ${'STATUS'}`);
+      for (const row of rows) {
+        console.log(`  ${row.harness.padEnd(14)} ${row.model.padEnd(28)} ${row.loginState.padEnd(12)} ${row.status}`);
+      }
+    }
+    return finishRuntime(0);
+  }
+
+  if (act === 'describe') {
+    if (!model || typeof model !== 'string') {
+      return usageError('models', '--model <id> is required for describe action', json);
+    }
+
+    const catalogue = readCatalogue(projectRoot);
+    const allowed = readAllowedModels({ env, projectRoot }) || [];
+    const matchingHarnesses        = [];
+    let modelMeta      = null;
+
+    if (catalogue && catalogue.harnesses) {
+      for (const [harnessId, h] of Object.entries(catalogue.harnesses)) {
+        const found = (h.offeredModels || []).find((m     ) => m.id === model);
+        if (found) {
+          if (!modelMeta) modelMeta = found;
+          matchingHarnesses.push({
+            harnessId,
+            loginState: h.loginState,
+            detectedMode: h.detectedMode,
+            derivedBilling: h.derivedBilling,
+          });
+        }
+      }
+    }
+
+    if (matchingHarnesses.length === 0) {
+      if (json) {
+        console.log(JSON.stringify({ error: 'not-found', model }, null, 2));
+      } else {
+        console.error(`doflow models: model '${model}' not found in observed catalogue. Run 'doflow models --action sync' to refresh.`);
+      }
+      return finishRuntime(1);
+    }
+
+    const detail = {
+      model,
+      displayName: modelMeta?.displayName || model,
+      family: modelMeta?.family || 'unknown',
+      status: allowed.includes(model) ? 'enabled' : 'listed',
+      harnesses: matchingHarnesses,
+    };
+
+    if (json) {
+      console.log(JSON.stringify(detail, null, 2));
+    } else {
+      console.log(`Model: ${detail.model} (${detail.displayName})`);
+      console.log(`  Family: ${detail.family}`);
+      console.log(`  Status: ${detail.status}`);
+      console.log('  Offering Harnesses:');
+      for (const h of detail.harnesses) {
+        console.log(`    - ${h.harnessId}: ${h.loginState} (mode: ${h.detectedMode}, billing: ${h.derivedBilling})`);
+      }
+    }
+    return finishRuntime(0);
+  }
+
+  return usageError('models', `unknown action '${act}'; expected sync, list, or describe`, json);
+}
+
+module.exports = { handleModelsCommand };

package/src/runtime/off-words.js

@@ -0,0 +1,12 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+/** Common opt-out values used without loading the settings resolver. */
+const OFF_WORDS = new Set(['off', '0', 'false', 'no']);
+
+function isOffWord(value         )          {
+  return typeof value === 'string' && OFF_WORDS.has(value.trim().toLowerCase());
+}
+
+module.exports = { OFF_WORDS, isOffWord };

package/src/runtime/outcome.js

@@ -43,7 +43,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { EvidenceLedger, assertSafeTaskId } = require('./evidence-ledger.js');
-const { taskStoreDir } = require('./task-scope.js');
+const { taskStoreDir, taskRecord } = require('./task-scope.js');
 // The two verdict vocabularies, imported from the modules that own them rather than respelled
 // here. A second copy would let this file accept a readiness state readiness itself has retired.
 const { READINESS_STATES } = require('./readiness.js');
@@ -55,7 +55,7 @@ const { planPath, UNREACHED } = require('./retrieval-plan.js');
 // One definition of the score refusal, applied at a further boundary. See the note on
 // EVIDENCE_SCORE_FIELDS in cli.js: a terminal state that carried a confidence would be exactly the
 // number NFR-001 exists to keep out of the one record the next worker reads first.
-const { assertNoScoreFields } = require('./cli.js');
+const { assertNoScoreFields } = require('./evidence-fields.js');
 const { finishRuntime, usageError } = require('./cli-result.js');
 const { REPO_ROOT } = require('../helper/repo-root.js');
 
@@ -107,7 +107,7 @@ function outcomePath(projectRoot     , taskId     , slug      = null) {
  * @returns {Object|null} the record, or null when no outcome was recorded
  */
 function readOutcome(projectRoot     , taskId     , slug      = null) {
-  const file = outcomePath(projectRoot, taskId, slug);
+  const file = taskRecord({ projectRoot, store: 'outcome', taskId: assertSafeTaskId(taskId), slug }).read;
   if (!fs.existsSync(file)) return null;
   try {
     return JSON.parse(fs.readFileSync(file, 'utf8'));