avorelo 0.1.0

package/scripts/lib/orchestration/index.js

@@ -0,0 +1,456 @@
+"use strict";
+
+const { loadInventory, inventoryText, summarizeInventoryForText } = require("./inventory");
+const { classifyTask } = require("./risk-classifier");
+const { planRoute } = require("./routing-policy");
+const { createAdapterRegistry } = require("./adapters");
+const { executeRoute } = require("./execution-manager");
+const { verifyWorkspace } = require("./verification-manager");
+const { getSettings, settingsMetadata } = require("./settings");
+const {
+  ensureOrchestrationDirs,
+  createRunId,
+  getCurrentPaths,
+  getRunPaths,
+  safeReadJson,
+} = require("./state");
+const {
+  buildProof,
+  buildAgentModelOrchestrationReceipt,
+  writeOrchestrationReceipt,
+  readOrchestrationReceipt,
+  writeCurrentArtifacts,
+  writeRunArtifacts,
+  writeHostContracts,
+  renderProofMarkdown,
+} = require("./proof-writer");
+const { writeHandoff, readCurrentHandoff } = require("./handoff");
+const { buildAgentAccessGovernanceSurface } = require("../agent-access-governance");
+const { buildSafePathSurface } = require("../safe-path-engine");
+const { buildInstallIntakeRiskSurface } = require("../install-intake-risk");
+const { buildSkillsOperatingLayerSurface } = require("../skills-operating-layer");
+const { buildWorkControlSurface } = require("../work-control-receipts");
+const { buildAiWorkspaceHygieneSurface } = require("../ai-workspace-hygiene");
+
+function buildTaskContext(taskText, options = {}) {
+  const classification = classifyTask(taskText, {
+    changedFiles: options.changedFiles || [],
+    selectedFiles: options.selectedFiles || [],
+  });
+  return {
+    taskText,
+    surface: options.surface || "avorelo_cli",
+    classification,
+    selectedFiles: options.selectedFiles || [],
+    changedFiles: options.changedFiles || [],
+  };
+}
+
+function routeTask(cwd, taskText, options = {}) {
+  ensureOrchestrationDirs(cwd);
+  const settings = getSettings(cwd);
+  const taskContext = buildTaskContext(taskText, options);
+  const inventory = loadInventory(cwd, {
+    env: options.env,
+    commandExists: options.commandExists,
+    commandRunner: options.commandRunner,
+    httpGetJson: options.httpGetJson,
+    surface: taskContext.surface,
+    refresh: options.refreshInventory,
+    deepRefresh: options.deepRefresh,
+  });
+  const route = planRoute({
+    taskText,
+    task: taskContext.classification,
+    inventory,
+    settings,
+    surface: taskContext.surface,
+  });
+  const proof = buildProof({
+    runId: options.runId || createRunId(),
+    taskContext,
+    route,
+    execution: {
+      finalStatus: "planned",
+      steps: [],
+      failures: [],
+      verification: { status: "skipped", reason: "Route only." },
+      diffSummary: null,
+    },
+    verification: { status: "skipped", reason: "Route only." },
+  });
+  writeCurrentArtifacts(cwd, taskContext, route, proof);
+  const hostContracts = writeHostContracts(cwd, route, taskContext, proof);
+  const orchestrationReceipt = buildAgentModelOrchestrationReceipt({ route, proof, cwd });
+  const orchestrationReceiptPath = writeOrchestrationReceipt(cwd, orchestrationReceipt);
+  return {
+    taskContext,
+    inventory,
+    route,
+    proof,
+    hostContracts,
+    orchestrationReceipt,
+    orchestrationReceiptPath,
+  };
+}
+
+function runTask(cwd, taskText, options = {}) {
+  ensureOrchestrationDirs(cwd);
+  const runId = options.runId || createRunId();
+  const routed = routeTask(cwd, taskText, { ...options, runId });
+  const settings = getSettings(cwd);
+  const runPaths = getRunPaths(cwd, runId);
+  const adapters = options.adapters || createAdapterRegistry();
+  const execution = executeRoute({
+    cwd,
+    runId,
+    route: routed.route,
+    taskContext: routed.taskContext,
+    adapters,
+    settings,
+    dryRun: options.dryRun === true,
+    executionLogPath: runPaths.executionLog,
+    options,
+  });
+  const verification = execution.verification || verifyWorkspace(cwd, routed.taskContext, options);
+  const proof = buildProof({
+    runId,
+    taskContext: routed.taskContext,
+    route: routed.route,
+    execution,
+    verification,
+  });
+  writeRunArtifacts(cwd, runId, routed.taskContext, routed.route, execution, verification, proof);
+  writeCurrentArtifacts(cwd, routed.taskContext, routed.route, proof);
+  const hostContracts = writeHostContracts(cwd, routed.route, routed.taskContext, proof);
+  return {
+    runId,
+    taskContext: routed.taskContext,
+    inventory: routed.inventory,
+    route: routed.route,
+    execution,
+    verification,
+    proof,
+    hostContracts,
+  };
+}
+
+function readCurrentProof(cwd) {
+  const paths = getCurrentPaths(cwd);
+  const proof = safeReadJson(paths.currentProofJson, null);
+  const governance = buildAgentAccessGovernanceSurface(cwd);
+  const safePath = buildSafePathSurface(cwd);
+  const installIntakeRisk = buildInstallIntakeRiskSurface(cwd);
+  const skillsOperatingLayer = buildSkillsOperatingLayerSurface(cwd);
+  const workControl = buildWorkControlSurface(cwd);
+  const aiWorkspaceHygiene = buildAiWorkspaceHygieneSurface(cwd);
+  if (!proof) {
+    return governance.latestReceiptPath || safePath.latestReceiptPath || installIntakeRisk.latestReceiptPath || skillsOperatingLayer.latestSourceAdoptionReceiptPath
+      ? {
+          governance,
+          safePath,
+          installIntakeRisk,
+          skillsOperatingLayer,
+          workControl,
+          aiWorkspaceHygiene,
+        }
+      : null;
+  }
+  return {
+    ...proof,
+    governance,
+    safePath,
+    installIntakeRisk,
+    skillsOperatingLayer,
+    workControl,
+    aiWorkspaceHygiene,
+  };
+}
+
+function buildOrchestrationStatus(cwd, options = {}) {
+  ensureOrchestrationDirs(cwd);
+  const settings = getSettings(cwd);
+  const inventory = loadInventory(cwd, {
+    env: options.env,
+    commandExists: options.commandExists,
+    commandRunner: options.commandRunner,
+    httpGetJson: options.httpGetJson,
+    surface: options.surface || "avorelo_cli",
+    refresh: options.refreshInventory,
+    deepRefresh: options.deepRefresh,
+  });
+  const currentPaths = getCurrentPaths(cwd);
+  const route = safeReadJson(currentPaths.currentRouteJson, null);
+  const proof = safeReadJson(currentPaths.currentProofJson, null);
+  const summary = summarizeInventoryForText(inventory);
+  const statusLine = route
+    ? `Orchestration: ${settings.mode} · ${route.state} · ${summary.available} workers available · inventory ${inventory.inventorySource || "cache"} · next refresh ${inventory.nextFullModelRefreshAfter || "unknown"} · last task ${route.task?.risk || "unknown"} risk`
+    : `Orchestration: ${settings.mode} · ${summary.available} workers available · inventory ${inventory.inventorySource || "cache"} · next refresh ${inventory.nextFullModelRefreshAfter || "unknown"}`;
+  return {
+    showInStatus: true,
+    statusLine,
+    settings: settingsMetadata(settings),
+    inventory,
+    currentRoute: route,
+    currentProof: proof,
+    summary,
+    whyChosen: route?.whyChosen || [],
+  };
+}
+
+function modelsText(cwd, options = {}) {
+  return inventoryText(loadInventory(cwd, options));
+}
+
+function proofText(cwd, options = {}) {
+  const proof = readCurrentProof(cwd);
+  if (!proof) return "No orchestration proof is available yet.\n";
+  if (!proof.runId && (proof.governance || proof.safePath || proof.skillsOperatingLayer)) {
+    return [
+      "No orchestration proof is available yet.",
+      "",
+      `Agent Access Governance: ${String(proof.governance.status || "partial").toUpperCase()}`,
+      `Latest receipt: ${proof.governance.latestReceiptPath || "missing"}`,
+      `Unknown subjects: ${proof.governance.unknownSubjects}`,
+      proof.safePath
+        ? `Safe Path: ${String(proof.safePath.status || "foundation").toUpperCase()} · last=${proof.safePath.lastDecision || "none"} · latest receipt ${proof.safePath.latestReceiptPath || "missing"}`
+        : null,
+      proof.installIntakeRisk
+        ? `Install Intake: ${String(proof.installIntakeRisk.status || "foundation").toUpperCase()} · items=${proof.installIntakeRisk.totalItems} · unknown=${proof.installIntakeRisk.unknownItems} · latest receipt ${proof.installIntakeRisk.latestReceiptPath || "missing"}`
+        : null,
+      proof.skillsOperatingLayer
+        ? `Skills Operating Layer: ${String(proof.skillsOperatingLayer.status || "foundation").toUpperCase()} · reviewed=${proof.skillsOperatingLayer.reviewedSources} · deferred=${proof.skillsOperatingLayer.deferredSources} · latest receipt ${proof.skillsOperatingLayer.latestSourceAdoptionReceiptPath || "missing"}`
+        : null,
+      `Next: ${proof.safePath?.nextAction || proof.governance.nextAction}`,
+      "",
+    ].filter(Boolean).join("\n");
+  }
+  const rendered = renderProofMarkdown(proof, options);
+  const trailingSections = [];
+  if (proof.governance?.latestReceiptPath) {
+    trailingSections.push(
+      [
+        "Agent Access Governance:",
+        `- Status: ${String(proof.governance.status || "partial").toUpperCase()}`,
+        `- Latest receipt: ${proof.governance.latestReceiptPath}`,
+        `- Unknown subjects: ${proof.governance.unknownSubjects}`,
+        `- Top reason codes: ${(proof.governance.topReasonCodes || []).join(", ") || "none"}`,
+      ].join("\n")
+    );
+  }
+  if (proof.safePath?.latestReceiptPath) {
+    trailingSections.push(
+      [
+        "Safe Path:",
+        `- Status: ${String(proof.safePath.status || "foundation").toUpperCase()}`,
+        `- Latest receipt: ${proof.safePath.latestReceiptPath}`,
+        `- Last decision: ${proof.safePath.lastDecision || "none"}`,
+        `- Top reason codes: ${(proof.safePath.topReasonCodes || []).join(", ") || "none"}`,
+        `- Reductions recommended: ${proof.safePath.reductionsRecommended || 0}`,
+        `- Approvals required: ${proof.safePath.approvalsRequired || 0}`,
+        `- Skill context warnings: ${proof.safePath.skillContextWarnings || 0}`,
+      ].join("\n")
+    );
+  }
+  if (proof.installIntakeRisk?.latestReceiptPath) {
+    trailingSections.push(
+      [
+        "Install Intake:",
+        `- Status: ${String(proof.installIntakeRisk.status || "foundation").toUpperCase()}`,
+        `- Latest receipt: ${proof.installIntakeRisk.latestReceiptPath}`,
+        `- Total items: ${proof.installIntakeRisk.totalItems || 0}`,
+        `- Unknown items: ${proof.installIntakeRisk.unknownItems || 0}`,
+        `- Deferred items: ${proof.installIntakeRisk.deferredItems || 0}`,
+        `- Blocked items: ${proof.installIntakeRisk.blockedItems || 0}`,
+        `- High-risk items: ${proof.installIntakeRisk.highRiskItems || 0}`,
+        `- Top reason codes: ${(proof.installIntakeRisk.topReasonCodes || []).join(", ") || "none"}`,
+      ].join("\n")
+    );
+  }
+  if (proof.skillsOperatingLayer?.latestSourceAdoptionReceiptPath || proof.skillsOperatingLayer?.latestSkillRouteReceiptPath) {
+    trailingSections.push(
+      [
+        "Skills Operating Layer:",
+        `- Status: ${String(proof.skillsOperatingLayer.status || "foundation").toUpperCase()}`,
+        `- Reviewed sources: ${proof.skillsOperatingLayer.reviewedSources}`,
+        `- Deferred sources: ${proof.skillsOperatingLayer.deferredSources}`,
+        `- Parsed skills: ${proof.skillsOperatingLayer.parsedSkills}`,
+        `- Latest source receipt: ${proof.skillsOperatingLayer.latestSourceAdoptionReceiptPath || "missing"}`,
+        `- Latest route receipt: ${proof.skillsOperatingLayer.latestSkillRouteReceiptPath || "missing"}`,
+        `- Latest adapter receipt: ${proof.skillsOperatingLayer.latestAdapterSyncReceiptPath || "missing"}`,
+      ].join("\n")
+    );
+  }
+  if (proof.workControl?.latestReceiptPath) {
+    trailingSections.push(
+      [
+        "Work Control:",
+        `- Status: ${String(proof.workControl.status || "missing").toUpperCase()}`,
+        `- Final state: ${proof.workControl.finalState || "missing"}`,
+        `- Latest receipt: ${proof.workControl.latestReceiptPath}`,
+        `- Blocked: ${proof.workControl.blockedCount || 0}`,
+        `- Approval required: ${proof.workControl.approvalRequiredCount || 0}`,
+        `- High-risk intake: ${proof.workControl.highRiskIntakeCount || 0}`,
+        `- Next safest action: ${proof.workControl.nextSafestAction || "none"}`,
+      ].join("\n")
+    );
+  }
+  if (proof.aiWorkspaceHygiene?.latestReportPath) {
+    trailingSections.push(
+      [
+        "AI Workspace Hygiene:",
+        `- Status: ${String(proof.aiWorkspaceHygiene.status || "not_run").toUpperCase()}`,
+        proof.aiWorkspaceHygiene.score != null ? `- Score: ${proof.aiWorkspaceHygiene.score}/100` : null,
+        `- Total assets: ${proof.aiWorkspaceHygiene.totalAssets ?? "unknown"}`,
+        `- Needs review: ${proof.aiWorkspaceHygiene.needsReview ?? 0}`,
+        `- High risk: ${proof.aiWorkspaceHygiene.highRisk ?? 0}`,
+        `- Latest report: ${proof.aiWorkspaceHygiene.latestReportPath}`,
+        proof.aiWorkspaceHygiene.nextAction ? `- Next action: ${proof.aiWorkspaceHygiene.nextAction}` : null,
+      ].filter(Boolean).join("\n")
+    );
+  }
+  // Work Ledger
+  try {
+    const { buildWorkLedgerSurface } = require("../work-ledger");
+    const ledgerSurface = buildWorkLedgerSurface(cwd);
+    if (ledgerSurface && ledgerSurface.status !== "not_available") {
+      trailingSections.push(
+        [
+          "Work Ledger:",
+          `- Status: ${String(ledgerSurface.status || "unknown").toUpperCase()}`,
+          `- Entries: ${ledgerSurface.entryCount ?? 0}`,
+          `- Friction points: ${ledgerSurface.frictionCount ?? 0}`,
+          `- Latest ledger: ${ledgerSurface.latestLedgerPath}`,
+          ledgerSurface.nextAction ? `- Next: ${ledgerSurface.nextAction}` : null,
+        ].filter(Boolean).join("\n")
+      );
+    }
+  } catch { /* non-blocking */ }
+
+  // Company Loop
+  try {
+    const { buildCompanyLoopSurface } = require("../company-loop");
+    const loopSurface = buildCompanyLoopSurface(cwd);
+    if (loopSurface && loopSurface.status !== "not_available") {
+      trailingSections.push(
+        [
+          "Company Loop:",
+          `- Status: ${String(loopSurface.status || "unknown").toUpperCase()}`,
+          `- Persona warnings: ${loopSurface.personaWarnCount ?? 0}`,
+          loopSurface.topFriction ? `- Top friction: ${loopSurface.topFriction}` : null,
+          `- Recommended next PR: ${loopSurface.recommendedNextPr || "not_available"}`,
+          `- Confidence: ${loopSurface.confidence || "low"}`,
+          `- Latest report: ${loopSurface.latestReportPath}`,
+        ].filter(Boolean).join("\n")
+      );
+    }
+  } catch { /* non-blocking */ }
+
+  if (!trailingSections.length) return rendered;
+  return [rendered.trimEnd(), "", ...trailingSections, ""].join("\n");
+}
+
+function generateHandoff(cwd, params = {}) {
+  ensureOrchestrationDirs(cwd);
+  const paths = getCurrentPaths(cwd);
+  const route = safeReadJson(paths.currentRouteJson, null);
+  const inventory = loadInventory(cwd, { surface: "avorelo_cli" });
+  const result = writeHandoff(cwd, {
+    target: params.target || "claude",
+    taskText: params.taskText || route?.taskText || "Continue current work",
+    route,
+    inventory,
+    changedFiles: params.changedFiles || [],
+    testsRun: params.testsRun || [],
+    validationStatus: params.validationStatus || "unknown",
+    dogfoodStatus: params.dogfoodStatus || "not_run",
+    whatWasDone: params.whatWasDone || [],
+    doNotRedo: params.doNotRedo || [],
+    remainingGaps: params.remainingGaps || [],
+    exactNextAction: params.exactNextAction || route?.expectedVerification?.[0] || "",
+    safePathConstraints: params.safePathConstraints || (route?.safetyNotes || []),
+    intakeWarnings: params.intakeWarnings || [],
+    selectedSkills: params.selectedSkills || [],
+    nonGoals: params.nonGoals || [],
+    branchName: params.branchName || null,
+    prUrl: params.prUrl || null,
+    lastCommit: params.lastCommit || null,
+  });
+  return result;
+}
+
+function buildAgentModelOrchestrationSurface(cwd) {
+  try {
+    const receipt = readOrchestrationReceipt(cwd);
+    const handoff = readCurrentHandoff(cwd);
+    const paths = getCurrentPaths(cwd);
+    const route = safeReadJson(paths.currentRouteJson, null);
+
+    if (!receipt && !route) {
+      return {
+        status: "not_run",
+        latestReceiptPath: null,
+        workersDetected: 0,
+        availableWorkers: 0,
+        limitedWorkers: 0,
+        localWorkersAvailable: 0,
+        selectedWorker: null,
+        fallbackWorker: null,
+        stageCount: 0,
+        handoffAvailable: false,
+        nextAction: "Run: avorelo route \"<task>\" to generate a route plan",
+      };
+    }
+
+    const r = receipt || {};
+    const stageCount = r.stageCount || (route?.stageList || []).length || 0;
+    const limitedWorkers = (r.quotaSignals?.limitedWorkers || []).length;
+    const localWorkersAvailable = (r.localWorkersAvailable || route?.localWorkersAvailable || []).length;
+    const statusText = limitedWorkers > 0 ? "limited" : localWorkersAvailable > 0 ? "local_available" : "ready";
+
+    return {
+      status: statusText,
+      contract: r.contract || "avorelo.agentModelOrchestration.v1",
+      latestReceiptPath: paths ? require("path").join(paths.root, "receipts", "current-orchestration-receipt.json").replace(/\\/g, "/") : null,
+      routeState: r.routeState || route?.state || "unknown",
+      selectedWorker: r.selectedWorkers?.[0]?.toolId || route?.chosenTool || null,
+      fallbackWorker: r.fallbackWorkers?.[0]?.toolId || route?.fallbackTool || null,
+      stageCount,
+      limitedWorkers,
+      localWorkersAvailable,
+      handoffAvailable: Boolean(r.handoffAvailable || handoff.receipt),
+      handoffPromptPath: r.handoffPromptPath || handoff.receipt?.handoffId ? `.claude/cco/orchestration/handoffs/current-handoff.md` : null,
+      fallbackReasonCodes: r.quotaSignals?.fallbackReasonCodes || [],
+      localWorkerRecommendation: r.localWorkerRecommendation || null,
+      nextAction: r.nextAction || "Run: avorelo route \"<task>\" to generate a stage plan",
+      notAGateway: true,
+      foundationOnly: true,
+    };
+  } catch {
+    return {
+      status: "error",
+      latestReceiptPath: null,
+      workersDetected: 0,
+      availableWorkers: 0,
+      limitedWorkers: 0,
+      localWorkersAvailable: 0,
+      selectedWorker: null,
+      fallbackWorker: null,
+      stageCount: 0,
+      handoffAvailable: false,
+      nextAction: "Run: avorelo route \"<task>\" to generate a route plan",
+    };
+  }
+}
+
+module.exports = {
+  buildTaskContext,
+  routeTask,
+  runTask,
+  buildOrchestrationStatus,
+  buildAgentModelOrchestrationSurface,
+  generateHandoff,
+  modelsText,
+  readCurrentProof,
+  proofText,
+};

package/scripts/lib/orchestration/inventory.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const { loadInventory, summarizeInventoryForText, INVENTORY_SCHEMA_VERSION } = require("./model-discovery");
+
+function describeToolStatus(tool) {
+  if (tool.toolId === "gemini_cli" && tool.installStatus === "installed_not_on_path") {
+    return "Gemini CLI command not found on PATH";
+  }
+  if (tool.toolId === "lm_studio" && tool.installStatus === "installed_or_configured_but_not_running") {
+    return "LM Studio local server not running";
+  }
+  if (tool.toolId === "lm_studio" && tool.installStatus === "configured_but_no_models") {
+    return "LM Studio local server reachable but no loaded models";
+  }
+  if (tool.availability === "needs_login") return "needs login";
+  return `${tool.installStatus}/${tool.availability}`;
+}
+
+function inventoryText(inventory) {
+  const summary = summarizeInventoryForText(inventory);
+  const lines = [
+    "Avorelo Model + Worker Inventory",
+    `Inventory source: ${inventory.inventorySource || "cache"}`,
+    `Refresh level: ${inventory.refreshLevel || "cache"}`,
+    `Last full model refresh: ${inventory.lastFullModelRefreshAt || "unknown"}`,
+    `Next full model refresh after: ${inventory.nextFullModelRefreshAfter || "unknown"}`,
+    `Detected: ${summary.available}/${summary.total} available · ${summary.enabled} enabled`,
+  ];
+  (inventory.tools || []).forEach((tool) => {
+    const selected = tool.activeModel || "unknown";
+    const roles = (tool.supportedRoles || []).join(", ") || "n/a";
+    const notes = [];
+    if (tool.workerState === "disabled_by_user") notes.push("disabled_by_user");
+    if (tool.workerState === "recently_limited") notes.push("recently_limited");
+    if (tool.workerState === "recently_failed") notes.push("recently_failed");
+    if (tool.workerState === "needs_login") notes.push("needs_login");
+    lines.push(`- ${tool.label}: ${describeToolStatus(tool)} · selected ${selected} · roles ${roles} · cost ${tool.costTier} · trust ${tool.trustTier}${notes.length ? ` · ${notes.join(", ")}` : ""}`);
+  });
+  return lines.join("\n");
+}
+
+module.exports = {
+  INVENTORY_SCHEMA_VERSION,
+  loadInventory,
+  inventoryText,
+  summarizeInventoryForText,
+};