avorelo 0.1.0 → 0.3.0

package/scripts/lib/orchestration/index.js

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

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