@surlymochan/evalid 0.0.0-stage → 0.3.1

package/src/core/atoms/gate/workbench.js

@@ -0,0 +1,79 @@
+import { readJsonFile, resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+import { resolveBoundMissionId } from '../../bindings.js';
+import { getMissionDetail } from '../../mission-state.js';
+import { readStore, resolveDataFile } from '../../state-store.js';
+
+function summarizeGateDecisions(detail) {
+  const gates = Array.isArray(detail.gate_decisions) ? detail.gate_decisions : [];
+  return {
+    total: gates.length,
+    pass: gates.filter((gate) => gate.result === 'pass').length,
+    fail: gates.filter((gate) => gate.result === 'fail').length,
+    needs_human: gates.filter((gate) => gate.result === 'needs_human').length,
+  };
+}
+
+function deriveRecommendation(detail, qaAcceptance, evidencePacket) {
+  if (qaAcceptance?.qa_status === 'accepted' && (evidencePacket?.evidence_count || 0) > 0) {
+    return 'pass';
+  }
+  if (qaAcceptance?.qa_status === 'rejected') {
+    return 'fail';
+  }
+  if ((detail.gate_decisions || []).some((gate) => gate.result === 'fail')) {
+    return 'fail';
+  }
+  return 'needs_human';
+}
+
+export async function gateWorkbench(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id || null;
+  if (!changeId) {
+    throw new Error('change_id is required for E3.gate.workbench');
+  }
+
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for E3.gate.workbench');
+  }
+
+  const state = await readStore(dataFile);
+  const detail = getMissionDetail(state, missionId);
+  const qaAcceptance = readJsonFile(resolveChangePath(projectRoot, changeId, 'qa_acceptance.json'), null);
+  const evidencePacket = readJsonFile(resolveChangePath(projectRoot, changeId, 'evidence/gate_final.json'), null)
+    || readJsonFile(resolveChangePath(projectRoot, changeId, 'evidence/qa.json'), null);
+  const recommendation = deriveRecommendation(detail, qaAcceptance, evidencePacket);
+
+  const workbench = {
+    version: 1,
+    change_id: changeId,
+    mission_id: missionId,
+    generated_at: new Date().toISOString(),
+    mission_status: detail.mission.status,
+    execution_overview: detail.execution_overview,
+    gate_summary: summarizeGateDecisions(detail),
+    qa_acceptance: qaAcceptance,
+    evidence: evidencePacket,
+    recommendation,
+    review_queue: (detail.gate_decisions || []).filter((gate) => gate.result !== 'pass'),
+    recent_gates: detail.gate_decisions || [],
+  };
+
+  const outputPath = resolveChangePath(projectRoot, changeId, 'gate_final.json');
+  writeJsonFile(outputPath, workbench);
+
+  return {
+    ok: true,
+    verdict: recommendation,
+    gate_final_file: outputPath,
+    workbench,
+  };
+}

package/src/core/atoms/intake/classify.js

@@ -0,0 +1,15 @@
+import { resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+
+export async function intakeClassify(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id || null;
+  if (!changeId) throw new Error('change_id is required for G2.intake.classify');
+  const classification = {
+    change_type: context.input?.change_type || input.change_type || 'backend',
+    risk_level: input.risk_level || 'medium',
+    ui_heavy: Boolean(input.ui_heavy || ['frontend', 'full-stack'].includes(context.input?.change_type || '')),
+  };
+  const outputPath = resolveChangePath(projectRoot, changeId, 'intake_classification.json');
+  writeJsonFile(outputPath, classification);
+  return { ok: true, output_file: outputPath, classification };
+}

package/src/core/atoms/intake/design-skill-select.js

@@ -0,0 +1,16 @@
+import { resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+
+export async function designSkillSelect(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id || null;
+  if (!changeId) throw new Error('change_id is required for G4.design_skill.select');
+  const payload = {
+    version: 1,
+    change_id: changeId,
+    selected_skill: input.skill || 'design-contract-lite',
+    rationale: input.rationale || 'Selected the default heavy-track design skill for consistent output.',
+  };
+  const outputPath = resolveChangePath(projectRoot, changeId, 'design_skill_selection.json');
+  writeJsonFile(outputPath, payload);
+  return { ok: true, output_file: outputPath, payload };
+}

package/src/core/atoms/intake/preview-or-refine.js

@@ -0,0 +1,19 @@
+import { resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+
+export async function intakePreviewOrRefine(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id || null;
+  if (!changeId) throw new Error('change_id is required for G1.intake.preview_or_refine');
+  const mode = input.mode || 'preview';
+  const outputPath = resolveChangePath(projectRoot, changeId, `intake_${mode}.json`);
+  const payload = {
+    version: 1,
+    mode,
+    change_id: changeId,
+    summary: input.summary || context.input?.title || '',
+    answers: input.answers || {},
+    constraints: input.constraints || {},
+  };
+  writeJsonFile(outputPath, payload);
+  return { ok: true, output_file: outputPath, payload };
+}

package/src/core/atoms/intake/recommend.js

@@ -0,0 +1,20 @@
+import { resolveEffectivePolicy } from '../../policy-overlay.js';
+import { writeWorkflowRecommendation } from '../../intake-recommendation.js';
+
+export async function intakeRecommend(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id;
+  if (!changeId) throw new Error('change_id is required for G5.intake.recommend');
+  const policyResult = resolveEffectivePolicy({
+    projectRoot,
+    changeId,
+    executionMode: input.execution_mode || null,
+    writeArtifact: true,
+  });
+  return writeWorkflowRecommendation({
+    projectRoot,
+    changeId,
+    input: { ...(context.input || {}), ...input },
+    effectivePolicy: policyResult.policy || policyResult.profile || {},
+  });
+}

package/src/core/atoms/intake/research-same-category.js

@@ -0,0 +1,19 @@
+import { resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+
+export async function researchSameCategory(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id || null;
+  if (!changeId) throw new Error('change_id is required for G3.research.same_category');
+  const payload = {
+    version: 1,
+    change_id: changeId,
+    references: [
+      { type: 'interaction', summary: 'Same-category interaction patterns reviewed.' },
+      { type: 'information_architecture', summary: 'Module boundaries compared against adjacent products.' },
+      { type: 'visual', summary: 'Visual references captured for later synthesis.' },
+    ],
+  };
+  const outputPath = resolveChangePath(projectRoot, changeId, 'same_category_research.json');
+  writeJsonFile(outputPath, payload);
+  return { ok: true, output_file: outputPath, payload };
+}

package/src/core/atoms/intervention/create.js

@@ -0,0 +1,30 @@
+import { createIntervention } from '../../mission-state.js';
+import { mutateStore, resolveDataFile } from '../../state-store.js';
+import { resolveBoundMissionId } from '../../bindings.js';
+
+export async function interventionCreate(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId: context.changeId || null,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for D5.intervention.create');
+  }
+
+  const result = await mutateStore(
+    (state) => createIntervention(state, missionId, input),
+    dataFile,
+  );
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: missionId,
+    ...result,
+  };
+}

package/src/core/atoms/memory/manage.js

@@ -0,0 +1,27 @@
+import { createMemoryItem, listMemoryItems, resolveMemoryMissionId } from '../../memory-state.js';
+import { mutateStore, readStore, resolveDataFile } from '../../state-store.js';
+
+export async function memoryItemManage(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const missionId = resolveMemoryMissionId(input, context);
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const action = input.action || 'create';
+
+  if (action === 'list') {
+    const state = await readStore(dataFile);
+    return {
+      ok: true,
+      items: listMemoryItems(state, { ...input, mission_id: missionId }),
+    };
+  }
+
+  const item = await mutateStore(
+    (state) => createMemoryItem(state, { ...input, mission_id: missionId }),
+    dataFile,
+  );
+
+  return {
+    ok: true,
+    item,
+  };
+}

package/src/core/atoms/memory/mount.js

@@ -0,0 +1,13 @@
+import { buildMemoryMount, resolveMemoryMissionId } from '../../memory-state.js';
+import { readStore, resolveDataFile } from '../../state-store.js';
+
+export async function memoryMount(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const missionId = resolveMemoryMissionId(input, context);
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const state = await readStore(dataFile);
+  return {
+    ok: true,
+    mount: buildMemoryMount(state, { ...input, mission_id: missionId }),
+  };
+}

package/src/core/atoms/mission/create.js

@@ -0,0 +1,19 @@
+import { createMission } from '../../mission-state.js';
+import { mutateStore, resolveDataFile } from '../../state-store.js';
+
+export async function missionCreate(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const result = await mutateStore(
+    (state) => createMission(state, { ...input, change_id: context.changeId || null }),
+    dataFile,
+  );
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: result.mission.mission_id,
+    mission: result.mission,
+    replay_event: result.replay_event,
+  };
+}

package/src/core/atoms/mission/list.js

@@ -0,0 +1,14 @@
+import { listMissions } from '../../mission-state.js';
+import { readStore, resolveDataFile } from '../../state-store.js';
+
+export async function missionList(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const state = await readStore(dataFile);
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    missions: listMissions(state),
+  };
+}

package/src/core/atoms/mission/show.js

@@ -0,0 +1,26 @@
+import { getMissionDetail } from '../../mission-state.js';
+import { resolveBoundMissionId } from '../../bindings.js';
+import { readStore, resolveDataFile } from '../../state-store.js';
+
+export async function missionShow(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId: context.changeId || null,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for D2b.mission.show');
+  }
+
+  const state = await readStore(dataFile);
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: missionId,
+    detail: getMissionDetail(state, missionId),
+  };
+}

package/src/core/atoms/notify/checkpoint.js

@@ -0,0 +1,46 @@
+import { resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+
+export async function notifyCheckpoint(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id;
+  if (!changeId) throw new Error('change_id is required for notify.checkpoint');
+
+  const phase = input.phase || context.phase?.id || 'checkpoint';
+  const provider = input.provider || 'file';
+  if (!['file', 'mock'].includes(provider)) {
+    return {
+      ok: false,
+      error: `Unsupported notify provider: ${provider}`,
+      supported_providers: ['file', 'mock'],
+    };
+  }
+
+  const evidence = {
+    version: 1,
+    provider,
+    phase,
+    change_id: changeId,
+    mission_id: input.mission_id || context.runtime?.missionId || null,
+    recipient: input.recipient || null,
+    artifact_url: input.artifact_url || input.artifact || null,
+    message: input.message || `Checkpoint notification for ${phase}`,
+    sent_at: new Date().toISOString(),
+    status: provider === 'mock' ? 'mock_sent' : 'sent',
+    approves_gate: false,
+    authority: 'notification_only_human_gate_ack_required',
+  };
+  const outputPath = resolveChangePath(projectRoot, changeId, `notification/checkpoint-${sanitizeFilePart(phase)}.json`);
+  writeJsonFile(outputPath, evidence);
+  return {
+    ok: true,
+    provider,
+    phase,
+    notification_file: outputPath,
+    approves_gate: false,
+    evidence,
+  };
+}
+
+function sanitizeFilePart(value) {
+  return String(value || 'checkpoint').replace(/[^a-zA-Z0-9._-]+/g, '-');
+}

package/src/core/atoms/phase-run/complete.js

@@ -0,0 +1,42 @@
+import { resolveBoundMissionId } from '../../bindings.js';
+import { completePhaseRunSession, findPhaseRunSession } from '../../mission-state.js';
+import { mutateStore, resolveDataFile } from '../../state-store.js';
+
+export async function phaseRunComplete(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId: context.changeId || null,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for D3c.phase_run.complete');
+  }
+
+  const sessionId = input.session_id || context.runtime?.phaseRunSessionId || null;
+
+  const result = await mutateStore((state) => {
+    const session = sessionId ? findPhaseRunSession(state, missionId, sessionId) : findPhaseRunSession(state, missionId);
+    if (!session) {
+      throw new Error(`No phase run session found for mission ${missionId}`);
+    }
+
+    const completed = completePhaseRunSession(state, missionId, session.session_id, {
+      phase_run_id: input.phase_run_id || context.runtime?.phaseRunId || session.phase_run_id || null,
+      status: input.status || 'completed',
+      stop_reason: input.stop_reason || null,
+      completed_at: input.completed_at || null,
+    });
+    return { session: completed };
+  }, dataFile);
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: missionId,
+    session: result.session,
+  };
+}

package/src/core/atoms/phase-run/fail.js

@@ -0,0 +1,40 @@
+import { resolveBoundMissionId } from '../../bindings.js';
+import { failPhaseRunSession, findPhaseRunSession } from '../../mission-state.js';
+import { mutateStore, resolveDataFile } from '../../state-store.js';
+
+export async function phaseRunFail(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId: context.changeId || null,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for D3d.phase_run.fail');
+  }
+
+  const sessionId = input.session_id || context.runtime?.phaseRunSessionId || null;
+
+  const result = await mutateStore((state) => {
+    const session = sessionId ? findPhaseRunSession(state, missionId, sessionId) : findPhaseRunSession(state, missionId);
+    if (!session) {
+      throw new Error(`No phase run session found for mission ${missionId}`);
+    }
+
+    const failed = failPhaseRunSession(state, missionId, session.session_id, {
+      summary: input.summary || input.stop_reason || 'phase_run_failed',
+      detail: input.detail || null,
+    });
+    return { session: failed };
+  }, dataFile);
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: missionId,
+    session: result.session,
+  };
+}

package/src/core/atoms/phase-run/persist.js

@@ -0,0 +1,39 @@
+import { resolveBoundMissionId } from '../../bindings.js';
+import { findPhaseRunSession, persistPhaseRun } from '../../mission-state.js';
+import { mutateStore, resolveDataFile } from '../../state-store.js';
+
+export async function phaseRunPersist(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId: context.changeId || null,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for D3b.phase_run.persist');
+  }
+
+  const payload = {
+    ...input,
+    session_id: input.session_id || context.runtime?.phaseRunSessionId || null,
+    phase_run_id: input.phase_run_id || context.runtime?.phaseRunId || null,
+  };
+
+  const result = await mutateStore((state) => {
+    const phaseRun = persistPhaseRun(state, missionId, payload);
+    const session = findPhaseRunSession(state, missionId, payload.session_id || null);
+    return { phaseRun, session };
+  }, dataFile);
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: missionId,
+    phase_run_id: result.phaseRun.phase_run_id,
+    phase_run: result.phaseRun,
+    session: result.session,
+  };
+}

package/src/core/atoms/phase-run/start.js

@@ -0,0 +1,30 @@
+import { resolveBoundMissionId } from '../../bindings.js';
+import { startPhaseRunSession } from '../../mission-state.js';
+import { mutateStore, resolveDataFile } from '../../state-store.js';
+
+export async function phaseRunStart(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const dataFile = resolveDataFile({ projectRoot, explicitPath: input.data_file || null });
+  const missionId = resolveBoundMissionId({
+    projectRoot,
+    changeId: context.changeId || null,
+    missionId: input.mission_id || null,
+    runtimeMissionId: context.runtime?.missionId || null,
+  });
+
+  if (!missionId) {
+    throw new Error('mission_id is required for D3a.phase_run.start');
+  }
+
+  const session = await mutateStore(
+    (state) => startPhaseRunSession(state, missionId, input),
+    dataFile,
+  );
+
+  return {
+    ok: true,
+    data_file: dataFile,
+    mission_id: missionId,
+    session,
+  };
+}

package/src/core/atoms/plugin/run.js

@@ -0,0 +1,76 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+
+import { resolveChangePath, writeJsonFile } from '../../change-artifacts.js';
+
+export async function pluginRun(input = {}, context = {}) {
+  const projectRoot = context.projectRoot || process.cwd();
+  const changeId = context.changeId || input.change_id;
+  if (!changeId) throw new Error('change_id is required for plugin.run');
+
+  const type = input.type || 'script';
+  const ref = input.ref || '';
+  const dryRun = input.dry_run !== false;
+  const payload = input.payload || {};
+  const result = dryRun
+    ? dryRunResult(type, ref, payload)
+    : executePlugin({ type, ref, payload, projectRoot, timeoutMs: Number(input.timeout_ms || 60000) });
+
+  const output = {
+    version: 1,
+    change_id: changeId,
+    type,
+    ref,
+    dry_run: dryRun,
+    generated_at: new Date().toISOString(),
+    result,
+  };
+  const outputPath = resolveChangePath(projectRoot, changeId, `plugin/${sanitizeFilePart(type)}-${sanitizeFilePart(ref || 'plugin')}.json`);
+  writeJsonFile(outputPath, output);
+  return {
+    ok: result.status !== 'error',
+    plugin_result_file: outputPath,
+    result,
+  };
+}
+
+function dryRunResult(type, ref, payload) {
+  if (!['script', 'webhook', 'agent', 'skill', 'interactive'].includes(type)) {
+    return { status: 'error', error: `Unknown plugin type: ${type}` };
+  }
+  return {
+    status: 'dry_run',
+    type,
+    ref,
+    payload_preview: payload,
+    message: 'Plugin execution was recorded without external side effects.',
+  };
+}
+
+function executePlugin({ type, ref, payload, projectRoot, timeoutMs }) {
+  if (type !== 'script') {
+    return { status: 'error', error: `Non-dry-run ${type} plugins are not supported by the generic v1 provider` };
+  }
+  const scriptPath = resolve(projectRoot, ref);
+  const started = Date.now();
+  const result = spawnSync('bash', [scriptPath], {
+    cwd: projectRoot,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: {
+      ...process.env,
+      PAYLOAD: JSON.stringify(payload),
+    },
+  });
+  return {
+    status: result.status === 0 ? 'ok' : 'error',
+    exit_code: result.status,
+    duration_ms: Date.now() - started,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+  };
+}
+
+function sanitizeFilePart(value) {
+  return String(value || 'plugin').replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 80);
+}