avorelo 0.1.0

package/scripts/lib/orchestration/execution-manager.js

@@ -0,0 +1,279 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { classifyTask } = require("./risk-classifier");
+const {
+  appendJsonl,
+  tryAcquireRunLock,
+  releaseRunLock,
+} = require("./state");
+const { recordWorkerFailure } = require("./model-discovery");
+const { verifyWorkspace } = require("./verification-manager");
+
+function runCommand(command, args, options = {}) {
+  const runner = options.commandRunner;
+  if (typeof runner === "function") {
+    return runner(command, args, options);
+  }
+  return spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    encoding: "utf8",
+    timeout: options.timeoutMs || 20_000,
+  });
+}
+
+function summarizeGitDiff(cwd, options = {}) {
+  const result = runCommand("git", ["diff", "--stat", "--no-ext-diff"], {
+    cwd,
+    env: options.env || process.env,
+    timeoutMs: 10_000,
+    commandRunner: options.commandRunner,
+  });
+  return String(result.stdout || result.stderr || "").trim() || "No diff output captured.";
+}
+
+function highRiskTouchedFiles(taskContext, touchedFiles) {
+  const next = classifyTask(taskContext.taskText, { changedFiles: touchedFiles || [] });
+  return next.risk === "high" && taskContext.classification.risk !== "high";
+}
+
+function unrelatedFilesChanged(taskContext, touchedFiles) {
+  if (!Array.isArray(taskContext.selectedFiles) || taskContext.selectedFiles.length === 0) return false;
+  const allowed = new Set(taskContext.selectedFiles.map((item) => String(item).replace(/\\/g, "/")));
+  return (touchedFiles || []).some((item) => !allowed.has(String(item).replace(/\\/g, "/")));
+}
+
+function executeRoute({ cwd, runId, route, taskContext, adapters, settings, dryRun = false, executionLogPath = null, options = {} }) {
+  const lockResult = tryAcquireRunLock(cwd, {
+    runId,
+    task: taskContext.taskText,
+    surface: taskContext.surface,
+  }, {
+    timeoutMs: (settings.lockTimeoutMinutes || 20) * 60 * 1000,
+  });
+  if (!lockResult.ok) {
+    return {
+      finalStatus: "blocked",
+      failureReason: lockResult.reason,
+      steps: [],
+      failures: [{ stepId: "lock", reason: lockResult.reason }],
+      verification: { status: "skipped", reason: "Another orchestration run is still active." },
+      diffSummary: "Run blocked by active orchestration lock.",
+    };
+  }
+
+  const steps = [];
+  const failures = [];
+  let finalStatus = dryRun ? "dry_run" : "completed";
+  let failureReason = null;
+  let verification = { status: "skipped", reason: "No verification stage ran." };
+
+  try {
+    for (const stage of route.stageList || []) {
+      if (stage.role === "verify") {
+        if (dryRun) {
+          const result = {
+            stepId: stage.id,
+            toolId: stage.chosenTool,
+            selectedModel: stage.chosenModel || null,
+            modelProfile: stage.chosenModelProfile,
+            executionMode: "dry_run",
+            status: "skipped",
+            reason: "dry_run",
+          };
+          steps.push(result);
+          if (executionLogPath) appendJsonl(executionLogPath, result);
+          continue;
+        }
+
+        verification = verifyWorkspace(cwd, taskContext, options);
+        const result = {
+          stepId: stage.id,
+          toolId: stage.chosenTool,
+          selectedModel: stage.chosenModel || null,
+          modelProfile: stage.chosenModelProfile,
+          executionMode: "direct",
+          status: verification.status,
+          reason: verification.reason,
+        };
+        steps.push(result);
+        if (executionLogPath) appendJsonl(executionLogPath, result);
+        if (verification.status === "failed") {
+          recordWorkerFailure(cwd, {
+            workerId: stage.chosenTool,
+            modelId: stage.chosenModel || null,
+            reason: verification.reason,
+            taskType: taskContext.classification.taskType,
+            risk: taskContext.classification.risk,
+          });
+          finalStatus = "failed";
+          failureReason = verification.reason;
+          failures.push({ stepId: stage.id, reason: verification.reason });
+          break;
+        }
+        continue;
+      }
+
+      if (stage.role === "handoff" || stage.chosenTool === "avorelo_handoff") {
+        const result = {
+          stepId: stage.id,
+          toolId: stage.chosenTool,
+          selectedModel: null,
+          modelProfile: stage.chosenModelProfile,
+          executionMode: "local_command",
+          status: dryRun ? "skipped" : "pending",
+          reason: dryRun ? "dry_run" : "handoff_prompt_not_auto_executed",
+        };
+        steps.push(result);
+        if (executionLogPath) appendJsonl(executionLogPath, result);
+        continue;
+      }
+
+      const adapter = adapters[stage.chosenTool];
+      if (!adapter) {
+        finalStatus = "failed";
+        failureReason = `missing_adapter:${stage.chosenTool}`;
+        failures.push({ stepId: stage.id, reason: failureReason });
+        break;
+      }
+
+      if (dryRun) {
+        const result = {
+          stepId: stage.id,
+          toolId: stage.chosenTool,
+          selectedModel: stage.chosenModel || null,
+          modelProfile: stage.chosenModelProfile,
+          executionMode: "dry_run",
+          status: "skipped",
+          reason: "dry_run",
+        };
+        steps.push(result);
+        if (executionLogPath) appendJsonl(executionLogPath, result);
+        continue;
+      }
+
+      const primary = adapter.execute(stage, taskContext, options) || {};
+      const primaryResult = {
+        stepId: stage.id,
+        toolId: stage.chosenTool,
+        selectedModel: stage.chosenModel || primary.selectedModel || null,
+        modelProfile: stage.chosenModelProfile,
+        executionMode: primary.executionMode || adapter.executionMode || "handoff",
+        status: primary.status || "completed",
+        summary: primary.summary || null,
+        touchedFiles: primary.touchedFiles || [],
+        handoffInstruction: primary.handoffInstruction || null,
+      };
+      steps.push(primaryResult);
+      if (executionLogPath) appendJsonl(executionLogPath, primaryResult);
+
+      if (primary.unrelatedFilesChanged || unrelatedFilesChanged(taskContext, primaryResult.touchedFiles)) {
+        finalStatus = "blocked";
+        failureReason = "unrelated_files_changed";
+        failures.push({ stepId: stage.id, reason: failureReason });
+        break;
+      }
+
+      if (highRiskTouchedFiles(taskContext, primaryResult.touchedFiles)) {
+        finalStatus = "blocked";
+        failureReason = "route_escalated_high_risk";
+        failures.push({ stepId: stage.id, reason: failureReason });
+        break;
+      }
+
+      if (primary.status === "failed") {
+        recordWorkerFailure(cwd, {
+          workerId: stage.chosenTool,
+          modelId: stage.chosenModel || primary.selectedModel || null,
+          reason: primary.summary || "worker_failed",
+          taskType: taskContext.classification.taskType,
+          risk: taskContext.classification.risk,
+        });
+        const fallbackAdapter = stage.fallbackTool ? adapters[stage.fallbackTool] : null;
+        if (fallbackAdapter && settings.safety.stopAfterRepeatedFailures) {
+          const fallback = fallbackAdapter.execute({
+            ...stage,
+            chosenTool: stage.fallbackTool,
+            chosenModel: stage.fallbackModel,
+            chosenModelProfile: stage.fallbackModelProfile,
+          }, taskContext, options) || {};
+          const fallbackResult = {
+            stepId: `${stage.id}:fallback`,
+            toolId: stage.fallbackTool,
+            selectedModel: stage.fallbackModel || fallback.selectedModel || null,
+            modelProfile: stage.fallbackModelProfile,
+            executionMode: fallback.executionMode || fallbackAdapter.executionMode || "handoff",
+            status: fallback.status || "completed",
+            summary: fallback.summary || null,
+            touchedFiles: fallback.touchedFiles || [],
+            handoffInstruction: fallback.handoffInstruction || null,
+          };
+          steps.push(fallbackResult);
+          if (executionLogPath) appendJsonl(executionLogPath, fallbackResult);
+          if (fallback.status === "failed") {
+            recordWorkerFailure(cwd, {
+              workerId: stage.fallbackTool,
+              modelId: stage.fallbackModel || fallback.selectedModel || null,
+              reason: fallback.summary || "fallback_failed",
+              taskType: taskContext.classification.taskType,
+              risk: taskContext.classification.risk,
+            });
+            finalStatus = "failed";
+            failureReason = fallback.summary || "fallback_failed";
+            failures.push({ stepId: stage.id, reason: failureReason });
+            break;
+          }
+          if (fallback.status === "handoff_required" || fallback.status === "delegated_to_current_surface") {
+            finalStatus = "partial";
+          }
+          continue;
+        }
+        finalStatus = "failed";
+        failureReason = primary.summary || "worker_failed";
+        failures.push({ stepId: stage.id, reason: failureReason });
+        break;
+      }
+
+      if (primary.status === "handoff_required" || primary.status === "delegated_to_current_surface") {
+        finalStatus = "partial";
+      }
+    }
+
+    if (finalStatus === "completed" && verification.status === "skipped") {
+      verification = verifyWorkspace(cwd, taskContext, options);
+      steps.push({
+        stepId: "verify:auto",
+        toolId: "test_runner",
+        selectedModel: null,
+        modelProfile: null,
+        executionMode: "direct",
+        status: verification.status,
+        reason: verification.reason,
+      });
+      if (verification.status === "failed") {
+        finalStatus = "failed";
+        failureReason = verification.reason;
+      } else if (verification.status === "insufficient") {
+        finalStatus = "partial";
+      } else {
+        finalStatus = "verified";
+      }
+    }
+  } finally {
+    releaseRunLock(cwd, lockResult.lock.runId);
+  }
+
+  return {
+    finalStatus,
+    failureReason,
+    steps,
+    failures,
+    verification,
+    diffSummary: summarizeGitDiff(cwd, options),
+  };
+}
+
+module.exports = {
+  executeRoute,
+};

package/scripts/lib/orchestration/handoff.js

@@ -0,0 +1,314 @@
+"use strict";
+
+const path = require("path");
+const crypto = require("crypto");
+const {
+  getCurrentPaths,
+  writeJson,
+  writeText,
+  relativeFromCwd,
+} = require("./state");
+
+const HANDOFF_SCHEMA_VERSION = 1;
+
+const TARGET_LABELS = {
+  claude: "Claude Code",
+  codex: "Codex / OpenAI CLI",
+  "local-model": "Local model (LM Studio / Ollama)",
+  generic: "Generic AI session",
+};
+
+function redactHandoffValue(value) {
+  if (typeof value !== "string") return value;
+  return value
+    .replace(/(OPENROUTER_API_KEY|ANTHROPIC_AUTH_TOKEN|OPENAI_API_KEY|GEMINI_API_KEY|REQUESTY_API_KEY|LITELLM_API_KEY)=\S+/gi, "$1=[REDACTED]")
+    .replace(/sk-[A-Za-z0-9_-]+/g, "[REDACTED]")
+    .replace(/ghp_[A-Za-z0-9]+/g, "[REDACTED]")
+    .replace(/ghs_[A-Za-z0-9]+/g, "[REDACTED]");
+}
+
+function safeRedact(obj) {
+  if (typeof obj === "string") return redactHandoffValue(obj);
+  if (Array.isArray(obj)) return obj.map(safeRedact);
+  if (obj && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [k, safeRedact(v)])
+    );
+  }
+  return obj;
+}
+
+function summarizeChangedFiles(changedFiles = []) {
+  if (!changedFiles.length) return [];
+  const limit = 20;
+  const shown = changedFiles.slice(0, limit).map((f) => {
+    const p = typeof f === "string" ? f : f.path || f.file || String(f);
+    return redactHandoffValue(p);
+  });
+  if (changedFiles.length > limit) shown.push(`...and ${changedFiles.length - limit} more`);
+  return shown;
+}
+
+function buildQuotaSignalSummary(inventory) {
+  const tools = Array.isArray(inventory?.tools) ? inventory.tools : [];
+  const limited = tools.filter((t) => t.workerState === "recently_limited").map((t) => t.label);
+  const needsLogin = tools.filter((t) => t.workerState === "needs_login").map((t) => t.label);
+  const local = tools.filter((t) => t.quotaSignal === "local" || t.costTier === "free_local").map((t) => t.label);
+  return { limited, needsLogin, local };
+}
+
+function buildStageSummary(route) {
+  const stages = Array.isArray(route?.stageList) ? route.stageList : [];
+  return stages.map((s) => ({
+    id: s.id,
+    role: s.role,
+    worker: s.chosenLabel || s.chosenTool || "unknown",
+    model: s.chosenModel || s.chosenModelProfile || "unknown",
+    executionMode: s.executionMode || "unknown",
+    fallback: s.fallbackTool || null,
+  }));
+}
+
+function generateHandoffId() {
+  return `handoff-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
+}
+
+function buildHandoffPrompt(params) {
+  const {
+    target = "claude",
+    taskText = "",
+    route = null,
+    inventory = null,
+    changedFiles = [],
+    testsRun = [],
+    validationStatus = "unknown",
+    dogfoodStatus = "not_run",
+    whatWasDone = [],
+    doNotRedo = [],
+    remainingGaps = [],
+    exactNextAction = "",
+    safePathConstraints = [],
+    intakeWarnings = [],
+    selectedSkills = [],
+    nonGoals = [],
+    branchName = null,
+    prUrl = null,
+    lastCommit = null,
+    currentProof = null,
+    contextPackSummary = null,
+  } = params;
+
+  const handoffId = generateHandoffId();
+  const targetLabel = TARGET_LABELS[target] || target;
+  const quotaSignals = buildQuotaSignalSummary(inventory);
+  const stageSummary = buildStageSummary(route);
+  const recommendedWorkerForNext = TARGET_LABELS[target] || target;
+
+  const sections = [
+    `# Avorelo Handoff Prompt`,
+    ``,
+    `Handoff ID: ${handoffId}`,
+    `Target: ${targetLabel}`,
+    `Generated: ${new Date().toISOString()}`,
+    ``,
+    `## Mission`,
+    redactHandoffValue(taskText) || "Continue current work task.",
+    ``,
+  ];
+
+  if (branchName || prUrl || lastCommit) {
+    sections.push(`## Branch / PR State`);
+    if (branchName) sections.push(`Branch: ${branchName}`);
+    if (prUrl) sections.push(`PR: ${prUrl}`);
+    if (lastCommit) sections.push(`Last commit: ${lastCommit}`);
+    sections.push(``);
+  }
+
+  if (changedFiles.length) {
+    sections.push(`## Files Changed`);
+    summarizeChangedFiles(changedFiles).forEach((f) => sections.push(`- ${f}`));
+    sections.push(``);
+  }
+
+  if (testsRun.length) {
+    sections.push(`## Tests Run`);
+    testsRun.forEach((t) => sections.push(`- ${redactHandoffValue(String(t))}`));
+    sections.push(``);
+  }
+
+  sections.push(`## Validation Status`);
+  sections.push(redactHandoffValue(String(validationStatus)));
+  sections.push(``);
+
+  if (whatWasDone.length) {
+    sections.push(`## What Was Already Done`);
+    whatWasDone.forEach((item) => sections.push(`- ${redactHandoffValue(String(item))}`));
+    sections.push(``);
+  }
+
+  if (doNotRedo.length) {
+    sections.push(`## Do NOT Redo`);
+    doNotRedo.forEach((item) => sections.push(`- ${redactHandoffValue(String(item))}`));
+    sections.push(``);
+  }
+
+  if (remainingGaps.length) {
+    sections.push(`## Remaining Gaps`);
+    remainingGaps.forEach((item) => sections.push(`- ${redactHandoffValue(String(item))}`));
+    sections.push(``);
+  }
+
+  if (exactNextAction) {
+    sections.push(`## Exact Next Action`);
+    sections.push(redactHandoffValue(exactNextAction));
+    sections.push(``);
+  }
+
+  if (stageSummary.length) {
+    sections.push(`## Stage Plan (from Avorelo route)`);
+    stageSummary.forEach((s) => {
+      sections.push(`- ${s.id} (${s.role}): ${s.worker} / ${s.model} via ${s.executionMode}${s.fallback ? ` · fallback: ${s.fallback}` : ""}`);
+    });
+    sections.push(``);
+  }
+
+  if (safePathConstraints.length) {
+    sections.push(`## Safe Path Constraints`);
+    safePathConstraints.forEach((c) => sections.push(`- ${redactHandoffValue(String(c))}`));
+    sections.push(``);
+  }
+
+  if (intakeWarnings.length) {
+    sections.push(`## Intake Warnings`);
+    intakeWarnings.forEach((w) => sections.push(`- ${redactHandoffValue(String(w))}`));
+    sections.push(``);
+  }
+
+  if (quotaSignals.limited.length) {
+    sections.push(`## Worker Quota Signals`);
+    quotaSignals.limited.forEach((label) => sections.push(`- ${label}: RECENTLY_LIMITED — avoid for implementation`));
+    quotaSignals.needsLogin.forEach((label) => sections.push(`- ${label}: NEEDS_LOGIN — requires auth before use`));
+    if (quotaSignals.local.length) {
+      sections.push(`Local workers available: ${quotaSignals.local.join(", ")}`);
+    }
+    sections.push(``);
+  }
+
+  if (selectedSkills.length) {
+    sections.push(`## Selected Skills / Capabilities`);
+    selectedSkills.forEach((s) => sections.push(`- ${redactHandoffValue(String(s))}`));
+    sections.push(``);
+  }
+
+  if (contextPackSummary) {
+    sections.push(`## Context Pack`);
+    sections.push(`Path: ${contextPackSummary.contextPackPath || "unknown"}`);
+    sections.push(`Stage: ${contextPackSummary.stageId || "unknown"} · Budget: ${contextPackSummary.budgetClass || "unknown"} · ~${contextPackSummary.tokenEstimate || 0} tokens`);
+    if (contextPackSummary.budgetWarning && contextPackSummary.budgetWarning !== "within_budget") {
+      sections.push(`Warning: ${contextPackSummary.budgetWarning}`);
+    }
+    sections.push(`Included: ${contextPackSummary.includedCount || 0} items · Excluded: ${contextPackSummary.excludedCount || 0} items`);
+    if (contextPackSummary.nextAction) {
+      sections.push(`Next: ${redactHandoffValue(contextPackSummary.nextAction)}`);
+    }
+    sections.push(``);
+  }
+
+  sections.push(`## Recommended Worker for Next Stage`);
+  sections.push(recommendedWorkerForNext);
+  sections.push(``);
+
+  if (nonGoals.length) {
+    sections.push(`## Explicit Non-Goals (do not implement)`);
+    nonGoals.forEach((g) => sections.push(`- ${redactHandoffValue(String(g))}`));
+    sections.push(``);
+  }
+
+  sections.push(`---`);
+  sections.push(`*Compact handoff generated by Avorelo — not a generic gateway. Work-aware routing only.*`);
+  sections.push(``);
+
+  const promptText = sections.join("\n");
+
+  const receipt = {
+    schemaVersion: HANDOFF_SCHEMA_VERSION,
+    contract: "avorelo.handoff.v1",
+    handoffId,
+    generatedAt: new Date().toISOString(),
+    target,
+    targetLabel,
+    taskSummary: redactHandoffValue(taskText).slice(0, 200),
+    branchName: branchName || null,
+    prUrl: prUrl || null,
+    lastCommit: lastCommit || null,
+    changedFileCount: changedFiles.length,
+    testsRun: testsRun.map((t) => redactHandoffValue(String(t))),
+    validationStatus: redactHandoffValue(String(validationStatus)),
+    whatWasDone: whatWasDone.map((i) => redactHandoffValue(String(i))),
+    doNotRedo: doNotRedo.map((i) => redactHandoffValue(String(i))),
+    remainingGaps: remainingGaps.map((i) => redactHandoffValue(String(i))),
+    exactNextAction: redactHandoffValue(exactNextAction),
+    stageSummary,
+    quotaSignals,
+    safePathConstraints: safePathConstraints.map((c) => redactHandoffValue(String(c))),
+    intakeWarnings: intakeWarnings.map((w) => redactHandoffValue(String(w))),
+    selectedSkills: selectedSkills.map((s) => redactHandoffValue(String(s))),
+    nonGoals: nonGoals.map((g) => redactHandoffValue(String(g))),
+    recommendedWorkerForNext,
+    contextPackSummary: contextPackSummary || null,
+    redacted: true,
+  };
+
+  return { handoffId, promptText, receipt };
+}
+
+function writeHandoff(cwd, params) {
+  const result = buildHandoffPrompt(params);
+  const paths = getCurrentPaths(cwd);
+  const handoffsDir = path.join(paths.root, "handoffs");
+
+  const promptPath = path.join(handoffsDir, `${result.handoffId}.md`);
+  const receiptPath = path.join(handoffsDir, `${result.handoffId}.json`);
+  const currentPromptPath = path.join(handoffsDir, "current-handoff.md");
+  const currentReceiptPath = path.join(handoffsDir, "current-handoff.json");
+
+  writeText(promptPath, result.promptText);
+  writeJson(receiptPath, result.receipt);
+  writeText(currentPromptPath, result.promptText);
+  writeJson(currentReceiptPath, result.receipt);
+
+  return {
+    handoffId: result.handoffId,
+    promptPath: relativeFromCwd(cwd, promptPath),
+    receiptPath: relativeFromCwd(cwd, receiptPath),
+    currentPromptPath: relativeFromCwd(cwd, currentPromptPath),
+    currentReceiptPath: relativeFromCwd(cwd, currentReceiptPath),
+    promptText: result.promptText,
+    receipt: result.receipt,
+  };
+}
+
+function readCurrentHandoff(cwd) {
+  const paths = getCurrentPaths(cwd);
+  const handoffsDir = path.join(paths.root, "handoffs");
+  const currentReceiptPath = path.join(handoffsDir, "current-handoff.json");
+  const currentPromptPath = path.join(handoffsDir, "current-handoff.md");
+
+  let receipt = null;
+  let promptText = null;
+  try {
+    receipt = JSON.parse(require("fs").readFileSync(currentReceiptPath, "utf8"));
+  } catch {}
+  try {
+    promptText = require("fs").readFileSync(currentPromptPath, "utf8");
+  } catch {}
+
+  return { receipt, promptText };
+}
+
+module.exports = {
+  buildHandoffPrompt,
+  writeHandoff,
+  readCurrentHandoff,
+  HANDOFF_SCHEMA_VERSION,
+};