@work-graph/cli 0.2.0

package/vendor/src/agentWorkerLiveLoop.mjs

@@ -0,0 +1,455 @@
+import { appendFile, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import {
+  buildWorkerInputFromTask,
+} from './agentWorkerLocalRunner.mjs';
+import { loadAgentBehaviorRulesBundle } from './agentBehaviorRulesBundle.mjs';
+import { buildWorkerInputWithRoleHandoff } from './agentWorkerOpenAiProvider.mjs';
+import { AGENT_LOOP_PHASES } from './goldenPath.mjs';
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+import { runWorkerWithProvider } from './workGraphWorkerProvider.mjs';
+import {
+  WorkGraphPolicyError,
+  claimNext,
+  claimWorkItemWithLease,
+  parseWorkItems,
+  recordEvidence,
+  transitionStatus,
+} from './workGraphRuntime.mjs';
+import { evaluateWorkItemExecutionGate } from './workItemExecutionGate.mjs';
+
+export { AGENT_LOOP_PHASES as AGENT_LIVE_LOOP_PHASES };
+
+const DEFAULT_JOURNAL_PATH = 'work/worker-runs.jsonl';
+
+export function formatWorkerEvidenceLine(evidence, output) {
+  if (typeof evidence === 'string') {
+    return evidence.trim();
+  }
+
+  if (!evidence || typeof evidence !== 'object') {
+    return `worker-run: runId=${output.runId} status=${output.status}`;
+  }
+
+  const parts = [
+    'worker-run',
+    `runId=${output.runId}`,
+    evidence.kind ? `kind=${evidence.kind}` : '',
+    evidence.source ? `source=${evidence.source}` : '',
+    evidence.result ? `result=${evidence.result}` : '',
+    evidence.summary ? `summary=${String(evidence.summary).trim()}` : '',
+  ].filter(Boolean);
+
+  return parts.join(' ');
+}
+
+export function buildWorkerRunSummary(output, loopMeta = {}) {
+  return {
+    runId: output.runId,
+    taskId: output.taskId,
+    status: output.status,
+    provider: loopMeta.provider ?? 'local-runner',
+    selectionMode: loopMeta.selectionMode ?? null,
+    explicitProvider: loopMeta.explicitProvider ?? false,
+    usedFallback: loopMeta.usedFallback ?? false,
+    fallbackTrail: loopMeta.fallbackTrail ?? [],
+    transitionProposal: output.transitionRequest ?? null,
+    appliedTransition: loopMeta.appliedTransition ?? null,
+    summary: output.patchSummary?.summary || output.failureReason || output.status,
+    recordedAt: loopMeta.recordedAt ?? new Date(0).toISOString(),
+  };
+}
+
+export function applyWorkerOutputToItem(item, output) {
+  let current = item;
+  const evidenceLines = Array.isArray(output.evidence) && output.evidence.length > 0
+    ? output.evidence.map((entry) => formatWorkerEvidenceLine(entry, output))
+    : [formatWorkerEvidenceLine(null, output)];
+
+  for (const line of evidenceLines) {
+    current = recordEvidence(current, line);
+  }
+
+  const transitionProposal = {
+    status: output.transitionRequest?.status ?? (output.status === 'succeeded' ? 'verify' : 'blocked'),
+    reason: output.transitionRequest?.reason ?? output.failureReason ?? '',
+  };
+
+  let appliedTransition = null;
+  let transitionError = null;
+
+  try {
+    if (output.status === 'succeeded') {
+      current = transitionStatus(current, transitionProposal.status, {
+        reason: transitionProposal.reason,
+      });
+      appliedTransition = transitionProposal.status;
+    } else {
+      const blockerReason = transitionProposal.reason || output.failureReason || 'worker run failed';
+      current = transitionStatus(current, 'blocked', {
+        reason: blockerReason,
+        blocker: blockerReason,
+      });
+      appliedTransition = 'blocked';
+    }
+  } catch (error) {
+    transitionError = error instanceof WorkGraphPolicyError || error instanceof Error
+      ? error.message
+      : String(error);
+  }
+
+  return {
+    updatedItem: current,
+    transitionProposal,
+    appliedTransition,
+    transitionError,
+  };
+}
+
+export async function runAgentWorkerLiveLoop(items, options = {}) {
+  const steps = [];
+  const pool = items.map(cloneItem);
+
+  steps.push({ phase: 'observe', detail: 'read snapshot', itemCount: pool.length });
+
+  const selected = options.taskId
+    ? pool.find((item) => item.id === options.taskId)
+    : claimNext(pool);
+
+  if (!selected) {
+    return {
+      ok: false,
+      error: 'no_claimable_task',
+      steps,
+      finalItems: pool,
+    };
+  }
+
+  const gate = evaluateWorkItemExecutionGate(selected);
+  if (!gate.allowed) {
+    return {
+      ok: false,
+      error: gate.code,
+      message: gate.message,
+      taskId: selected.id,
+      steps,
+      finalItems: pool,
+    };
+  }
+
+  const runId = options.runId ?? `live-loop-${selected.id}`;
+  const claimResult = claimWorkItemWithLease(selected, {
+    claimRunId: runId,
+    targetStatus: 'claimed',
+    nowMs: options.nowMs,
+    leaseMs: options.claimLeaseMs,
+  });
+
+  if (!claimResult.ok) {
+    return {
+      ok: false,
+      error: claimResult.error,
+      taskId: selected.id,
+      claimedBy: claimResult.claimedBy ?? null,
+      leaseUntil: claimResult.leaseUntil ?? null,
+      steps,
+      finalItems: pool,
+    };
+  }
+
+  steps.push({ phase: 'plan', detail: 'select task ' + selected.id, taskId: selected.id });
+
+  let current = claimResult.item;
+  replaceItem(pool, selected.id, current);
+  steps.push({
+    phase: 'claim',
+    detail: claimResult.idempotent ? 'reuse active claim lease' : 'transition to claimed',
+    taskId: current.id,
+    status: current.status,
+    claimRunId: claimResult.claimRunId,
+    leaseUntil: claimResult.leaseUntil,
+  });
+
+  if (claimResult.idempotent && typeof options.runWorker !== 'function') {
+    return {
+      ok: true,
+      taskId: current.id,
+      steps,
+      idempotentClaim: true,
+      claimRunId: claimResult.claimRunId,
+      leaseUntil: claimResult.leaseUntil,
+      finalItems: pool,
+    };
+  }
+
+  const explicitProvider = options.provider ?? null;
+  const useRoleHandoff = explicitProvider === 'openai' || explicitProvider === 'openai-compatible';
+  const handoffExtras = useRoleHandoff
+    ? buildWorkerInputWithRoleHandoff(current, { runId, ...(options.handoff ?? {}) })
+    : {};
+
+  const behaviorBundle = options.behaviorRulesBundle ?? (
+    options.skipBehaviorRules
+      ? null
+      : await loadAgentBehaviorRulesBundle({ cwd: options.cwd ?? process.cwd() })
+  );
+
+  const behaviorHints = behaviorBundle?.ok
+    ? {
+        behaviorRuleIds: behaviorBundle.ruleIds,
+        behaviorRulesPrompt: behaviorBundle.promptSlice,
+      }
+    : {};
+
+  const input = buildWorkerInputFromTask(current, {
+    runId,
+    policy: {
+      mode: handoffExtras.policy?.mode ?? 'dry-run',
+      allowShell: false,
+      allowNetwork: false,
+      allowFileWrite: false,
+      timeoutMs: handoffExtras.policy?.timeoutMs ?? 0,
+      ...(options.workerInput?.policy ?? {}),
+    },
+    workGraphItems: pool,
+    graphRag: options.graphRag,
+    providerHints: {
+      ...(handoffExtras.providerHints ?? {}),
+      ...behaviorHints,
+      ...(options.workerInput?.providerHints ?? {}),
+    },
+    allowedTools: options.workerInput?.allowedTools,
+    memorySlice: options.workerInput?.memorySlice,
+  });
+
+  let providerResult = null;
+  let output;
+
+  if (typeof options.runWorker === 'function') {
+    output = options.runWorker(input);
+    if (output && typeof output.then === 'function') {
+      output = await output;
+    }
+  } else {
+    providerResult = await runWorkerWithProvider(input, {
+      provider: explicitProvider ?? undefined,
+      providerOptions: options.providerOptions,
+      selectionOptions: options.selectionOptions,
+      enableFallback: options.enableFallback,
+      maxFallbackAttempts: options.maxFallbackAttempts,
+    });
+    output = providerResult.output;
+  }
+
+  const resolvedProviderId = providerResult?.providerId ?? explicitProvider ?? 'local';
+  const selectionMode = providerResult?.selectionRationale?.selectionMode ?? (explicitProvider ? 'explicit_provider' : 'capability_score');
+
+  steps.push({
+    phase: 'act',
+    detail: providerResult?.usedFallback
+      ? `run ${resolvedProviderId} worker after fallback`
+      : explicitProvider
+        ? `run ${explicitProvider} worker`
+        : `run ${resolvedProviderId} worker (${selectionMode})`,
+    taskId: current.id,
+    workerStatus: output.status,
+    providerId: resolvedProviderId,
+    selectionMode,
+    usedFallback: providerResult?.usedFallback ?? false,
+  });
+
+  const applied = applyWorkerOutputToItem(current, output);
+  current = applied.updatedItem;
+  replaceItem(pool, current.id, current);
+
+  steps.push({
+    phase: 'verify',
+    detail: 'apply worker output evidence',
+    evidenceCount: current.evidence.length,
+  });
+
+  steps.push({
+    phase: 'record',
+    detail: 'propose transition',
+    transitionProposal: applied.transitionProposal,
+    appliedTransition: applied.appliedTransition,
+    transitionError: applied.transitionError,
+  });
+
+  steps.push({ phase: 'stop', detail: 'live loop complete', taskId: current.id });
+
+  const recordedAt = options.recordedAt ?? new Date().toISOString();
+  const workerRunSummary = buildWorkerRunSummary(output, {
+    appliedTransition: applied.appliedTransition,
+    recordedAt,
+    provider: resolvedProviderId,
+    selectionMode,
+    explicitProvider: providerResult?.explicitProvider ?? Boolean(explicitProvider),
+    usedFallback: providerResult?.usedFallback ?? false,
+    fallbackTrail: providerResult?.fallbackTrail ?? [],
+  });
+
+  return {
+    ok: output.status === 'succeeded' && applied.transitionError === null,
+    error: applied.transitionError ?? (output.status === 'succeeded' ? null : output.failureReason),
+    taskId: current.id,
+    steps,
+    workerInput: input,
+    workerOutput: output,
+    providerResult,
+    transitionProposal: applied.transitionProposal,
+    appliedTransition: applied.appliedTransition,
+    transitionError: applied.transitionError,
+    workerRunSummary,
+    finalItems: pool,
+  };
+}
+
+export async function runAgentWorkerLiveLoopFromBacklogText(backlogText, options = {}) {
+  return runAgentWorkerLiveLoop(parseWorkItems(backlogText), options);
+}
+
+export async function runAgentWorkerLiveLoopFromBacklogFile(options = {}) {
+  const items = await readWorkItemsFromRepo(options);
+  return runAgentWorkerLiveLoop(items, options);
+}
+
+export async function readWorkerRunJournal(options = {}) {
+  const journalPath = resolve(options.cwd ?? process.cwd(), options.journalPath ?? DEFAULT_JOURNAL_PATH);
+
+  try {
+    const text = await readFile(journalPath, 'utf8');
+    return text
+      .split(/\r?\n/u)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return [];
+    }
+
+    throw error;
+  }
+}
+
+export async function appendWorkerRunJournal(entry, options = {}) {
+  const journalPath = resolve(options.cwd ?? process.cwd(), options.journalPath ?? DEFAULT_JOURNAL_PATH);
+  await appendFile(journalPath, `${JSON.stringify(entry)}\n`, 'utf8');
+  return journalPath;
+}
+
+function cloneItem(item) {
+  return {
+    ...item,
+    dependsOn: [...item.dependsOn],
+    targetFiles: [...item.targetFiles],
+    evidence: [...item.evidence],
+    checks: [...item.checks],
+    labels: { ...item.labels },
+  };
+}
+
+function replaceItem(pool, id, nextItem) {
+  const index = pool.findIndex((item) => item.id === id);
+  if (index === -1) {
+    return pool;
+  }
+
+  pool[index] = nextItem;
+  return pool;
+}
+
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  const options = {
+    once: false,
+    dryRun: true,
+    writeJournal: true,
+    taskId: undefined,
+    provider: undefined,
+    explicitProvider: false,
+    backlogPath: undefined,
+    journalPath: DEFAULT_JOURNAL_PATH,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--once') {
+      options.once = true;
+      continue;
+    }
+
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (arg === '--provider') {
+      options.provider = args[index + 1] ?? 'local';
+      options.explicitProvider = true;
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--no-journal') {
+      options.writeJournal = false;
+      continue;
+    }
+
+    if (arg === '--backlog') {
+      options.backlogPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--journal') {
+      options.journalPath = args[index + 1] ?? DEFAULT_JOURNAL_PATH;
+      index += 1;
+      continue;
+    }
+
+    if (!arg.startsWith('--') && options.taskId === undefined) {
+      options.taskId = arg;
+    }
+  }
+
+  return options;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const cli = parseCliArgs(process.argv);
+
+  if (!cli.once) {
+    console.error('Usage: node src/agentWorkerLiveLoop.mjs --once [--provider local|openai] [--backlog path/to/backlog.bvc] [--journal work/worker-runs.jsonl] [taskId]');
+    process.exitCode = 1;
+  } else {
+    const result = await runAgentWorkerLiveLoopFromBacklogFile({
+      taskId: cli.taskId,
+      backlogPath: cli.backlogPath,
+      provider: cli.explicitProvider ? cli.provider : undefined,
+      workerInput: cli.dryRun ? { policy: { mode: 'dry-run' } } : {},
+    });
+
+    if (cli.writeJournal && result.workerRunSummary) {
+      await appendWorkerRunJournal(result.workerRunSummary, { journalPath: cli.journalPath });
+    }
+
+    console.log(JSON.stringify({
+      ok: result.ok,
+      taskId: result.taskId,
+      error: result.error,
+      appliedTransition: result.appliedTransition,
+      transitionProposal: result.transitionProposal,
+      workerRunSummary: result.workerRunSummary,
+      steps: result.steps?.map((step) => step.phase),
+    }, null, 2));
+
+    if (!result.ok) {
+      process.exitCode = 1;
+    }
+  }
+}

package/vendor/src/agentWorkerLocalCliProvider.mjs

@@ -0,0 +1,217 @@
+import { spawnSync } from 'node:child_process';
+
+import { VERIFICATION_MATRIX } from './verificationLoop.mjs';
+
+const INPUT_SCHEMA = 'agent-worker.input.v1';
+const OUTPUT_SCHEMA = 'agent-worker.output.v1';
+
+const ALLOWLISTED_COMMANDS = new Set(
+  VERIFICATION_MATRIX
+    .map((row) => row.command)
+    .filter((command) => typeof command === 'string' && command.trim() !== '' && !command.startsWith('manual')),
+);
+
+export function resolveLocalCliProviderEnv(options = {}) {
+  const env = options.env ?? process.env;
+  return {
+    enabled: (options.enabled ?? env.IOHASC_LOCAL_CLI_WORKER) === '1',
+    cwd: String(options.cwd ?? env.IOHASC_LOCAL_CLI_CWD ?? process.cwd()).trim(),
+    timeoutMs: Number(options.timeoutMs ?? env.IOHASC_LOCAL_CLI_TIMEOUT_MS ?? 900_000),
+  };
+}
+
+export function resolveAllowlistedVerificationCommand(task) {
+  if (!task || typeof task !== 'object') {
+    return null;
+  }
+
+  const taskId = String(task.id ?? '').trim();
+  if (taskId === '') {
+    return null;
+  }
+
+  const matches = VERIFICATION_MATRIX.filter((row) => row.gateTaskIds.includes(taskId));
+  if (matches.length === 0) {
+    return null;
+  }
+
+  return matches.find((row) => ALLOWLISTED_COMMANDS.has(row.command)) ?? null;
+}
+
+export function assertAllowlistedCliCommand(command) {
+  const normalized = String(command ?? '').trim();
+  if (!ALLOWLISTED_COMMANDS.has(normalized)) {
+    throw new Error(`command not in verification allowlist: ${normalized}`);
+  }
+  return normalized;
+}
+
+export function executeAllowlistedCliCommand(command, options = {}) {
+  const allowlistedCommand = assertAllowlistedCliCommand(command);
+  const cwd = options.cwd ?? process.cwd();
+  const runCommand = options.runCommand ?? defaultRunCommand;
+  return runCommand(allowlistedCommand, { cwd, timeoutMs: options.timeoutMs ?? 900_000 });
+}
+
+export async function runLocalCliWorker(input, options = {}) {
+  const validationError = validateLocalCliWorkerInput(input);
+  if (validationError !== null) {
+    return buildLocalCliFailureOutput(input, validationError, 'code_failure');
+  }
+
+  const env = resolveLocalCliProviderEnv(options);
+  if (!env.enabled && options.requireLive !== false) {
+    return buildLocalCliFailureOutput(
+      input,
+      'Local CLI provider skipped: set IOHASC_LOCAL_CLI_WORKER=1 for live path',
+      'skipped',
+    );
+  }
+
+  if (input.policy?.allowShell !== true) {
+    return buildLocalCliFailureOutput(
+      input,
+      'Local CLI provider blocked: Worker Input policy.allowShell must be true',
+      'blocked',
+    );
+  }
+
+  const matrixRow = resolveAllowlistedVerificationCommand(input.task);
+  if (!matrixRow) {
+    return buildLocalCliFailureOutput(
+      input,
+      `No verification allowlist entry for task ${input.task.id}`,
+      'blocked',
+    );
+  }
+
+  try {
+    const result = executeAllowlistedCliCommand(matrixRow.command, {
+      cwd: options.cwd ?? env.cwd,
+      timeoutMs: env.timeoutMs,
+      runCommand: options.runCommand,
+    });
+
+    if (result.exitCode !== 0) {
+      return buildLocalCliFailureOutput(
+        input,
+        `Allowlisted command failed (${matrixRow.command}): exit ${result.exitCode}`,
+        'env_blocker',
+        {
+          command: matrixRow.command,
+          verificationId: matrixRow.id,
+          stdout: result.stdout,
+          stderr: result.stderr,
+        },
+      );
+    }
+
+    return {
+      schema: OUTPUT_SCHEMA,
+      runId: input.runId,
+      taskId: input.task.id,
+      status: 'succeeded',
+      patchSummary: {
+        changedFiles: [],
+        summary: `Allowlisted verification command succeeded: ${matrixRow.command}`,
+      },
+      evidence: [{
+        kind: 'verification_command',
+        source: 'local-cli',
+        result: 'succeeded',
+        summary: `${matrixRow.id}: ${matrixRow.command}`,
+        verificationId: matrixRow.id,
+        command: matrixRow.command,
+        exitCode: result.exitCode,
+      }],
+      transitionRequest: {
+        status: 'verify',
+        reason: `verification allowlist command passed (${matrixRow.id})`,
+      },
+      logs: [{
+        level: 'info',
+        message: `Executed allowlisted command ${matrixRow.command} with exit code ${result.exitCode}`,
+      }],
+      failureReason: '',
+      retryAdvice: '',
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return buildLocalCliFailureOutput(input, `Local CLI execution failed: ${message}`, 'env_blocker');
+  }
+}
+
+function defaultRunCommand(command, options = {}) {
+  const result = spawnSync(command, {
+    cwd: options.cwd,
+    encoding: 'utf8',
+    shell: true,
+    timeout: options.timeoutMs,
+  });
+
+  return {
+    exitCode: result.status ?? 1,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    signal: result.signal ?? null,
+  };
+}
+
+function validateLocalCliWorkerInput(input) {
+  if (!input || typeof input !== 'object') {
+    return 'input must be an object';
+  }
+
+  if (input.schema !== INPUT_SCHEMA) {
+    return `unsupported input schema: ${String(input.schema)}`;
+  }
+
+  if (!input.task || typeof input.task.id !== 'string' || input.task.id.trim() === '') {
+    return 'task.id must be a non-empty string';
+  }
+
+  if (input.policy?.allowNetwork === true) {
+    return 'local-cli provider MVP rejects allowNetwork policy flag';
+  }
+
+  if (input.policy?.allowFileWrite === true) {
+    return 'local-cli provider MVP rejects allowFileWrite policy flag';
+  }
+
+  return null;
+}
+
+function buildLocalCliFailureOutput(input, failureReason, failureClass, details = {}) {
+  const runId = typeof input?.runId === 'string' && input.runId.trim() !== '' ? input.runId : 'local-cli-invalid-input';
+  const taskId = typeof input?.task?.id === 'string' && input.task.id.trim() !== '' ? input.task.id : '';
+
+  return {
+    schema: OUTPUT_SCHEMA,
+    runId,
+    taskId,
+    status: 'failed',
+    patchSummary: {
+      changedFiles: [],
+      summary: failureClass === 'skipped'
+        ? 'Local CLI provider skipped (env-gated mode).'
+        : 'Local CLI provider failed before producing verification evidence.',
+    },
+    evidence: [{
+      kind: 'verification_command',
+      source: 'local-cli',
+      result: 'failed',
+      summary: failureReason,
+      failureClass,
+      ...details,
+    }],
+    transitionRequest: {
+      status: 'blocked',
+      reason: failureReason,
+    },
+    logs: [{ level: failureClass === 'skipped' ? 'info' : 'error', message: failureReason }],
+    failureReason,
+    retryAdvice: failureClass === 'skipped'
+      ? 'Set IOHASC_LOCAL_CLI_WORKER=1 and allowShell=true with a verification-matrix gate for the task.'
+      : 'Fix verification command environment or choose a different provider, then retry.',
+  };
+}