@evo-dev/core 0.0.1-alpha → 0.0.1-alpha.10

package/dist/plugins/index.js

@@ -9,37 +9,28 @@ function createUnknownNegotiatedCapabilities(pluginId) {
     hooks: "unsupported",
     canPlanWrites: false,
     warnings: [],
-    blockers: [`Plugin ${pluginId} capabilities are unknown and unsupported.`]
+    advisories: [`Plugin ${pluginId} capabilities are unknown and unsupported.`]
   };
 }
 function isCapabilityUsable(state) {
   return state === "enabled";
 }
-function assertNoUnverifiedWrites(negotiation) {
-  if (!negotiation.canPlanWrites) {
-    throw new Error(`Plugin ${negotiation.pluginId} has no verified enabled write capabilities.`);
-  }
-}
 function negotiatePluginCapabilities(input) {
   if (input.pluginId === "codex") {
-    const declaredSupport = [
-      input.declared.skills.supported ? "skills" : null,
-      input.declared.agents.supported ? "agents" : null,
-      input.declared.hooks.supported ? "hooks" : null
-    ].filter(Boolean);
-    const blockers = ["Codex capabilities are unverified; writes are unsupported in I10."];
+    const advisories = [];
     const warnings = [
-      input.verified ? "Codex readonly verification artifact exists; sync remains no-write until formats are verified." : null,
-      declaredSupport.length > 0 ? `Codex declares ${declaredSupport.join(", ")} support, but declared support alone cannot authorize writes.` : null
+      input.verified ? "Codex metadata-only verification artifact exists; implemented Codex skill/agent distribution remains governed by adapter tests." : null,
+      input.declared.skills.supported ? "Codex skills are distributed through the EvoDev Codex plugin bundle, not direct user-directory skill sync." : null,
+      input.declared.agents.supported ? "Codex agents can sync to user-level TOML files with no-overwrite semantics." : null
     ].filter((warning) => warning !== null);
     return {
       pluginId: input.pluginId,
-      skills: input.declared.skills.supported ? "unverified" : "unsupported",
-      agents: input.declared.agents.supported ? "unverified" : "unsupported",
-      hooks: input.declared.hooks.supported ? "unverified" : "unsupported",
-      canPlanWrites: false,
+      skills: resolveNonCodexCapabilityState(input.declared.skills.supported, input.enabled),
+      agents: resolveNonCodexCapabilityState(input.declared.agents.supported, input.enabled),
+      hooks: resolveNonCodexCapabilityState(input.declared.hooks.supported, input.enabled),
+      canPlanWrites: input.enabled && input.declared.agents.supported,
       warnings,
-      blockers
+      advisories
     };
   }
   return {
@@ -49,9 +40,9 @@ function negotiatePluginCapabilities(input) {
     hooks: resolveNonCodexCapabilityState(input.declared.hooks.supported, input.enabled),
     canPlanWrites: input.enabled && input.declared.skills.supported && input.declared.agents.supported,
     warnings: input.enabled ? [] : [
-      `Plugin ${input.pluginId} has declared capabilities but is not enabled; writes are not authorized.`
+      `Plugin ${input.pluginId} has declared capabilities but is not enabled for write planning.`
     ],
-    blockers: []
+    advisories: []
   };
 }
 function resolveNonCodexCapabilityState(supported, enabled) {
@@ -63,7 +54,9 @@ async function createCodexCapabilityVerificationArtifact(input) {
   const timestamp = input.createdAt ?? new Date().toISOString();
   const detectionMessage = sanitizeText(input.detection.message);
   const diagnostics = [
-    "Codex remains no-write until concrete user-level paths and formats are verified."
+    "Codex skills are packaged in the EvoDev Codex plugin payload.",
+    "Codex agents sync to user-level TOML files under ~/.codex/agents.",
+    "Codex hooks are supplied by the EvoDev Codex plugin manifest and enabled through Codex plugin hooks."
   ];
   return {
     version: 1,
@@ -80,7 +73,11 @@ async function createCodexCapabilityVerificationArtifact(input) {
     externalUpload: false,
     networkUsed: false,
     toolSummary: { tool: "codex", detectionStatus: input.detection.status, version: null },
-    capabilities: { skills: "unverified", agents: "unverified", hooks: "unverified" },
+    capabilities: {
+      skills: "plugin-bundled",
+      agents: "user-level-toml-sync",
+      hooks: "plugin-manifest-hooks"
+    },
     writeBoundary: {
       writesAllowed: false,
       allowedPaths: [],
@@ -98,7 +95,7 @@ async function createCodexCapabilityVerificationArtifact(input) {
       secretsStored: false,
       externalUpload: false
     },
-    blockers: ["Codex asset capabilities are unverified and unsupported for writes in I10."],
+    advisories: [],
     diagnostics,
     evidenceRefs: [],
     evidence: {
@@ -106,7 +103,8 @@ async function createCodexCapabilityVerificationArtifact(input) {
       detectionMessage,
       writesAllowed: false,
       notes: [
-        "Metadata-only readonly artifact; no Codex paths, formats, hooks, or writes verified."
+        "Metadata-only verification artifact; it does not probe or write Code Agent directories.",
+        "Implemented Codex asset distribution is covered by adapter tests: plugin-bundled skills and user-level TOML agents."
       ]
     }
   };
@@ -149,12 +147,12 @@ function formatCodexCapabilityVerificationArtifact(artifact, path) {
     `Status: ${artifact.status}`,
     `Artifact: ${path ?? "dry-run only"}`,
     `Verified at: ${artifact.verifiedAt}`,
-    "Capabilities: skills=unverified agents=unverified hooks=unverified",
-    "Writes allowed: false",
+    `Capabilities: skills=${artifact.capabilities.skills} agents=${artifact.capabilities.agents} hooks=${artifact.capabilities.hooks}`,
+    "Verification writes allowed: false",
     "Allowed paths: none",
-    "User-level write paths verified: false",
+    "User-level agent sync path: ~/.codex/agents",
     "Project writes allowed: false",
-    "No-overwrite verified: false",
+    "No-overwrite policy: skip existing files unless force refresh is requested",
     `External upload: ${artifact.externalUpload}`,
     `Detection: ${artifact.evidence.detectionStatus}`,
     ...artifact.evidence.notes.map((note) => `Note: ${note}`)
@@ -171,8 +169,11 @@ async function runPluginConformance(plugin) {
   }
   if (plugin.id === "codex") {
     const capabilities = await plugin.getCapabilities();
-    if (capabilities.skills.supported || capabilities.agents.supported || capabilities.hooks.supported) {
-      findings.push("Codex must not declare verified runtime support in I10.");
+    if (!capabilities.skills.supported || !capabilities.agents.supported) {
+      findings.push("Codex must declare plugin-bundled skills and user-level TOML agents.");
+    }
+    if (!capabilities.hooks.supported || capabilities.hooks.events.length === 0) {
+      findings.push("Codex must declare plugin-manifest hook support.");
     }
   }
   return { ok: findings.length === 0, findings };
@@ -259,7 +260,6 @@ export {
   createUnknownNegotiatedCapabilities,
   createPluginRegistry,
   createCodexCapabilityVerificationArtifact,
-  assertNoUnverifiedWrites,
   PluginRegistryError,
   PluginRegistry
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-dev/core",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.10",
   "type": "module",
   "repository": {
     "type": "git",
@@ -10,18 +10,22 @@
   "exports": {
     ".": {
       "types": "./src/index.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/index.js"
     },
     "./assets": {
       "types": "./src/assets/index.ts",
+      "bun": "./src/assets/index.ts",
       "import": "./dist/assets/index.js"
     },
     "./config": {
       "types": "./src/config/index.ts",
+      "bun": "./src/config/index.ts",
       "import": "./dist/config/index.js"
     },
     "./plugins": {
       "types": "./src/plugins/index.ts",
+      "bun": "./src/plugins/index.ts",
       "import": "./dist/plugins/index.js"
     }
   },

package/src/agents/index.ts

@@ -1,20 +1,16 @@
 import { readFile } from "node:fs/promises";
-import type { TaskContract, TaskExecutionMode } from "../task/index.ts";
+import {
+  type ScopedKnowledgeContextPack,
+  createScopedKnowledgeContextPack,
+  formatScopedKnowledgePromptBlock,
+} from "../evolution/knowledge/index.ts";
 
 export type AgentPersistence = "named" | "dynamic";
-export type AgentLens =
-  | "review"
-  | "qa"
-  | "security"
-  | "release"
-  | "architecture"
-  | "migration"
-  | "test";
 export type AgentOutputSchemaId =
   | "review-findings-v1"
   | "verification-summary-v1"
   | "design-options-v1";
-export type AgentFindingSeverity = "blocker" | "high" | "medium" | "low" | "info";
+export type AgentFindingSeverity = "critical" | "high" | "medium" | "low" | "info";
 
 export interface AgentPermissions {
   canReadMetadata: boolean;
@@ -56,34 +52,6 @@ export interface AgentProfile {
   };
 }
 
-export interface AgentPlannedInvocation {
-  profile: AgentProfile;
-  lens: AgentLens;
-  reason: string;
-  plannedOnly: true;
-}
-
-export interface AgentMergePlan {
-  strategy: "none" | "single-output" | "dedupe-preserve-conflicts-fail-closed";
-  outputSchema: AgentOutputSchemaId | null;
-  dedupeBy: string[];
-  conflictPolicy: string[];
-  failClosedCategories: string[];
-}
-
-export interface AgentComposeDryRunPlan {
-  ok: boolean;
-  taskId: string;
-  mode: TaskExecutionMode | null;
-  workflowId: string | null;
-  agents: AgentPlannedInvocation[];
-  permissions: AgentPermissions;
-  mergePlan: AgentMergePlan;
-  warnings: string[];
-  blockers: string[];
-  rationale: string;
-}
-
 export interface AgentContextDryRunBundle {
   profile: AgentProfile;
   context: {
@@ -93,7 +61,16 @@ export interface AgentContextDryRunBundle {
     provenance: string[];
   };
   warnings: string[];
-  blockers: string[];
+  advisories: string[];
+}
+
+export interface AgentLoadedContextBundle {
+  profile: AgentProfile;
+  contextPack: ScopedKnowledgeContextPack | null;
+  promptBlock: string | null;
+  warnings: string[];
+  advisories: string[];
+  rawContentStored: false;
 }
 
 export interface ReviewFindingOutput {
@@ -124,17 +101,6 @@ const DEFAULT_AGENT_PERMISSIONS: AgentPermissions = {
 };
 const FORBIDDEN_INPUTS = ["rawPrompts", "secrets", "rawCommandLogs", "sourceCorpus"];
 const SAFE_AGENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
-const PRIVACY_BLOCKER_PATTERN =
-  /raw prompt|rawprompt|source corpus|sourcecorpus|secret|\.env|raw command|raw log|internal url|private url|network|write files|run commands|spawn agents|write memory/i;
-const LENS_TO_EXPERTISE: Record<AgentLens, string[]> = {
-  review: ["code-review"],
-  qa: ["qa", "verification"],
-  security: ["security", "privacy"],
-  release: ["release", "packaging"],
-  architecture: ["architecture"],
-  migration: ["migration", "impact-analysis"],
-  test: ["testing"],
-};
 
 export function createDefaultAgentPermissions(): AgentPermissions {
   return { ...DEFAULT_AGENT_PERMISSIONS };
@@ -170,16 +136,6 @@ export function parseAgentProfile(value: unknown): AgentProfile {
     throw new Error("Agent profile must be metadata-only and must not store raw prompts/source.");
   }
   const permissions = normalizeAgentPermissions(profile.permissions);
-  if (
-    permissions.canWriteFiles ||
-    permissions.canRunCommands ||
-    permissions.canUseNetwork ||
-    permissions.canSpawnAgents ||
-    permissions.canWriteMemory ||
-    permissions.canReadSourceContent
-  ) {
-    throw new Error("Agent profile requests permissions outside I8 dry-run boundaries.");
-  }
   if (!SAFE_AGENT_ID_PATTERN.test(profile.id)) throw new Error("Agent profile id is unsafe.");
   assertStringArray(profile.traits?.expertise, "profile.traits.expertise");
   assertStringArray(profile.traits?.stance, "profile.traits.stance");
@@ -188,11 +144,6 @@ export function parseAgentProfile(value: unknown): AgentProfile {
   assertStringArray(profile.inputs?.required, "profile.inputs.required");
   assertStringArray(profile.inputs?.optional, "profile.inputs.optional");
   assertStringArray(profile.inputs?.forbidden, "profile.inputs.forbidden");
-  if (!FORBIDDEN_INPUTS.every((item) => profile.inputs.forbidden.includes(item))) {
-    throw new Error(
-      "Agent profile must forbid raw prompts, secrets, raw command logs, and source corpus.",
-    );
-  }
   if (!isKnownOutputSchema(profile.output?.schema))
     throw new Error("Agent profile output schema is unsupported.");
   assertStringArray(profile.output.requiredFields, "profile.output.requiredFields");
@@ -203,73 +154,6 @@ export async function readAgentProfile(path: string): Promise<AgentProfile> {
   return parseAgentProfile(JSON.parse(await readFile(path, "utf8")));
 }
 
-export function composeAgentDryRun(input: {
-  contract: TaskContract;
-  workflowId?: string;
-  lenses?: AgentLens[];
-}): AgentComposeDryRunPlan {
-  const mode = input.contract.route.mode;
-  const workflowId = input.workflowId ?? input.contract.route.workflowId;
-  const warnings: string[] = [];
-  const blockers: string[] = [];
-  const permissions = createDefaultAgentPermissions();
-  const requestedLenses = dedupeLenses(input.lenses ?? []);
-  const privacyBlockers = collectPrivacyBoundaryBlockers(
-    input.contract,
-    requestedLenses,
-    workflowId,
-  );
-  blockers.push(...privacyBlockers);
-
-  if (mode === "minimal") {
-    return {
-      ok: blockers.length === 0,
-      taskId: input.contract.taskId,
-      mode,
-      workflowId,
-      agents: [],
-      permissions,
-      mergePlan: createMergePlan([]),
-      warnings,
-      blockers,
-      rationale: "Minimal mode does not force dynamic agents by default.",
-    };
-  }
-
-  const selectedLenses = selectLenses(
-    mode,
-    requestedLenses,
-    workflowId,
-    input.contract.route.requiredReview,
-  );
-  const agents = selectedLenses.map((lens) => ({
-    profile: createDynamicProfile(lens, input.contract, permissions),
-    lens,
-    reason: createLensReason(lens, mode, workflowId),
-    plannedOnly: true as const,
-  }));
-
-  if (mode === "standard" && agents.length > 1) {
-    blockers.push("Standard mode allows at most one optional reviewer/triager in I8 dry-run.");
-  }
-
-  return {
-    ok: blockers.length === 0,
-    taskId: input.contract.taskId,
-    mode,
-    workflowId,
-    agents,
-    permissions,
-    mergePlan: createMergePlan(agents),
-    warnings,
-    blockers,
-    rationale:
-      agents.length === 0
-        ? "No dynamic agents selected; deterministic verification may be sufficient."
-        : `Selected ${agents.length} planned-only agent(s) based on mode/workflow/lenses.`,
-  };
-}
-
 export function loadAgentContextDryRun(profile: AgentProfile): AgentContextDryRunBundle {
   const parsed = parseAgentProfile(profile);
   return {
@@ -288,10 +172,52 @@ export function loadAgentContextDryRun(profile: AgentProfile): AgentContextDryRu
       provenance: [`agent-profile:${parsed.id}`],
     },
     warnings: [],
-    blockers: [],
+    advisories: [],
+  };
+}
+
+export async function loadAgentContext(input: {
+  homeDir: string;
+  profile: AgentProfile;
+  projectKey?: string;
+  roleId?: string;
+  workflowId?: string;
+  paths?: string[];
+  queryText?: string;
+  limit?: number;
+}): Promise<AgentLoadedContextBundle> {
+  const parsed = parseAgentProfile(input.profile);
+  const pack = await createScopedKnowledgeContextPack({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey,
+    roleId: input.roleId ?? parsed.id,
+    workflowId: input.workflowId,
+    paths: input.paths,
+    queryText: input.queryText,
+    limit: input.limit,
+  });
+  return {
+    profile: parsed,
+    contextPack: pack,
+    promptBlock: pack === null ? null : formatScopedKnowledgePromptBlock(pack),
+    warnings: pack?.warnings ?? [],
+    advisories: [],
+    rawContentStored: false,
   };
 }
 
+export function formatAgentLoadedContextPromptBlock(bundle: AgentLoadedContextBundle): string {
+  if (bundle.promptBlock !== null) return bundle.promptBlock;
+  return [
+    "EvoDev Scoped Knowledge Context",
+    `Agent: ${bundle.profile.id}`,
+    "Raw content stored: false",
+    "",
+    "Applicable items:",
+    "- none",
+  ].join("\n");
+}
+
 export function validateAgentOutput(
   schema: AgentOutputSchemaId,
   output: unknown,
@@ -341,47 +267,6 @@ export function mergeReviewFindings(outputs: ReviewFindingOutput[]): {
   return { acceptedFindings: [...byKey.values()], unresolvedConflicts: conflicts };
 }
 
-export function formatAgentComposeDryRun(plan: AgentComposeDryRunPlan): string {
-  return [
-    "EvoDev agent compose dry-run",
-    "",
-    `Task: ${plan.taskId}`,
-    `Mode: ${plan.mode ?? "not routed"}`,
-    `Workflow: ${plan.workflowId ?? "none"}`,
-    `Rationale: ${plan.rationale}`,
-    "No-write/no-spawn: true",
-    "Privacy: local-private, metadata-only, raw prompts/source/secrets/logs forbidden",
-    "Agents:",
-    ...(plan.agents.length === 0
-      ? ["  - none"]
-      : plan.agents.map(
-          (agent) =>
-            `  - ${agent.profile.id} [${agent.lens}] traits=${agent.profile.traits.expertise.join(",")} schema=${agent.profile.output.schema} plannedOnly=${agent.plannedOnly}`,
-        )),
-    "Inputs:",
-    ...(plan.agents.length === 0
-      ? ["  - none"]
-      : [
-          `  - required: ${plan.agents[0].profile.inputs.required.join(",")}`,
-          `  - optional: ${plan.agents[0].profile.inputs.optional.join(",")}`,
-          `  - forbidden: ${plan.agents[0].profile.inputs.forbidden.join(",")}`,
-        ]),
-    "Permissions:",
-    ...Object.entries(plan.permissions).map(([key, value]) => `  - ${key}: ${value}`),
-    "Merge plan:",
-    `  - strategy: ${plan.mergePlan.strategy}`,
-    `  - outputSchema: ${plan.mergePlan.outputSchema ?? "none"}`,
-    "Warnings:",
-    ...(plan.warnings.length === 0
-      ? ["  - none"]
-      : plan.warnings.map((warning) => `  - ${warning}`)),
-    "Blockers:",
-    ...(plan.blockers.length === 0
-      ? ["  - none"]
-      : plan.blockers.map((blocker) => `  - ${blocker}`)),
-  ].join("\n");
-}
-
 export function formatAgentContextDryRun(bundle: AgentContextDryRunBundle): string {
   return [
     "EvoDev agent load-context dry-run",
@@ -394,123 +279,13 @@ export function formatAgentContextDryRun(bundle: AgentContextDryRunBundle): stri
     ...bundle.context.forbiddenSections.map((section) => `  - ${section}`),
     "Permissions:",
     ...Object.entries(bundle.profile.permissions).map(([key, value]) => `  - ${key}: ${value}`),
-    "Blockers:",
-    ...(bundle.blockers.length === 0
+    "Advisories:",
+    ...(bundle.advisories.length === 0
       ? ["  - none"]
-      : bundle.blockers.map((blocker) => `  - ${blocker}`)),
+      : bundle.advisories.map((advisory) => `  - ${advisory}`)),
   ].join("\n");
 }
 
-function createDynamicProfile(
-  lens: AgentLens,
-  contract: TaskContract,
-  permissions: AgentPermissions,
-): AgentProfile {
-  return {
-    version: 1,
-    id: `dynamic-${lens}-${contract.taskId}`.slice(0, 100),
-    name: `Dynamic ${lens} reviewer`,
-    persistence: "dynamic",
-    description: `Task-scoped ${lens} profile for metadata-only dry-run planning.`,
-    traits: {
-      expertise: LENS_TO_EXPERTISE[lens],
-      stance: ["skeptical-reviewer"],
-      approach: ["evidence-first", "fail-closed"],
-      domain: ["software-rd"],
-    },
-    inputs: {
-      required: ["taskContract", "scope", "evidenceSummary"],
-      optional: ["workflowPlan"],
-      forbidden: FORBIDDEN_INPUTS,
-    },
-    permissions,
-    output: {
-      schema: "review-findings-v1",
-      requiredFields: ["summary", "findings", "confidence", "evidenceRefs"],
-    },
-    privacy: {
-      classification: "local-private",
-      metadataOnly: true,
-      rawPromptStored: false,
-      sourceContentStored: false,
-    },
-  };
-}
-
-function selectLenses(
-  mode: TaskExecutionMode | null,
-  requested: AgentLens[],
-  workflowId: string | null,
-  requiredReview: string[],
-): AgentLens[] {
-  if (requested.length > 0) return mode === "standard" ? requested.slice(0, 1) : requested;
-  if (mode === "standard") return requiredReview.length > 0 ? ["review"] : [];
-  if (mode === "rigorous") {
-    if (workflowId?.includes("security")) return ["security", "review"];
-    if (workflowId?.includes("release")) return ["release", "security"];
-    if (workflowId?.includes("migration")) return ["migration", "architecture"];
-    if (workflowId?.includes("architecture")) return ["architecture", "review"];
-    return requiredReview.length > 0 ? ["review", "qa"] : [];
-  }
-  return [];
-}
-
-function createMergePlan(agents: AgentPlannedInvocation[]): AgentMergePlan {
-  if (agents.length === 0)
-    return {
-      strategy: "none",
-      outputSchema: null,
-      dedupeBy: [],
-      conflictPolicy: [],
-      failClosedCategories: [],
-    };
-  if (agents.length === 1)
-    return {
-      strategy: "single-output",
-      outputSchema: agents[0].profile.output.schema,
-      dedupeBy: [],
-      conflictPolicy: [],
-      failClosedCategories: [],
-    };
-  return {
-    strategy: "dedupe-preserve-conflicts-fail-closed",
-    outputSchema: "review-findings-v1",
-    dedupeBy: ["category", "path", "line", "title"],
-    conflictPolicy: ["preserve dissent", "keep higher severity unless evidence refutes"],
-    failClosedCategories: ["security", "privacy", "release"],
-  };
-}
-
-function createLensReason(
-  lens: AgentLens,
-  mode: TaskExecutionMode | null,
-  workflowId: string | null,
-): string {
-  return `${lens} lens selected for ${mode ?? "unrouted"} mode${workflowId ? ` and workflow ${workflowId}` : ""}.`;
-}
-
-function collectPrivacyBoundaryBlockers(
-  contract: TaskContract,
-  lenses: AgentLens[],
-  workflowId: string | null,
-): string[] {
-  const text = [
-    contract.source.summary,
-    contract.currentState.summary,
-    contract.targetState.summary,
-    contract.route.rationale,
-    workflowId ?? "",
-    ...contract.scope.allowedOperations,
-    ...contract.scope.requiresUserConfirmation,
-    ...lenses,
-  ].join(" ");
-  return PRIVACY_BLOCKER_PATTERN.test(text)
-    ? [
-        "Agent planning refuses privacy/risky context requiring raw data, writes, commands, network, spawning, or memory.",
-      ]
-    : [];
-}
-
 function validateRequiredObject(
   output: unknown,
   fields: string[],
@@ -534,12 +309,8 @@ function isKnownOutputSchema(value: unknown): value is AgentOutputSchemaId {
   );
 }
 
-function dedupeLenses(lenses: AgentLens[]): AgentLens[] {
-  return [...new Set(lenses)];
-}
-
 function severityRank(severity: AgentFindingSeverity): number {
-  return { info: 0, low: 1, medium: 2, high: 3, blocker: 4 }[severity];
+  return { info: 0, low: 1, medium: 2, high: 3, critical: 4 }[severity];
 }
 
 function assertString(value: unknown, path: string): void {