avorelo 0.1.0

package/scripts/lib/optimization-v3.js

@@ -0,0 +1,122 @@
+"use strict";
+
+const { buildMemoryEvidence } = require("./memory");
+
+const SLICE1_ALLOWED_RECOMMENDATIONS = new Set([
+  "REC_LOOP_REPLAN",
+  "REC_RETRY_SUPPRESSION",
+  "REC_PROMPT_ENVELOPE",
+  "REC_ENABLE_TOOL_SEARCH",
+  "REC_MCP_OUTPUT_CAP",
+  "REC_PRECOMPACT_EVIDENCE",
+]);
+
+function confidenceRank(label) {
+  if (label === "high") return 3;
+  if (label === "medium") return 2;
+  return 1;
+}
+
+function saturationGroup(traceId) {
+  if (/MCP|OUTPUT|THINKING/.test(traceId)) return "cost";
+  if (/SEC|TRUST|WORKTREE/.test(traceId)) return "security";
+  if (/LOOP|RETRY|PROMPT|PRECOMPACT/.test(traceId)) return "quality";
+  return "general";
+}
+
+function adoptionBoost(traceId, memoryProfile) {
+  const outcome = memoryProfile?.recommendationOutcomes?.[traceId];
+  if (!outcome) return 0;
+  const shown = Number(outcome.shownCount || 0);
+  const accepted = Number(outcome.acceptedCount || 0);
+  if (shown <= 0) return 0;
+  return Math.round((accepted / shown) * 4);
+}
+
+function memoryBoost(trace, memoryProfile) {
+  const evidence = buildMemoryEvidence(trace.id, memoryProfile);
+  const baseBoost = evidence.length;
+  const scoreBoost = Number(memoryProfile?.memoryScore || 0) < 60 ? 1 : 0;
+  return { boost: baseBoost + scoreBoost, evidence };
+}
+
+function withPercentileHint(trace, signals) {
+  if (trace.id !== "REC_MCP_OUTPUT_CAP") return trace;
+  const p95 = Number(signals?.outputBytesP95 || 0);
+  if (!p95) return trace;
+  const suggested = Math.max(12000, Math.round(p95 * 0.85));
+  return {
+    ...trace,
+    text: `${trace.text} Suggested cap: ${suggested} bytes (from p95 output).`,
+    actionPath: `${trace.actionPath} -> suggested_cap=${suggested}`,
+  };
+}
+
+function applyRecommendationDecision(params) {
+  const { traces, memoryProfile, signals, profileName } = params;
+  const list = (Array.isArray(traces) ? traces : []).filter((t) => SLICE1_ALLOWED_RECOMMENDATIONS.has(String(t.id || t.recommendationId || "")));
+
+  const ranked = list
+    .map((trace) => {
+      const mem = memoryBoost(trace, memoryProfile);
+      const adoption = adoptionBoost(trace.id, memoryProfile);
+      const adjusted = withPercentileHint(trace, signals);
+      const saturation = saturationGroup(trace.id);
+      const finalWeight = Number(trace.weight || trace.score || 0) + mem.boost + adoption;
+
+      return {
+        ...adjusted,
+        recommendationId: adjusted.id,
+        saturationGroup: saturation,
+        memoryEvidence: mem.evidence,
+        weight: finalWeight,
+        confidence: adjusted.confidence || "low",
+      };
+    })
+    .sort((a, b) => {
+      const w = Number(b.weight || 0) - Number(a.weight || 0);
+      if (w !== 0) return w;
+      return confidenceRank(b.confidence) - confidenceRank(a.confidence);
+    });
+
+  const displayed = [];
+  const suppressed = [];
+  const groupCounts = {};
+
+  ranked.forEach((r) => {
+    const group = r.saturationGroup || "general";
+    groupCounts[group] = groupCounts[group] || 0;
+
+    const lowConfidenceOverload = r.confidence === "low" && displayed.length >= 5;
+    const groupSaturated = groupCounts[group] >= 3;
+
+    if (lowConfidenceOverload || groupSaturated) {
+      suppressed.push({
+        recommendationId: r.recommendationId,
+        reason: lowConfidenceOverload ? "low-confidence-cap" : "saturation-cap",
+        weight: r.weight,
+      });
+      return;
+    }
+
+    displayed.push(r);
+    groupCounts[group] += 1;
+  });
+
+  const next = displayed[0] || ranked[0] || null;
+  const nextBestAction = next ? next.text : "Run /cco-optimize for focused next steps.";
+
+  const reason = `profile=${profileName};displayed=${displayed.length};suppressed=${suppressed.length};slice=s1`;
+
+  return {
+    nextBestAction,
+    displayedRecommendations: displayed,
+    suppressedRecommendations: suppressed,
+    reason,
+  };
+}
+
+module.exports = {
+  applyRecommendationDecision,
+  saturationGroup,
+};

package/scripts/lib/orchestration/adapters/_shared.js

@@ -0,0 +1,49 @@
+"use strict";
+
+function buildHandoffResult(adapter, step, taskContext, options = {}) {
+  return {
+    status: "handoff_required",
+    executionMode: adapter.executionMode || "handoff",
+    toolId: adapter.toolId,
+    stepId: step.id,
+    touchedFiles: [],
+    summary: adapter.summarize(step, taskContext, options),
+    handoffInstruction: adapter.buildHandoff(step, taskContext, options),
+  };
+}
+
+function baseAdapter(definition) {
+  return {
+    ...definition,
+    detect() {
+      return true;
+    },
+    listProfiles(inventoryItem) {
+      return inventoryItem?.candidateProfiles || [];
+    },
+    canHandle(step, taskContext, inventoryItem) {
+      return (inventoryItem?.toolId || definition.toolId) === definition.toolId
+        && Array.isArray(inventoryItem?.supportedRoles)
+        && inventoryItem.supportedRoles.includes(step.role);
+    },
+    estimateSuitability(step, taskContext, inventoryItem) {
+      return this.canHandle(step, taskContext, inventoryItem) ? 0.8 : 0;
+    },
+    collectResult(result) {
+      return result;
+    },
+    detectFailure(result) {
+      return !result || result.status === "failed";
+    },
+    redact(text) {
+      return String(text || "")
+        .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]");
+    },
+  };
+}
+
+module.exports = {
+  baseAdapter,
+  buildHandoffResult,
+};

package/scripts/lib/orchestration/adapters/aider.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "aider",
+  label: "Aider",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return `Aider handoff\nStage: ${step.role}\nTask: ${taskContext.taskText}`;
+  },
+  summarize(step) {
+    return `Prepared Aider ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/claude-code.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "claude_code",
+  label: "Claude Code",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return [
+      "Claude Code handoff",
+      `Stage: ${step.role}`,
+      `Task: ${taskContext.taskText}`,
+      `Risk: ${taskContext.classification.risk}`,
+      "Use the current workspace, follow the current-route.md guidance, and preserve proof before completion.",
+    ].join("\n");
+  },
+  summarize(step) {
+    return `Prepared Claude Code ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    if (taskContext.surface === "claude_code") {
+      return {
+        status: "delegated_to_current_surface",
+        executionMode: "in_session",
+        toolId: "claude_code",
+        stepId: step.id,
+        touchedFiles: [],
+        summary: "Current Claude Code session can continue on the selected route.",
+        handoffInstruction: this.buildHandoff(step, taskContext, options),
+      };
+    }
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/codex.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "codex",
+  label: "Codex",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return [
+      "Codex handoff",
+      `Stage: ${step.role}`,
+      `Task: ${taskContext.taskText}`,
+      `Risk: ${taskContext.classification.risk}`,
+      "Use the Avorelo current-task/current-route files and keep verification deterministic.",
+    ].join("\n");
+  },
+  summarize(step) {
+    return `Prepared Codex ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    if (taskContext.surface === "codex_cli") {
+      return {
+        status: "delegated_to_current_surface",
+        executionMode: "in_session",
+        toolId: "codex",
+        stepId: step.id,
+        touchedFiles: [],
+        summary: "Current Codex session can continue on the selected route.",
+        handoffInstruction: this.buildHandoff(step, taskContext, options),
+      };
+    }
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/gemini-cli.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "gemini_cli",
+  label: "Gemini CLI",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return `Gemini CLI handoff\nStage: ${step.role}\nTask: ${taskContext.taskText}`;
+  },
+  summarize(step) {
+    return `Prepared Gemini CLI ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/git.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const { baseAdapter } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "git",
+  label: "Git",
+  executionMode: "direct",
+  buildHandoff() {
+    return null;
+  },
+  summarize(step) {
+    return `Git supports deterministic ${step.role}.`;
+  },
+  execute(step) {
+    return {
+      status: "completed",
+      executionMode: "direct",
+      toolId: "git",
+      stepId: step.id,
+      touchedFiles: [],
+      summary: `Reserved ${step.role} for deterministic git-backed checks.`,
+    };
+  },
+});

package/scripts/lib/orchestration/adapters/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const claudeCode = require("./claude-code");
+const codex = require("./codex");
+const geminiCli = require("./gemini-cli");
+const lmStudio = require("./lm-studio");
+const opencode = require("./opencode");
+const aider = require("./aider");
+const ollama = require("./ollama");
+const openrouter = require("./openrouter");
+const testRunner = require("./test-runner");
+const git = require("./git");
+
+function createAdapterRegistry() {
+  return {
+    claude_code: claudeCode,
+    codex,
+    gemini_cli: geminiCli,
+    lm_studio: lmStudio,
+    opencode,
+    aider,
+    ollama,
+    openrouter_api: openrouter,
+    test_runner: testRunner,
+    git,
+  };
+}
+
+module.exports = {
+  createAdapterRegistry,
+};

package/scripts/lib/orchestration/adapters/lm-studio.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "lm_studio",
+  label: "LM Studio",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return `LM Studio handoff\nStage: ${step.role}\nTask: ${taskContext.taskText}`;
+  },
+  summarize(step) {
+    return `Prepared LM Studio ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/ollama.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "ollama",
+  label: "Ollama",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return `Ollama handoff\nStage: ${step.role}\nTask: ${taskContext.taskText}`;
+  },
+  summarize(step) {
+    return `Prepared Ollama ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/opencode.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "opencode",
+  label: "OpenCode",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return `OpenCode handoff\nStage: ${step.role}\nTask: ${taskContext.taskText}`;
+  },
+  summarize(step) {
+    return `Prepared OpenCode ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/openrouter.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { baseAdapter, buildHandoffResult } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "openrouter_api",
+  label: "OpenRouter",
+  executionMode: "handoff",
+  buildHandoff(step, taskContext) {
+    return `OpenRouter handoff\nStage: ${step.role}\nTask: ${taskContext.taskText}`;
+  },
+  summarize(step) {
+    return `Prepared OpenRouter ${step.role} handoff.`;
+  },
+  execute(step, taskContext, options) {
+    return buildHandoffResult(this, step, taskContext, options);
+  },
+});

package/scripts/lib/orchestration/adapters/test-runner.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const { baseAdapter } = require("./_shared");
+
+module.exports = baseAdapter({
+  toolId: "test_runner",
+  label: "Local test runner",
+  executionMode: "direct",
+  buildHandoff() {
+    return null;
+  },
+  summarize(step) {
+    return `Verification is handled through the local ${step.role} surface.`;
+  },
+  execute(step) {
+    return {
+      status: "completed",
+      executionMode: "direct",
+      toolId: "test_runner",
+      stepId: step.id,
+      touchedFiles: [],
+      summary: `Reserved ${step.role} for deterministic verification.`,
+    };
+  },
+});