@stravica-ai/digital-operator-pa 0.1.6 → 0.1.8

package/dist/engineering-pa-cli/src/research/commands/show.mjs

@@ -28,7 +28,16 @@ export async function showCommand(argv, { store, stdout = process.stdout } = {})
   const findings = await store.listFindings(id);
 
   if (parsed.values.json) {
-    stdout.write(JSON.stringify({ manifest, plan, sources, gates, findings }, null, 2) + '\n');
+    const assembled = { manifest, plan, sources, gates, findings };
+    // Deep-mode-only artifacts (D4): surface them when present, omit cleanly when
+    // absent so a normal/light session's --json is byte-identical to before.
+    const rounds = await store.readRounds(id);
+    const judge = await store.readJudge(id);
+    const cost = await store.readCost(id);
+    if (rounds !== null) assembled.rounds = rounds;
+    if (judge !== null) assembled.judge = judge;
+    if (cost !== null) assembled.cost = cost;
+    stdout.write(JSON.stringify(assembled, null, 2) + '\n');
     return 0;
   }
 

package/dist/engineering-pa-cli/src/research/engine/agents.mjs

@@ -0,0 +1,163 @@
+// Shared research engine — agent schemas, per-role agent wrappers, and the
+// search+extract pipeline. Model/effort pins are explicit per call (build-spec
+// §4.1 — never harness-inherited); verify pins are overridable so deep can lift
+// its lead-vote tier without editing normal's behaviour.
+import { brief } from './io.mjs';
+import { topoOrder } from './plan.mjs';
+
+// ── JSON schemas for structured agent returns ──────────────────────────────────
+
+export const SEARCH_SCHEMA = {
+  type: 'object', additionalProperties: false,
+  required: ['subQuestionId', 'sources', 'toolCallsUsed'],
+  properties: {
+    subQuestionId: { type: 'string' },
+    sources: {
+      type: 'array',
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['sourceId', 'url', 'title', 'kind', 'sourceQuality'],
+        properties: {
+          sourceId: { type: 'string' },
+          url: { type: 'string' },
+          title: { type: 'string' },
+          kind: { enum: ['web', 'playwright', 'kb', 'codebase', 'prior-session'] },
+          sourceQuality: { enum: ['primary', 'secondary', 'low'] },
+          snippet: { type: 'string' },
+        },
+      },
+    },
+    toolCallsUsed: { type: 'integer' },
+    gatedDropped: {
+      type: 'array',
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['url', 'gateType', 'whatIsNeeded'],
+        properties: { url: { type: 'string' }, gateType: { type: 'string' }, whatIsNeeded: { type: 'string' } },
+      },
+    },
+    notes: { type: 'string' },
+  },
+};
+
+export const EXTRACT_SCHEMA = {
+  type: 'object', additionalProperties: false,
+  required: ['subQuestionId', 'claims', 'unsourcedClaims'],
+  properties: {
+    subQuestionId: { type: 'string' },
+    claims: {
+      type: 'array',
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['claimId', 'text', 'quote', 'sourceId', 'importance', 'sourceQuality'],
+        properties: {
+          claimId: { type: 'string' },
+          text: { type: 'string' },
+          quote: { type: 'string' },
+          sourceId: { type: 'string' },
+          importance: { enum: ['central', 'supporting', 'incidental'] },
+          sourceQuality: { enum: ['primary', 'secondary', 'low'] },
+        },
+      },
+    },
+    unsourcedClaims: { type: 'integer' },
+    notes: { type: 'string' },
+  },
+};
+
+export const VERIFY_SCHEMA = {
+  type: 'object', additionalProperties: false,
+  required: ['outcome', 'note'],
+  properties: {
+    outcome: { enum: ['confirmed', 'refuted', 'unverified-infra'] },
+    note: { type: 'string' },
+  },
+};
+
+export const SYNTH_SCHEMA = {
+  type: 'object', additionalProperties: false,
+  required: ['subQuestionId', 'written', 'path', 'confidence', 'claimCount', 'centralConfirmed', 'centralRefuted', 'unsourcedCount'],
+  properties: {
+    subQuestionId: { type: 'string' },
+    written: { type: 'boolean' },
+    path: { type: 'string' },
+    confidence: { enum: ['low', 'medium', 'high'] },
+    claimCount: { type: 'integer' },
+    centralConfirmed: { type: 'integer' },
+    centralRefuted: { type: 'integer' },
+    unsourcedCount: { type: 'integer' },
+    refutedTransparency: { type: 'string' },
+  },
+};
+
+// ── agent wrappers (model/effort per build-spec §4.1 — explicit, never inherited) ──
+// Mode-varying knobs live on ctx (defaults reproduce normal exactly): `ctx.toolCallCap`
+// (deep lifts the searcher cap 12→20), `ctx.extractorRole`/`ctx.extractSchema` (deep
+// swaps in deep-extractor.md + claimKind tagging), `ctx.modelOverride` (deep's
+// testOverrides.modelPanel forces a cheap panel for mechanical smoke runs). When a
+// knob is unset, `?? default` / `|| pinned` yields normal's byte-identical output.
+
+export function searchAgent(ctx, sq, siblings, priorContext) {
+  return agent(brief(ctx, 'searcher', {
+    sessionId: ctx.sessionId, sessionQuestion: ctx.baseQuestion, intent: ctx.baseIntent, gatePolicy: ctx.basePolicy,
+    subQuestionId: sq.id, subQuestionText: sq.text,
+    siblingSubQuestions: siblings.filter((s) => s.id !== sq.id).map((s) => `${s.id}: ${s.text}`).join(' | ') || 'none',
+    sourceIdPrefix: sq.id.replace(/[^a-zA-Z0-9]/g, ''), toolCallCap: ctx.toolCallCap ?? 12, sessionDir: ctx.sessionDir,
+    dependencyContext: priorContext || 'none (independent sub-question)',
+  }), { model: ctx.modelOverride || 'sonnet', effort: 'medium', phase: 'Search', label: `search:${sq.id}`, schema: SEARCH_SCHEMA });
+}
+
+export function extractAgent(ctx, sq, searchRes, priorContext) {
+  const sources = (searchRes && searchRes.sources) || [];
+  return agent(brief(ctx, ctx.extractorRole ?? 'extractor', {
+    sessionId: ctx.sessionId, sessionQuestion: ctx.baseQuestion,
+    subQuestionId: sq.id, subQuestionText: sq.text,
+    sources: sources.map((s) => ({ sourceId: s.sourceId, url: s.url, title: s.title, sourceQuality: s.sourceQuality })),
+    sessionDir: ctx.sessionDir, dependencyContext: priorContext || 'none',
+  }), { model: ctx.modelOverride || 'sonnet', effort: 'medium', phase: 'Extract', label: `extract:${sq.id}`, schema: ctx.extractSchema ?? EXTRACT_SCHEMA });
+}
+
+export function verifyAgent(ctx, claim, lens, model = 'sonnet', effort = 'high', role = 'verifier') {
+  return agent(brief(ctx, role, {
+    sessionId: ctx.sessionId, claimText: claim.text, quote: claim.quote, sourceUrl: claim.url || claim.sourceId,
+    subQuestionText: claim.sqText, lens,
+  }), { model, effort, phase: 'Verify', label: `verify:${claim.claimId}:${lens}`, schema: VERIFY_SCHEMA });
+}
+
+export function synthAgent(ctx, sq, buckets) {
+  return agent(brief(ctx, 'synthesizer', {
+    sessionId: ctx.sessionId, subQuestionId: sq.id, subQuestionText: sq.text, outputMode: ctx.baseOutputMode,
+    findingFilename: `${sq.id}.json`, sessionDir: ctx.sessionDir, schemaDir: ctx.schemaDir, cli: ctx.cli,
+    verifiedClaims: buckets.verified, supportingClaims: buckets.supporting, refutedClaims: buckets.refuted,
+  }), { model: ctx.modelOverride || 'opus', effort: 'high', phase: 'Synthesize', label: `synth:${sq.id}`, schema: SYNTH_SCHEMA });
+}
+
+// -- Search + Extract --
+// Independent facets flow search→extract with no cross-facet barrier (pipeline).
+// Dependent facets are chained AFTER their dependsOn extract completes (the DAG that
+// pipeline() cannot express — documented fallback, §8). Returns sq.id -> { sq, search, extract }.
+export async function runSearchExtract(ctx, subQuestions) {
+  const independent = subQuestions.filter((sq) => sq.kind !== 'dependent' || (sq.dependsOn || []).length === 0);
+  const dependents = subQuestions.filter((sq) => sq.kind === 'dependent' && (sq.dependsOn || []).length > 0);
+
+  const sqResults = new Map(); // sq.id -> { sq, search, extract }
+
+  const indepPairs = await pipeline(
+    independent,
+    (sq) => searchAgent(ctx, sq, subQuestions),
+    (searchRes, sq) => extractAgent(ctx, sq, searchRes).then((extract) => ({ sq, search: searchRes, extract })),
+  );
+  for (const r of indepPairs.filter(Boolean)) sqResults.set(r.sq.id, r);
+
+  for (const sq of topoOrder(dependents)) {
+    const priorContext = (sq.dependsOn || [])
+      .map((d) => sqResults.get(d))
+      .filter(Boolean)
+      .map((r) => `${r.sq.id}: ${(r.extract.claims || []).map((c) => c.text).slice(0, 3).join('; ')}`)
+      .join(' || ') || 'dependencies produced no claims';
+    const searchRes = await searchAgent(ctx, sq, subQuestions, priorContext);
+    const extract = await extractAgent(ctx, sq, searchRes, priorContext);
+    sqResults.set(sq.id, { sq, search: searchRes, extract });
+  }
+  return sqResults;
+}