avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/agent-evolution-loop.js

@@ -0,0 +1,479 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const { ensureCcoDirs, nowIso, safeReadJson, safeWriteJson } = require("./fsx");
+const {
+  appendProductLearningEvent,
+  redactPayload,
+  redactString,
+  sha256,
+} = require("./product-learning-events");
+
+const AGENT_EVOLUTION_DIR_REL_PATH = ".claude/cco/intel/agent-evolution";
+const CAPABILITY_REQUESTS_REL_PATH = `${AGENT_EVOLUTION_DIR_REL_PATH}/capability-requests.json`;
+const EVOLUTION_REPORT_REL_PATH = `${AGENT_EVOLUTION_DIR_REL_PATH}/evolution-report.json`;
+const QUARANTINE_DECISIONS_REL_PATH = `${AGENT_EVOLUTION_DIR_REL_PATH}/quarantine-decisions.json`;
+
+const DEFAULT_REPEAT_THRESHOLD = 2;
+const SIGNAL_KINDS = new Set(["missing_capability", "no_connect"]);
+const DECISIONS = new Set(["created", "no_action", "skipped", "no_connect"]);
+const HIGH_RISK_PERMISSIONS = new Set([
+  "browser",
+  "credential_access",
+  "exec",
+  "filesystem_write",
+  "install",
+  "network",
+  "secrets",
+  "shell",
+]);
+
+function ensureAgentEvolutionDirs(cwd) {
+  ensureCcoDirs(cwd);
+  fs.mkdirSync(path.join(cwd, AGENT_EVOLUTION_DIR_REL_PATH), { recursive: true });
+}
+
+function normalizeIdentifier(value) {
+  const text = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  return text.length >= 2 ? text : null;
+}
+
+function normalizeReasonCodes(value) {
+  if (!Array.isArray(value)) return [];
+  return Array.from(
+    new Set(
+      value
+        .map((item) => normalizeIdentifier(item))
+        .filter(Boolean)
+    )
+  ).slice(0, 8);
+}
+
+function normalizePermissions(value) {
+  if (!Array.isArray(value)) return [];
+  return Array.from(
+    new Set(
+      value
+        .map((item) => normalizeIdentifier(item))
+        .filter(Boolean)
+    )
+  );
+}
+
+function normalizeKind(value) {
+  const kind = normalizeIdentifier(value);
+  if (kind === "missing_capability" || kind === "capability_missing" || kind === "missing") {
+    return "missing_capability";
+  }
+  if (kind === "no_connect" || kind === "connectivity_gap" || kind === "offline_only") {
+    return "no_connect";
+  }
+  return null;
+}
+
+function summarizeText(value) {
+  const text = redactString(String(value || "").trim()).replace(/\s+/g, " ");
+  return text ? text.slice(0, 240) : null;
+}
+
+function classifyPermissionRisk(signal) {
+  const explicit = normalizeIdentifier(signal.permissionRisk || signal.riskLevel);
+  if (explicit === "critical" || explicit === "high") return "high";
+  const requestedPermissions = normalizePermissions(signal.requestedPermissions);
+  return requestedPermissions.some((permission) => HIGH_RISK_PERMISSIONS.has(permission)) ? "high" : "low";
+}
+
+function summarizeSignalForStorage(signal) {
+  return redactPayload({
+    occurredAt: signal.occurredAt || null,
+    kind: signal.kind || null,
+    capabilityId: signal.capabilityId || null,
+    summary: signal.summary || null,
+    reasonCodes: signal.reasonCodes || [],
+    surface: signal.surface || null,
+    permissionRisk: signal.permissionRisk || "low",
+    requestedPermissions: signal.requestedPermissions || [],
+    proposalMode: signal.proposalMode || null,
+    verificationProofPresent: Boolean(signal.verificationProofPresent),
+    valueClaimPresent: Boolean(signal.valueClaimPresent),
+  });
+}
+
+function normalizeSignal(signal, index) {
+  if (!signal || typeof signal !== "object" || Array.isArray(signal)) {
+    return {
+      valid: false,
+      reasonCode: "signal_not_object",
+      index,
+    };
+  }
+
+  const capabilityId = normalizeIdentifier(
+    signal.capabilityId ||
+      signal.missingCapabilityId ||
+      signal.requestedCapabilityId ||
+      signal.suggestedCapability?.id ||
+      signal.generatedCapability?.id
+  );
+  const reasonCodes = normalizeReasonCodes(signal.reasonCodes);
+  const summary = summarizeText(signal.summary || signal.reason || signal.note);
+  const kind = normalizeKind(signal.kind || signal.outcome || signal.decision);
+  const proposalMode = signal.generatedCapability ? "generated" : signal.suggestedCapability ? "suggested" : "observed";
+  const permissionRisk = classifyPermissionRisk(signal);
+  const requestedPermissions = normalizePermissions(signal.requestedPermissions);
+  const contributorKey = signal.userId || signal.actorId || signal.agentId || signal.author;
+  const sessionKey = signal.sessionId || signal.runId || signal.traceId;
+  const surface = normalizeIdentifier(signal.surface || signal.source || "local") || "local";
+  const evidenceScore = [capabilityId, kind, summary || reasonCodes.length > 0].filter(Boolean).length;
+
+  if (!kind || !SIGNAL_KINDS.has(kind)) {
+    return {
+      valid: false,
+      reasonCode: "unknown_signal_kind",
+      index,
+    };
+  }
+
+  return {
+    valid: true,
+    occurredAt: signal.occurredAt || nowIso(),
+    capabilityId,
+    kind,
+    summary,
+    reasonCodes,
+    proposalMode,
+    permissionRisk,
+    requestedPermissions,
+    surface,
+    verificationProofPresent: Boolean(signal.verificationProof?.verified || signal.verification?.verified || signal.proofRef),
+    valueClaimPresent: Boolean(signal.valueClaim || signal.valueSummary),
+    sufficientEvidence:
+      kind === "missing_capability" && Boolean(capabilityId) && evidenceScore >= 3,
+    contributorHash: contributorKey ? sha256(String(contributorKey)).slice(0, 12) : null,
+    sessionHash: sessionKey ? sha256(String(sessionKey)).slice(0, 12) : null,
+    storageSummary: summarizeSignalForStorage({
+      occurredAt: signal.occurredAt || null,
+      kind,
+      capabilityId,
+      summary,
+      reasonCodes,
+      surface,
+      permissionRisk,
+      requestedPermissions,
+      proposalMode,
+      verificationProofPresent: Boolean(signal.verificationProof?.verified || signal.verification?.verified || signal.proofRef),
+      valueClaimPresent: Boolean(signal.valueClaim || signal.valueSummary),
+    }),
+  };
+}
+
+function chooseWinningCapability(groups) {
+  return Array.from(groups.values()).sort((left, right) => {
+    if (right.signals.length !== left.signals.length) return right.signals.length - left.signals.length;
+    if (right.uniqueSessions !== left.uniqueSessions) return right.uniqueSessions - left.uniqueSessions;
+    return left.capabilityId.localeCompare(right.capabilityId);
+  })[0] || null;
+}
+
+function buildRequestId(capabilityId, signals) {
+  const seed = `${capabilityId}:${signals.length}:${signals.map((item) => item.occurredAt).join("|")}`;
+  return `agent-evolution-${capabilityId}-${sha256(seed).slice(0, 10)}`;
+}
+
+function aggregateTeamRollup(signals) {
+  return {
+    aggregateOnly: true,
+    totalSignals: signals.length,
+    uniqueSessions: new Set(signals.map((signal) => signal.sessionHash).filter(Boolean)).size,
+    uniqueContributors: new Set(signals.map((signal) => signal.contributorHash).filter(Boolean)).size,
+    individualRankingAvailable: false,
+  };
+}
+
+function loadArrayArtifact(cwd, relPath) {
+  const value = safeReadJson(cwd, relPath, []);
+  return Array.isArray(value) ? value : [];
+}
+
+function evaluateAgentEvolutionLoop(input = {}) {
+  const threshold = Number.isInteger(input.repeatThreshold) && input.repeatThreshold > 1
+    ? input.repeatThreshold
+    : DEFAULT_REPEAT_THRESHOLD;
+  const rawSignals = Array.isArray(input.signals) ? input.signals : null;
+
+  if (!rawSignals) {
+    return {
+      ok: false,
+      decision: "skipped",
+      reasonCodes: ["malformed_input"],
+      request: null,
+      report: {
+        status: "skipped",
+        reasonCodes: ["malformed_input"],
+        repeatThreshold: threshold,
+      },
+    };
+  }
+
+  const normalizedSignals = rawSignals.map((signal, index) => normalizeSignal(signal, index));
+  const validSignals = normalizedSignals.filter((signal) => signal.valid);
+  const malformedSignals = normalizedSignals.filter((signal) => !signal.valid);
+  const groupedSignals = new Map();
+
+  for (const signal of validSignals.filter((item) => item.kind === "missing_capability" && item.sufficientEvidence)) {
+    if (!groupedSignals.has(signal.capabilityId)) {
+      groupedSignals.set(signal.capabilityId, {
+        capabilityId: signal.capabilityId,
+        signals: [],
+        reasonCodes: new Set(),
+        uniqueSurfaces: new Set(),
+        sessionHashes: new Set(),
+        contributorHashes: new Set(),
+        highestPermissionRisk: "low",
+      });
+    }
+    const group = groupedSignals.get(signal.capabilityId);
+    group.signals.push(signal);
+    signal.reasonCodes.forEach((code) => group.reasonCodes.add(code));
+    group.uniqueSurfaces.add(signal.surface);
+    if (signal.sessionHash) group.sessionHashes.add(signal.sessionHash);
+    if (signal.contributorHash) group.contributorHashes.add(signal.contributorHash);
+    if (signal.permissionRisk === "high") group.highestPermissionRisk = "high";
+  }
+
+  groupedSignals.forEach((group) => {
+    group.uniqueSessions = group.sessionHashes.size;
+    group.uniqueContributors = group.contributorHashes.size;
+  });
+
+  const winningGroup = chooseWinningCapability(groupedSignals);
+  const reportBase = {
+    schemaVersion: 1,
+    contract: "avorelo.agentEvolutionReport.v1",
+    status: "evaluated",
+    decision: "skipped",
+    repeatThreshold: threshold,
+    totalSignalsReceived: rawSignals.length,
+    validSignals: validSignals.length,
+    malformedSignals: malformedSignals.length,
+    candidateCapabilities: Array.from(groupedSignals.values())
+      .map((group) => ({
+        capabilityId: group.capabilityId,
+        repeatedSignals: group.signals.length,
+        uniqueSurfaces: group.uniqueSurfaces.size,
+      }))
+      .sort((left, right) => right.repeatedSignals - left.repeatedSignals || left.capabilityId.localeCompare(right.capabilityId)),
+    teamRollup: aggregateTeamRollup(validSignals),
+  };
+
+  if (validSignals.length === 0) {
+    return {
+      ok: false,
+      decision: "skipped",
+      reasonCodes: ["malformed_input"],
+      request: null,
+      report: {
+        ...reportBase,
+        status: "skipped",
+        decision: "skipped",
+        reasonCodes: ["malformed_input"],
+      },
+    };
+  }
+
+  if (!winningGroup) {
+    const noConnect = validSignals.some((signal) => signal.kind === "no_connect");
+    return {
+      ok: true,
+      decision: noConnect ? "no_connect" : "skipped",
+      reasonCodes: [noConnect ? "no_connect" : "insufficient_evidence"],
+      request: null,
+      report: {
+        ...reportBase,
+        status: noConnect ? "no_connect" : "skipped",
+        decision: noConnect ? "no_connect" : "skipped",
+        reasonCodes: [noConnect ? "no_connect" : "insufficient_evidence"],
+      },
+    };
+  }
+
+  if (winningGroup.signals.length < threshold) {
+    return {
+      ok: true,
+      decision: "no_action",
+      reasonCodes: ["repeat_threshold_not_met"],
+      request: null,
+      report: {
+        ...reportBase,
+        status: "observed",
+        decision: "no_action",
+        reasonCodes: ["repeat_threshold_not_met"],
+        topCapabilityId: winningGroup.capabilityId,
+      },
+    };
+  }
+
+  const request = {
+    schemaVersion: 1,
+    contract: "avorelo.agentEvolutionRequest.v1",
+    requestId: buildRequestId(winningGroup.capabilityId, winningGroup.signals),
+    createdAt: input.now || nowIso(),
+    capabilityId: winningGroup.capabilityId,
+    title: `Governed capability request: ${winningGroup.capabilityId}`,
+    status: "manual_review",
+    quarantineState: "quarantine",
+    autoActivationAllowed: false,
+    activationProofStatus: "proof_required",
+    valueClaimStatus: "verification_proof_required",
+    approvalDecision: winningGroup.highestPermissionRisk === "high" ? "approval_required" : "not_required",
+    proposalMode: winningGroup.signals.some((signal) => signal.proposalMode === "generated") ? "generated" : "suggested",
+    repeatedSignals: winningGroup.signals.length,
+    reasonCodes: Array.from(winningGroup.reasonCodes).sort(),
+    evidence: {
+      aggregateOnly: true,
+      uniqueSurfaces: winningGroup.uniqueSurfaces.size,
+      uniqueSessions: winningGroup.uniqueSessions,
+      uniqueContributors: winningGroup.uniqueContributors,
+      individualRankingAvailable: false,
+      sampledSignals: winningGroup.signals.slice(0, 3).map((signal) => signal.storageSummary),
+    },
+    constraints: {
+      noActivationWithoutProof: true,
+      noValueClaimWithoutVerificationProof: true,
+      highRiskPermissionsRequireApproval: true,
+    },
+    safeNextAction:
+      winningGroup.highestPermissionRisk === "high"
+        ? "Review the quarantined request, scope permissions to the minimum needed, and attach proof requirements before any approval."
+        : "Review the quarantined request and define verification proof before any activation.",
+  };
+
+  return {
+    ok: true,
+    decision: "created",
+    reasonCodes: ["repeat_threshold_met"],
+    request,
+    report: {
+      ...reportBase,
+      status: "created",
+      decision: "created",
+      reasonCodes: ["repeat_threshold_met"],
+      topCapabilityId: winningGroup.capabilityId,
+      requestId: request.requestId,
+    },
+  };
+}
+
+function readCapabilityRequests(cwd) {
+  return loadArrayArtifact(cwd, CAPABILITY_REQUESTS_REL_PATH);
+}
+
+function readEvolutionReport(cwd) {
+  return safeReadJson(cwd, EVOLUTION_REPORT_REL_PATH, null);
+}
+
+function readQuarantineDecisions(cwd) {
+  return loadArrayArtifact(cwd, QUARANTINE_DECISIONS_REL_PATH);
+}
+
+function appendUniqueRequest(existingRequests, request) {
+  if (existingRequests.some((item) => item && item.requestId === request.requestId)) {
+    return existingRequests.slice();
+  }
+  return [...existingRequests, request];
+}
+
+function runAgentEvolutionLoop(cwd, input = {}) {
+  ensureAgentEvolutionDirs(cwd);
+  const evaluated = evaluateAgentEvolutionLoop(input);
+  const existingRequests = readCapabilityRequests(cwd);
+  const existingQuarantineDecisions = readQuarantineDecisions(cwd);
+  let requests = existingRequests.slice();
+  let quarantineDecisions = existingQuarantineDecisions.slice();
+
+  if (evaluated.decision === "created" && evaluated.request) {
+    requests = appendUniqueRequest(existingRequests, evaluated.request);
+    quarantineDecisions = [
+      ...existingQuarantineDecisions,
+      {
+        requestId: evaluated.request.requestId,
+        capabilityId: evaluated.request.capabilityId,
+        state: "quarantine",
+        status: "manual_review",
+        approvalDecision: evaluated.request.approvalDecision,
+        createdAt: evaluated.request.createdAt,
+      },
+    ];
+    appendProductLearningEvent(cwd, {
+      eventName: "agent_evolution_request_created",
+      category: "product_learning",
+      payload: {
+        capabilityId: evaluated.request.capabilityId,
+        requestId: evaluated.request.requestId,
+        repeatedSignals: evaluated.request.repeatedSignals,
+        approvalDecision: evaluated.request.approvalDecision,
+      },
+    });
+    appendProductLearningEvent(cwd, {
+      eventName: "agent_evolution_quarantined",
+      category: "product_learning",
+      payload: {
+        capabilityId: evaluated.request.capabilityId,
+        requestId: evaluated.request.requestId,
+        state: evaluated.request.quarantineState,
+        status: evaluated.request.status,
+      },
+    });
+  } else {
+    appendProductLearningEvent(cwd, {
+      eventName: "agent_evolution_request_skipped",
+      category: "product_learning",
+      payload: {
+        decision: evaluated.decision,
+        reasonCodes: evaluated.reasonCodes,
+      },
+    });
+  }
+
+  const report = {
+    ...evaluated.report,
+    updatedAt: input.now || nowIso(),
+    openRequests: requests.length,
+    lastRequestId: requests.length ? requests[requests.length - 1].requestId : null,
+    fullDashboardVerification: "blocked_preexisting_timeout_on_clean_origin_main",
+  };
+
+  safeWriteJson(cwd, CAPABILITY_REQUESTS_REL_PATH, requests);
+  safeWriteJson(cwd, QUARANTINE_DECISIONS_REL_PATH, quarantineDecisions);
+  safeWriteJson(cwd, EVOLUTION_REPORT_REL_PATH, report);
+
+  return {
+    ...evaluated,
+    request: evaluated.request,
+    report,
+    artifacts: {
+      capabilityRequestsPath: CAPABILITY_REQUESTS_REL_PATH,
+      evolutionReportPath: EVOLUTION_REPORT_REL_PATH,
+      quarantineDecisionsPath: QUARANTINE_DECISIONS_REL_PATH,
+    },
+  };
+}
+
+module.exports = {
+  AGENT_EVOLUTION_DIR_REL_PATH,
+  CAPABILITY_REQUESTS_REL_PATH,
+  EVOLUTION_REPORT_REL_PATH,
+  QUARANTINE_DECISIONS_REL_PATH,
+  DEFAULT_REPEAT_THRESHOLD,
+  evaluateAgentEvolutionLoop,
+  runAgentEvolutionLoop,
+  readCapabilityRequests,
+  readEvolutionReport,
+  readQuarantineDecisions,
+};

package/scripts/lib/agent-policy-profile.js

@@ -0,0 +1,210 @@
+"use strict";
+
+const { getCurrentPlan } = require("./entitlements");
+
+const POLICY_MODES = Object.freeze(["visibility", "warn", "approve", "enforce"]);
+
+function unique(values) {
+  return [...new Set((values || []).filter(Boolean))];
+}
+
+function toIso(value) {
+  return value instanceof Date ? value.toISOString() : new Date(value || Date.now()).toISOString();
+}
+
+function normalizeMode(value, fallback) {
+  return POLICY_MODES.includes(value) ? value : fallback;
+}
+
+function normalizePlan(value) {
+  return String(value || "free").trim().toLowerCase() === "pro" ? "pro" : "free";
+}
+
+function buildBaseProfile(plan, now) {
+  const createdAt = toIso(now);
+
+  if (plan === "pro") {
+    return {
+      profileId: "avorelo-pro-least-privilege",
+      plan,
+      mode: "approve",
+      allowedActionTypes: [
+        "prompt_compile",
+        "file_read",
+        "visual_qa_run",
+        "browser_action",
+        "tool_call",
+        "mcp_tool_call",
+        "command_run",
+        "git_operation",
+      ],
+      deniedActionTypes: [
+        "secret_access",
+      ],
+      allowedPaths: [
+        ".",
+        "src/",
+        "tests/",
+        "docs/",
+        "deferred/site-implementation/",
+        "src/landing-page/",
+      ],
+      deniedPaths: [
+        ".env",
+        ".env.*",
+        ".ssh/",
+        ".github/workflows/",
+        "secrets/",
+        "credentials/",
+      ],
+      allowedDomains: [
+        "localhost",
+        "127.0.0.1",
+        "::1",
+      ],
+      deniedDomains: [
+        "*.internal",
+      ],
+      allowedTools: [
+        "prompt_compiler",
+        "visual_qa",
+        "refactor_boundary",
+        "browser_governance",
+        "security_protection",
+        "context_cost_optimizer",
+        "evidence_report",
+      ],
+      deniedTools: [],
+      approvalRequiredFor: [
+        "sensitive_file_write",
+        "external_browser_domain",
+        "write_capable_tool",
+        "write_capable_mcp",
+        "deploy_operation",
+        "external_export",
+        "unknown_tool",
+      ],
+      ttlSeconds: 1800,
+      evidenceRequired: true,
+      sourceTrustRequired: true,
+      zeroStandingPermissions: true,
+      scopedJitStyleAccess: true,
+      enforcementAvailable: "where_supported",
+      createdAt,
+    };
+  }
+
+  return {
+    profileId: "avorelo-free-visibility-warn",
+    plan,
+    mode: "warn",
+    allowedActionTypes: [
+      "prompt_compile",
+      "file_read",
+      "visual_qa_run",
+      "browser_action",
+      "tool_call",
+      "mcp_tool_call",
+      "command_run",
+    ],
+    deniedActionTypes: [
+      "secret_access",
+    ],
+    allowedPaths: [
+      ".",
+      "src/",
+      "tests/",
+      "docs/",
+      "deferred/site-implementation/",
+      "src/landing-page/",
+    ],
+    deniedPaths: [
+      ".env",
+      ".env.*",
+      ".ssh/",
+      "secrets/",
+      "credentials/",
+    ],
+    allowedDomains: [
+      "localhost",
+      "127.0.0.1",
+      "::1",
+    ],
+    deniedDomains: [
+      "*.internal",
+    ],
+    allowedTools: [
+      "prompt_compiler",
+      "visual_qa",
+      "security_protection",
+      "evidence_report",
+    ],
+    deniedTools: [],
+    approvalRequiredFor: [
+      "sensitive_file_write",
+      "external_browser_domain",
+      "write_capable_tool",
+      "write_capable_mcp",
+      "deploy_operation",
+      "external_export",
+      "unknown_tool",
+    ],
+    ttlSeconds: 900,
+    evidenceRequired: true,
+    sourceTrustRequired: false,
+    zeroStandingPermissions: true,
+    scopedJitStyleAccess: false,
+    enforcementAvailable: "visibility_and_warning",
+    createdAt,
+  };
+}
+
+function buildPolicyProfile(options = {}) {
+  const cwd = options.cwd;
+  const plan = normalizePlan(options.plan || getCurrentPlan({ cwd }));
+  const now = options.now || new Date();
+  const base = buildBaseProfile(plan, now);
+  const overrides = options.overrides && typeof options.overrides === "object" ? options.overrides : {};
+
+  return {
+    ...base,
+    ...overrides,
+    plan,
+    mode: normalizeMode(overrides.mode, base.mode),
+    allowedActionTypes: unique(overrides.allowedActionTypes || base.allowedActionTypes),
+    deniedActionTypes: unique(overrides.deniedActionTypes || base.deniedActionTypes),
+    allowedPaths: unique(overrides.allowedPaths || base.allowedPaths),
+    deniedPaths: unique(overrides.deniedPaths || base.deniedPaths),
+    allowedDomains: unique(overrides.allowedDomains || base.allowedDomains),
+    deniedDomains: unique(overrides.deniedDomains || base.deniedDomains),
+    allowedTools: unique(overrides.allowedTools || base.allowedTools),
+    deniedTools: unique(overrides.deniedTools || base.deniedTools),
+    approvalRequiredFor: unique(overrides.approvalRequiredFor || base.approvalRequiredFor),
+    createdAt: toIso(overrides.createdAt || base.createdAt),
+  };
+}
+
+function describePolicyProfile(profile) {
+  const mode = normalizeMode(profile?.mode, "warn");
+  const plan = normalizePlan(profile?.plan);
+
+  if (plan === "pro") {
+    return {
+      headline: "Advanced least-privilege protection",
+      summary: mode === "enforce"
+        ? "Pro can enforce blocks for clearly unsafe actions and require approval where supported."
+        : "Pro narrows risky actions, requires approval for sensitive work, and keeps deeper local evidence where supported.",
+    };
+  }
+
+  return {
+    headline: "Basic safer-by-default visibility",
+    summary: "Free surfaces risky skills, instructions, tools, browser capability, and the latest local evidence without making the workflow heavy.",
+  };
+}
+
+module.exports = {
+  POLICY_MODES,
+  buildPolicyProfile,
+  describePolicyProfile,
+};