avorelo 0.1.0 → 0.3.0

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

@@ -1,279 +0,0 @@
-"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

@@ -1,314 +0,0 @@
-"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,
-};