@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/src/runtime/review/identity.js

@@ -0,0 +1,255 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+/**
+ * 119 C.1 (IC-002, D-5, FR-007): the IO half of reviewer independence. `crossCheckAuthor` reads the reviewed head's
+ * `Co-Authored-By` trailers and the slug's task-attempt owners and reports where they contradict the record's
+ * `author` claim. The author is a claim (design R5): this catches mistakes and contradictions, not an adversary.
+ * Never throws; every failure to read is an `author-unchecked:*` advisory.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+
+                                              
+                                                                                                       
+
+// Inherited location variables would point the check at another repository (C-8); same set as command.ts.
+const GIT_LOCATION_KEYS = Object.freeze([
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_OBJECT_DIRECTORY', 'GIT_COMMON_DIR',
+  'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+]);
+
+function defaultGit(args          , cwd        , env     )                                             {
+  const gitEnv = { ...env };
+  for (const key of GIT_LOCATION_KEYS) delete gitEnv[key];
+  return spawnSync('git', ['-C', cwd, ...args], { cwd, env: gitEnv, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+}
+
+/** The known (non-`unknown`) model families of core/registry/models.json; `null` when the registry cannot be read. */
+function knownFamilies()                  {
+  try {
+    const models = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'core', 'registry', 'models.json'), 'utf8'));
+    return [...new Set        (models.providers.flatMap((provider     ) => provider.families))].filter((family) => family !== 'unknown');
+  } catch { return null; }
+}
+
+/** A trailer value mapped to a known family it names (`Claude Sonnet 5.5 <...>` -> `claude`), else `unknown`. */
+function trailerFamily(value        , families          )         {
+  return families.find((family) => new RegExp(`(?<![a-z0-9])${family}(?![a-z0-9])`, 'i').test(value)) ?? 'unknown';
+}
+
+function trailerAdvisories(record     , cwd        , env     , git           )           {
+  const families = knownFamilies();
+  let values          ;
+  try {
+    const run = git(['log', '-1', '--format=%(trailers:key=Co-Authored-By,valueonly)', record.reviewedHead], cwd, env);
+    if (run?.status !== 0 || typeof run.stdout !== 'string') return ['author-unchecked:trailers'];
+    values = run.stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch { return ['author-unchecked:trailers']; }
+  if (values.length === 0 || record.author.family === 'unknown') return [];
+  if (families === null) return ['author-unchecked:trailers'];
+  const claimsClaude = values.some((value) => trailerFamily(value, families) === 'claude');
+  return claimsClaude !== (record.author.family === 'claude') ? ['author-trailer-contradiction'] : [];
+}
+
+function attemptAdvisories(record     , cwd        , readFile                          )           {
+  let text        ;
+  try {
+    const { projectRoot } = require('../lifecycle/root.js');
+    const { storeFile } = require('../task-attempts.js');
+    text = readFile(storeFile(projectRoot(cwd), record.slug));
+  } catch (error     ) {
+    return error?.code === 'ENOENT' ? [] : ['author-unchecked:attempts'];
+  }
+  let owners          ;
+  try {
+    const tasks = JSON.parse(text).tasks;
+    if (tasks === null || typeof tasks !== 'object' || Array.isArray(tasks)) return ['author-unchecked:attempts'];
+    owners = [];
+    for (const task of Object.values     (tasks)) {
+      if (!Array.isArray(task?.attempts)) return ['author-unchecked:attempts'];
+      for (const attempt of task.attempts) {
+        if (typeof attempt?.owner !== 'string') return ['author-unchecked:attempts'];
+        owners.push(attempt.owner);
+      }
+    }
+  } catch { return ['author-unchecked:attempts']; }
+  return owners.length > 0 && !owners.includes(record.author.agent) ? ['author-attempt-contradiction'] : [];
+}
+
+/**
+ * Advisories contradicting a valid record's `author` claim, sorted. `git` and `readFile` are injectable for tests.
+ * @param record a record that passed validateFindings and holds `author`
+ */
+function crossCheckAuthor({ record, cwd, env = process.env, git = defaultGit, readFile = (file        ) => fs.readFileSync(file, 'utf8') }     )           {
+  try {
+    return [...trailerAdvisories(record, cwd, env, git), ...attemptAdvisories(record, cwd, readFile)].sort();
+  } catch {
+    return ['author-unchecked:attempts', 'author-unchecked:trailers'];
+  }
+}
+
+                          
+                                                         
+                  
+                
+                                
+  
+
+/**
+ * 120 D.1 (IC-015, IC-016): extracts the read-only authoring identities of a slug.
+ * Returns flat identity rows from:
+ * 1. The record's `author` (channel 'claim').
+ * 2. Every dispatch of the slug's dispatch runs that reached submit:
+ *    - subagent: requested (channel 'observed' when descriptor model status is 'supported', else 'claim')
+ *      and served (channel 'observed').
+ *    - sequential: harness from primary snapshot, model from requested binding or 'unknown' (channel 'claim').
+ * 3. The primary when author.harness equals the primary harness (channel 'observed' when confirmed, else 'claim').
+ */
+function authoringIdentities({
+  slug,
+  cwd = process.cwd(),
+  env = process.env,
+  record = null,
+  registry = null,
+  primary: primaryOverride = null,
+  fsImpl = fs,
+}   
+                
+               
+            
+               
+                 
+                
+               
+  = {})                      {
+  const rows                      = [];
+
+  // 1. Record's author
+  if (record?.author && typeof record.author === 'object') {
+    const authorHarness = typeof record.author.harness === 'string' && record.author.harness.length > 0 ? record.author.harness : null;
+    const authorModel = typeof record.author.model === 'string' && record.author.model.length > 0 ? record.author.model : 'unknown';
+    if (authorHarness !== null) {
+      rows.push({
+        kind: 'record',
+        harness: authorHarness,
+        model: authorModel,
+        channel: 'claim',
+      });
+
+      // 3. Primary joins when record's author names primary
+      try {
+        let primary = primaryOverride;
+        if (!primary) {
+          const { resolvePrimary } = require('../context/primary.js');
+          primary = resolvePrimary({ projectRoot: cwd ? path.resolve(cwd) : process.cwd(), cwd, env, registry });
+        }
+        if (primary && primary.harness && primary.harness === authorHarness) {
+          rows.push({
+            kind: 'primary',
+            harness: primary.harness,
+            model: typeof primary.model === 'string' && primary.model.length > 0 ? primary.model : 'unknown',
+            channel: primary.state === 'confirmed' ? 'observed' : 'claim',
+          });
+        }
+      } catch {}
+    }
+  }
+
+  // 2. Dispatches in dispatch store
+  if (slug && typeof slug === 'string') {
+    try {
+      const { projectRoot } = require('../lifecycle/root.js');
+      const { storeFileFor, readDispatch } = require('../dispatch/store.js');
+      const root = projectRoot(cwd);
+      const file = storeFileFor(root, slug);
+      if (fsImpl.existsSync(file)) {
+        const store = readDispatch(file, fsImpl);
+        const dispatches = store?.dispatches && typeof store.dispatches === 'object' ? Object.values(store.dispatches) : [];
+
+        // Descriptor model status lookup
+        let descriptors                      = {};
+        try {
+          const { loadRegistry } = require('../../registry/index.js');
+          const reg = registry || loadRegistry({ repoRoot: REPO_ROOT });
+          for (const h of reg.harnesses || []) {
+            if (h.worker && typeof h.worker === 'object') {
+              descriptors[h.id] = h.worker;
+            }
+          }
+        } catch {}
+
+        for (const d of dispatches         ) {
+          if (!d || typeof d !== 'object') continue;
+          const reachedSubmit = Boolean(
+            d.collectedAt ||
+            d.phase === 'collected' ||
+            d.phase === 'integrating' ||
+            (d.phase === 'ended' && (d.commit || d.report || d.collectedAt))
+          );
+          if (!reachedSubmit) continue;
+
+          if (d.mode === 'subagent') {
+            const harness = typeof d.harness === 'string' && d.harness.length > 0 ? d.harness : 'unknown';
+            const desc = descriptors[harness];
+            const isSupported = desc?.model?.status === 'supported' && Array.isArray(desc.model?.argv);
+
+            if (typeof d.model?.served === 'string' && d.model.served.length > 0) {
+              rows.push({
+                kind: 'subagent',
+                harness,
+                model: d.model.served,
+                channel: 'observed',
+              });
+            }
+
+            if (typeof d.model?.requested === 'string' && d.model.requested.length > 0) {
+              rows.push({
+                kind: 'subagent',
+                harness,
+                model: d.model.requested,
+                channel: isSupported ? 'observed' : 'claim',
+              });
+            }
+
+            if (!d.model?.served && !d.model?.requested) {
+              rows.push({
+                kind: 'subagent',
+                harness,
+                model: 'unknown',
+                channel: 'claim',
+              });
+            }
+          } else if (d.mode === 'sequential') {
+            const harness = d.primary?.harness ?? (typeof d.harness === 'string' && d.harness.length > 0 ? d.harness : 'unknown');
+            const model = typeof d.model?.requested === 'string' && d.model.requested.length > 0 ? d.model.requested : 'unknown';
+            rows.push({
+              kind: 'sequential',
+              harness,
+              model,
+              channel: 'claim',
+            });
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // Deduplicate preserving order
+  const seen = new Set        ();
+  const deduped                      = [];
+  for (const row of rows) {
+    const key = `${row.kind}:${row.harness}:${row.model}:${row.channel}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduped.push(row);
+    }
+  }
+  return deduped;
+}
+
+module.exports = { crossCheckAuthor, authoringIdentities };

package/src/runtime/review/protocol-command.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * `doflow protocol` (119 IC-004, D-3): the read-only view of the review and debate protocols. `--action list`
+ * prints the presets and the invariants; `--action resolve` prints the IC-003 result for a kind, so a debate or
+ * review brief can embed the printed protocol verbatim. It writes nothing: no telemetry, no state, no upkeep.
+ * The verb has no diff, so the changed paths are unknown and a review resolves to the deep preset.
+ */
+
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { finishRuntime, captureCaught } = require('../cli-result.js');
+const { resolveProtocol, protocolLines } = require('./resolve-protocol.js');
+const { loadProtocolInputs } = require('./start.js');
+const { loadProtocols, presetIds } = require('./protocols.js');
+const { isQualifiedId } = require('../../helper/package-ids.js');
+
+const KINDS = ['review', 'debate'];
+// A preset id: a core one as protocols.ts validates it (`^[a-z][a-z0-9-]*$`), or a package preset's qualified id
+// (`<package>.<preset>`, 122 IC-003). Whether it is available and strict enough is the resolver's answer (IC-014).
+const CORE_PRESET_ID = /^[a-z][a-z0-9-]*$/;
+const presetIdShape = (value         )          => typeof value === 'string' && (CORE_PRESET_ID.test(value) || isQualifiedId(value));
+
+function seatText(seat     )         {
+  return `${seat.id}[${(seat.lenses ?? []).join(',')}]`;
+}
+
+function presetEntry(registry     , id        )      {
+  const preset = registry.presets[id];
+  return {
+    id, kind: preset.kind, ...(preset.kind === 'review' ? { depth: preset.depth } : {}),
+    seats: preset.seats, rounds: preset.rounds, crossAnswer: preset.crossAnswer,
+    synthesizer: preset.synthesizer, decider: preset.decider,
+  };
+}
+
+function presetLine(entry     )         {
+  return `preset ${entry.id}: kind=${entry.kind}${entry.depth ? ` depth=${entry.depth}` : ''} seats=${entry.seats.map(seatText).join(' ')}`
+    + ` rounds=${entry.rounds.default} (min ${entry.rounds.min}) crossAnswer=${entry.crossAnswer} synthesizer=${entry.synthesizer} decider=${entry.decider}`;
+}
+
+function handleProtocolCommand({ action, kind, taskClass, risk, preset, positional = [], json = false, cwd = process.cwd(), out = (line        ) => console.log(line) }      = {})         {
+  const usage = (message        )         => {
+    out(json ? JSON.stringify({ ok: false, error: 'usage', message }) : `doflow protocol: ${message}`);
+    return finishRuntime(2);
+  };
+  const refuse = (error        , message        )         => {
+    out(json ? JSON.stringify({ ok: false, error, message }) : `protocol: ${error}: ${message}`);
+    return finishRuntime(1);
+  };
+  if (Array.isArray(positional) && positional.length > 0) return usage(`unexpected positional argument '${positional[0]}'`);
+  if (action !== 'list' && action !== 'resolve') return usage('action must be list or resolve');
+  if (kind !== undefined && kind !== null && !KINDS.includes(kind)) return usage(`--kind must be one of ${KINDS.join(', ')}`);
+
+  try {
+    const loaded = loadProtocols();
+    if (!loaded.ok) return refuse('protocols-invalid', loaded.errors.join('; '));
+    const registry = loaded.registry;
+
+    if (action === 'list') {
+      if (taskClass != null || risk != null || preset != null) return usage('--task-class, --risk and --preset are valid only with --action resolve');
+      const entries = KINDS.filter((k) => !kind || k === kind).flatMap((k) => presetIds(registry, k)).map((id) => presetEntry(registry, id));
+      if (json) out(JSON.stringify({ schema: 1, presets: entries, invariants: registry.invariants }));
+      else {
+        for (const entry of entries) out(presetLine(entry));
+        for (const inv of registry.invariants) out(`invariant ${inv.id}: ${inv.statement} (enforced by ${inv.enforcedBy})`);
+      }
+      return finishRuntime(0);
+    }
+
+    if (!kind) return usage('--kind is required with --action resolve');
+    const { WorkflowEngine } = require('../workflow-engine.js');
+    const { loadVerificationRegistry, reviewDepthPolicy } = require('../verification/registry.js');
+    if (taskClass != null && !Object.hasOwn(new WorkflowEngine({ repoRoot: REPO_ROOT }).classes ?? {}, taskClass)) {
+      return usage(`--task-class '${taskClass}' is not in the workflows data`);
+    }
+    const verification = loadVerificationRegistry({ repoRoot: REPO_ROOT });
+    if (risk != null && !Object.hasOwn(verification.riskLevels, risk)) {
+      return usage(`--risk must be one of ${Object.keys(verification.riskLevels).join(', ')}`);
+    }
+    if (preset != null && !presetIdShape(preset)) {
+      return usage('--preset must be a preset id (lower-case letters, digits and hyphens, or <package>.<preset> for a package preset)');
+    }
+
+    const inputs = loadProtocolInputs(taskClass ?? null, cwd);
+    if ('error' in inputs) return refuse(inputs.error, inputs.message);
+    // No diff: `paths` is unknown, so a review is never `single` and the risk only matters to the scope rule.
+    const resolved = resolveProtocol({
+      kind, taskClass: taskClass ?? null, risk: risk ?? verification.policy.defaultRiskLevel, paths: null,
+      runPreset: preset ?? null, advicePick: null, ...inputs, riskPolicy: reviewDepthPolicy(verification),
+    });
+    if (!resolved.ok) {
+      const messages                         = {
+        'preset-unknown': `--preset '${preset}' is not a ${kind} preset`,
+        'preset-looser': `--preset '${preset}' is looser than the protocol this ${kind} needs; a run preset can only raise it`,
+        'registry-incomplete': `the protocols registry has no ${kind} preset for the decided protocol`,
+      };
+      return refuse(resolved.reason, messages[resolved.reason] ?? resolved.reason);
+    }
+    if (json) out(JSON.stringify({ schema: 1, ok: true, protocol: resolved.protocol }));
+    else for (const line of protocolLines(resolved.protocol)) out(line);
+    return finishRuntime(0);
+  } catch (error     ) {
+    captureCaught(error, 'protocol', 1);
+    console.error(`[ERROR] protocol: ${error?.message || String(error)}`);
+    return finishRuntime(1);
+  }
+}
+
+module.exports = { handleProtocolCommand };