@evo-dev/core 0.0.1-alpha

package/dist/index.js

@@ -0,0 +1,4879 @@
+// packages/core/src/agents/index.ts
+import { readFile } from "node:fs/promises";
+var DEFAULT_AGENT_PERMISSIONS = {
+  canReadMetadata: true,
+  canReadSourceContent: false,
+  canWriteFiles: false,
+  canRunCommands: false,
+  canUseNetwork: false,
+  canSpawnAgents: false,
+  canWriteMemory: false
+};
+var FORBIDDEN_INPUTS = ["rawPrompts", "secrets", "rawCommandLogs", "sourceCorpus"];
+var SAFE_AGENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+var 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;
+var LENS_TO_EXPERTISE = {
+  review: ["code-review"],
+  qa: ["qa", "verification"],
+  security: ["security", "privacy"],
+  release: ["release", "packaging"],
+  architecture: ["architecture"],
+  migration: ["migration", "impact-analysis"],
+  test: ["testing"]
+};
+function createDefaultAgentPermissions() {
+  return { ...DEFAULT_AGENT_PERMISSIONS };
+}
+function applyStrictestAgentPermissions(...permissions) {
+  const merged = createDefaultAgentPermissions();
+  for (const candidate of permissions) {
+    if (candidate === undefined)
+      continue;
+    for (const key of Object.keys(merged)) {
+      merged[key] = merged[key] && candidate[key] === true;
+    }
+  }
+  return merged;
+}
+function parseAgentProfile(value) {
+  if (!isRecord(value))
+    throw new Error("Agent profile must be an object.");
+  if (value.version !== 1)
+    throw new Error("Agent profile version must be 1.");
+  const profile = value;
+  assertString(profile.id, "profile.id");
+  assertString(profile.name, "profile.name");
+  if (profile.persistence !== "named" && profile.persistence !== "dynamic") {
+    throw new Error("Agent profile persistence must be named or dynamic.");
+  }
+  if (profile.privacy?.metadataOnly !== true || profile.privacy.rawPromptStored !== false || profile.privacy.sourceContentStored !== false) {
+    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");
+  assertStringArray(profile.traits?.approach, "profile.traits.approach");
+  assertStringArray(profile.traits?.domain, "profile.traits.domain");
+  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");
+  return { ...profile, permissions };
+}
+async function readAgentProfile(path) {
+  return parseAgentProfile(JSON.parse(await readFile(path, "utf8")));
+}
+function composeAgentDryRun(input) {
+  const mode = input.contract.route.mode;
+  const workflowId = input.workflowId ?? input.contract.route.workflowId;
+  const warnings = [];
+  const blockers = [];
+  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
+  }));
+  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.`
+  };
+}
+function loadAgentContextDryRun(profile) {
+  const parsed = parseAgentProfile(profile);
+  return {
+    profile: parsed,
+    context: {
+      metadataOnly: true,
+      allowedSections: [
+        "role",
+        "inputs",
+        "permissions",
+        "output-schema",
+        "privacy",
+        "failure-behavior"
+      ],
+      forbiddenSections: [...FORBIDDEN_INPUTS, "rawSource", "rawEvidence", "memoryBodies"],
+      provenance: [`agent-profile:${parsed.id}`]
+    },
+    warnings: [],
+    blockers: []
+  };
+}
+function validateAgentOutput(schema, output) {
+  if (schema === "verification-summary-v1")
+    return validateRequiredObject(output, ["summary", "status", "evidenceRefs"]);
+  if (schema === "design-options-v1")
+    return validateRequiredObject(output, ["summary", "options", "recommendation", "evidenceRefs"]);
+  const errors = [];
+  if (!isRecord(output))
+    return { ok: false, errors: ["Output must be an object."] };
+  if (typeof output.summary !== "string")
+    errors.push("summary is required.");
+  if (!Array.isArray(output.findings))
+    errors.push("findings array is required.");
+  if (output.confidence !== "low" && output.confidence !== "medium" && output.confidence !== "high") {
+    errors.push("confidence must be low/medium/high.");
+  }
+  if (!Array.isArray(output.evidenceRefs))
+    errors.push("evidenceRefs array is required.");
+  return { ok: errors.length === 0, errors };
+}
+function mergeReviewFindings(outputs) {
+  const byKey = new Map;
+  const conflicts = [];
+  for (const output of outputs) {
+    for (const finding of output.findings) {
+      const key = `${finding.category}:${finding.path ?? ""}:${finding.line ?? ""}:${finding.title}`;
+      const existing = byKey.get(key);
+      if (existing === undefined) {
+        byKey.set(key, finding);
+        continue;
+      }
+      if (severityRank(finding.severity) > severityRank(existing.severity))
+        byKey.set(key, finding);
+      if (finding.severity !== existing.severity || finding.recommendation !== existing.recommendation) {
+        conflicts.push(key);
+      }
+    }
+  }
+  return { acceptedFindings: [...byKey.values()], unresolvedConflicts: conflicts };
+}
+function formatAgentComposeDryRun(plan) {
+  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(`
+`);
+}
+function formatAgentContextDryRun(bundle) {
+  return [
+    "EvoDev agent load-context dry-run",
+    "",
+    `Agent: ${bundle.profile.id}`,
+    `Persistence: ${bundle.profile.persistence}`,
+    "Allowed sections:",
+    ...bundle.context.allowedSections.map((section) => `  - ${section}`),
+    "Forbidden sections:",
+    ...bundle.context.forbiddenSections.map((section) => `  - ${section}`),
+    "Permissions:",
+    ...Object.entries(bundle.profile.permissions).map(([key, value]) => `  - ${key}: ${value}`),
+    "Blockers:",
+    ...bundle.blockers.length === 0 ? ["  - none"] : bundle.blockers.map((blocker) => `  - ${blocker}`)
+  ].join(`
+`);
+}
+function createDynamicProfile(lens, contract, permissions) {
+  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, requested, workflowId, requiredReview) {
+  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) {
+  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, mode, workflowId) {
+  return `${lens} lens selected for ${mode ?? "unrouted"} mode${workflowId ? ` and workflow ${workflowId}` : ""}.`;
+}
+function collectPrivacyBoundaryBlockers(contract, lenses, workflowId) {
+  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, fields) {
+  if (!isRecord(output))
+    return { ok: false, errors: ["Output must be an object."] };
+  const errors = fields.filter((field) => output[field] === undefined).map((field) => `${field} is required.`);
+  return { ok: errors.length === 0, errors };
+}
+function normalizeAgentPermissions(value) {
+  return { ...createDefaultAgentPermissions(), ...value };
+}
+function isKnownOutputSchema(value) {
+  return value === "review-findings-v1" || value === "verification-summary-v1" || value === "design-options-v1";
+}
+function dedupeLenses(lenses) {
+  return [...new Set(lenses)];
+}
+function severityRank(severity) {
+  return { info: 0, low: 1, medium: 2, high: 3, blocker: 4 }[severity];
+}
+function assertString(value, path) {
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${path} must be a non-empty string.`);
+}
+function assertStringArray(value, path) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new Error(`${path} must be an array of non-empty strings.`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// packages/core/src/assets/errors.ts
+class EvoDevAssetError extends Error {
+  filePath;
+  constructor(message, filePath) {
+    super(filePath ? `${message}: ${filePath}` : message);
+    this.filePath = filePath;
+    this.name = "EvoDevAssetError";
+  }
+}
+function describeType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+// packages/core/src/assets/manifest.ts
+function parseSkillManifest(value) {
+  return {
+    ...parseBaseManifest(value, "skill manifest"),
+    kind: "skill"
+  };
+}
+function parseAgentManifest(value) {
+  return {
+    ...parseBaseManifest(value, "agent manifest"),
+    kind: "agent"
+  };
+}
+function parseBaseManifest(value, label) {
+  const root = expectRecord(value, label);
+  const manifest = {
+    id: expectSlug(root.id, `${label}.id`),
+    name: expectNonEmptyString(root.name, `${label}.name`),
+    version: expectNonEmptyString(root.version, `${label}.version`),
+    category: expectSlug(root.category, `${label}.category`),
+    description: expectNonEmptyString(root.description, `${label}.description`),
+    targets: expectTargets(root.targets, `${label}.targets`),
+    entry: expectRelativePath(root.entry, `${label}.entry`)
+  };
+  if (root.license !== undefined) {
+    manifest.license = expectNonEmptyString(root.license, `${label}.license`);
+  }
+  return manifest;
+}
+function expectRecord(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected object, got ${describeType(value)}`);
+  }
+  return value;
+}
+function expectNonEmptyString(value, path) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new EvoDevAssetError(`Invalid ${path}; expected non-empty string`);
+  }
+  return value;
+}
+function expectSlug(value, path) {
+  const text = expectNonEmptyString(value, path);
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(text)) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected lowercase kebab-case slug`);
+  }
+  return text;
+}
+function expectTargets(value, path) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected non-empty target array`);
+  }
+  const targets = value.map((target, index) => {
+    if (target !== "claude" && target !== "codex") {
+      throw new EvoDevAssetError(`Invalid ${path}[${index}]; expected claude or codex`);
+    }
+    return target;
+  });
+  return [...new Set(targets)];
+}
+function expectRelativePath(value, path) {
+  const text = expectNonEmptyString(value, path);
+  if (text.startsWith("/") || text.includes("..")) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected safe relative path`);
+  }
+  return text;
+}
+// packages/core/src/assets/scanner.ts
+import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+async function scanAssets(paths) {
+  const [skills, agents] = await Promise.all([
+    scanSkillAssets(paths.skillsDir),
+    scanAgentAssets(paths.agentsDir)
+  ]);
+  return { skills, agents };
+}
+async function scanSkillAssets(skillsDir) {
+  return scanAssetKind(skillsDir, parseSkillManifest);
+}
+async function scanAgentAssets(agentsDir) {
+  return scanAssetKind(agentsDir, parseAgentManifest);
+}
+async function scanAssetKind(rootDir, parseManifest) {
+  if (!await pathExists(rootDir)) {
+    return [];
+  }
+  const manifestPaths = await findManifestFiles(rootDir);
+  const assets = await Promise.all(manifestPaths.map((manifestPath) => readScannedAsset(rootDir, manifestPath, parseManifest)));
+  return assets.sort((left, right) => left.registryKey.localeCompare(right.registryKey));
+}
+async function findManifestFiles(rootDir) {
+  const entries = await readdir(rootDir, { withFileTypes: true });
+  const nested = await Promise.all(entries.map(async (entry) => {
+    const entryPath = join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      return findManifestFiles(entryPath);
+    }
+    if (entry.isFile() && entry.name === "manifest.json") {
+      return [entryPath];
+    }
+    return [];
+  }));
+  return nested.flat();
+}
+async function readScannedAsset(rootDir, manifestPath, parseManifest) {
+  const json = await readManifestJson(manifestPath);
+  const manifest = parseManifestWithPath(json, manifestPath, parseManifest);
+  const assetDir = manifestPath.slice(0, -"/manifest.json".length);
+  const entryPath = join(assetDir, manifest.entry);
+  if (!await isFile(entryPath)) {
+    throw new EvoDevAssetError(`Asset entry file not found for ${manifest.id}`, entryPath);
+  }
+  const registryKey = createRegistryKey(rootDir, assetDir, manifest);
+  return {
+    manifest,
+    manifestPath,
+    entryPath,
+    assetDir,
+    registryKey
+  };
+}
+async function readManifestJson(manifestPath) {
+  let raw;
+  try {
+    raw = await readFile2(manifestPath, "utf8");
+  } catch (error) {
+    throw new EvoDevAssetError(`Cannot read manifest (${describeFileError(error)})`, manifestPath);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevAssetError(`Invalid manifest JSON (${describeFileError(error)})`, manifestPath);
+  }
+}
+function parseManifestWithPath(json, manifestPath, parseManifest) {
+  try {
+    return parseManifest(json);
+  } catch (error) {
+    if (error instanceof EvoDevAssetError) {
+      throw new EvoDevAssetError(error.message, manifestPath);
+    }
+    throw error;
+  }
+}
+function createRegistryKey(rootDir, assetDir, manifest) {
+  const relativeDir = relative(rootDir, assetDir).replaceAll("\\", "/");
+  if (relativeDir === "" || relativeDir === manifest.id) {
+    return manifest.id;
+  }
+  return relativeDir;
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isFile(path) {
+  try {
+    const fileStat = await stat(path);
+    return fileStat.isFile();
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function describeFileError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+// packages/core/src/config/errors.ts
+class EvoDevConfigError extends Error {
+  filePath;
+  constructor(message, filePath) {
+    super(filePath ? `${message}: ${filePath}` : message);
+    this.filePath = filePath;
+    this.name = "EvoDevConfigError";
+  }
+}
+function describeType2(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+// packages/core/src/config/paths.ts
+function resolveEvoDevPaths(homeDir = getHomeDir()) {
+  const normalizedHome = stripTrailingSlash(homeDir);
+  const rootDir = `${normalizedHome}/.evodev`;
+  const stateDir = `${rootDir}/state`;
+  return {
+    homeDir: normalizedHome,
+    rootDir,
+    settingsPath: `${rootDir}/settings.json`,
+    registryPath: `${rootDir}/registry.json`,
+    stateDir,
+    installStatePath: `${stateDir}/install.json`,
+    syncStatePath: `${stateDir}/sync.json`
+  };
+}
+function getHomeDir() {
+  const home = process.env.HOME;
+  if (home === undefined || home.trim() === "") {
+    throw new Error("Cannot resolve home directory: HOME is not set");
+  }
+  return home;
+}
+function stripTrailingSlash(path) {
+  if (path === "/") {
+    return path;
+  }
+  return path.replace(/\/+$/, "");
+}
+// packages/core/src/config/registry.ts
+function createDefaultRegistry() {
+  return {
+    version: 1,
+    skills: {},
+    agents: {}
+  };
+}
+function parseRegistry(value) {
+  const root = expectRecord2(value, "registry");
+  if (root.version !== 1) {
+    throw new EvoDevConfigError("Invalid registry.version; expected 1");
+  }
+  return {
+    version: 1,
+    skills: parseAssetMap(root.skills, "registry.skills"),
+    agents: parseAssetMap(root.agents, "registry.agents")
+  };
+}
+function parseAssetMap(value, path) {
+  const input = expectRecord2(value, path);
+  const output = {};
+  for (const [assetId, asset] of Object.entries(input)) {
+    output[assetId] = parseRegisteredAsset(asset, `${path}.${assetId}`);
+  }
+  return output;
+}
+function parseRegisteredAsset(value, path) {
+  const input = expectRecord2(value, path);
+  const source = input.source;
+  if (source !== "builtin" && source !== "user") {
+    throw new EvoDevConfigError(`Invalid ${path}.source; expected builtin or user`);
+  }
+  if (!Array.isArray(input.targets) || !input.targets.every((target) => typeof target === "string")) {
+    throw new EvoDevConfigError(`Invalid ${path}.targets; expected string array`);
+  }
+  return {
+    version: expectString(input.version, `${path}.version`),
+    source,
+    targets: [...input.targets]
+  };
+}
+function expectRecord2(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected object, got ${describeType2(value)}`);
+  }
+  return value;
+}
+function expectString(value, path) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected non-empty string`);
+  }
+  return value;
+}
+// packages/core/src/hooks/index.ts
+import { createHash } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+
+// packages/core/src/task/index.ts
+import { lstat, mkdir, readFile as readFile3, realpath, stat as stat2, writeFile } from "node:fs/promises";
+import { basename, dirname, join as join2, resolve } from "node:path";
+var FORBIDDEN_TASK_PATHS = ["CLAUDE.md", "AGENTS.md", ".claude/**", ".codex/**"];
+var FORBIDDEN_TASK_WRITE_SEGMENTS = new Set([".claude", ".codex"]);
+var FORBIDDEN_PROJECT_ASSET_SEGMENTS = new Set(["packages", "src"]);
+var FORBIDDEN_TASK_WRITE_FILES = new Set(["agents.md", "claude.md", "package.json", "readme.md"]);
+var FORBIDDEN_RAW_KEYS = new Set([
+  "rawoutput",
+  "raw_output",
+  "stdout",
+  "stderr",
+  "source",
+  "sourcecontent",
+  "source_content",
+  "sourcetext",
+  "source_text",
+  "prompt",
+  "prompttext",
+  "prompt_text",
+  "transcript",
+  "transcripttext",
+  "transcript_text",
+  "secret",
+  "secretvalue",
+  "secret_value"
+]);
+var ALLOWED_VERIFICATION_KEYS = new Set([
+  "acceptanceResults",
+  "antiCriteriaResults",
+  "commands",
+  "evidence",
+  "exitCode",
+  "id",
+  "status",
+  "summary",
+  "type"
+]);
+var SENSITIVE_TEXT_PATTERN = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw source|raw prompt)\b/gi;
+function createTaskContract(input) {
+  const taskId = createTaskId(input.title);
+  const summary = input.summary ?? input.title;
+  const acceptanceCriteria = input.acceptanceCriteria === undefined || input.acceptanceCriteria.length === 0 ? [
+    {
+      id: "AC1",
+      category: "engineering",
+      statement: "Task outcome satisfies the requested target state.",
+      requiredEvidence: ["verification-summary"],
+      status: "not-run"
+    }
+  ] : input.acceptanceCriteria.map((criterion) => ({
+    id: sanitizeId(criterion.id),
+    category: criterion.category,
+    statement: sanitizeText(criterion.statement),
+    requiredEvidence: uniqueSanitizedIds(criterion.requiredEvidence ?? []),
+    status: "not-run"
+  }));
+  const defaultAntiCriteria = [
+    {
+      id: "ANTI1",
+      category: "privacy",
+      statement: "Do not collect source code, prompts, raw command output, secrets, or internal links.",
+      status: "unknown"
+    },
+    {
+      id: "ANTI2",
+      category: "scope",
+      statement: "Do not write outside approved task storage or approved implementation scope.",
+      status: "unknown"
+    }
+  ];
+  return {
+    version: 1,
+    taskId,
+    status: "draft",
+    classification: "local-private",
+    source: { summary: sanitizeText(summary), rawPromptStored: false },
+    context: {
+      projectId: input.projectId === undefined || input.projectId === null ? null : sanitizeText(input.projectId),
+      relatedFiles: [],
+      assumptions: [],
+      openQuestions: []
+    },
+    currentState: { summary: "To be completed by the task owner.", evidenceRefs: [] },
+    targetState: { summary: sanitizeText(input.title), nonGoals: [], constraints: [] },
+    scope: {
+      allowedPaths: sanitizeTextList(input.allowedPaths ?? []),
+      forbiddenPaths: FORBIDDEN_TASK_PATHS,
+      allowedOperations: input.allowedOperations === undefined || input.allowedOperations.length === 0 ? ["read", "edit-approved-files", "run-local-tests"] : sanitizeTextList(input.allowedOperations),
+      requiresUserConfirmation: sanitizeTextList(input.requiresUserConfirmation ?? [])
+    },
+    acceptanceCriteria,
+    antiCriteria: [
+      ...defaultAntiCriteria,
+      ...(input.antiCriteria ?? []).map((criterion) => ({
+        id: sanitizeId(criterion.id),
+        category: criterion.category,
+        statement: sanitizeText(criterion.statement),
+        status: "unknown"
+      }))
+    ],
+    route: {
+      mode: null,
+      workflowId: null,
+      rationale: "Not routed yet.",
+      requiredReview: [],
+      requiredVerification: uniqueSanitizedIds(input.requiredVerification ?? [])
+    },
+    verification: {
+      policy: "fail-closed",
+      commands: [],
+      acceptanceResults: [],
+      antiCriteriaResults: [],
+      status: "not-run",
+      summary: "Verification has not run."
+    },
+    evidence: { metadataOnly: true, items: [] },
+    learningCandidates: []
+  };
+}
+function routeTaskContract(contract) {
+  const mode = selectMode(contract);
+  const requiredVerification = uniqueSanitizedIds([
+    ...contract.route.requiredVerification ?? [],
+    "verification-summary"
+  ]);
+  return {
+    ...contract,
+    status: "routed",
+    route: {
+      mode,
+      workflowId: selectWorkflowId(contract, mode),
+      rationale: createRouteRationale(contract, mode),
+      requiredReview: mode === "rigorous" ? ["security-boundary", "verification"] : [],
+      requiredVerification
+    }
+  };
+}
+function verifyTaskContract(contract, input) {
+  assertMetadataOnly(input);
+  const commands = (input.commands ?? []).map((command) => ({
+    id: sanitizeId(command.id),
+    status: assertVerificationCommandStatus(command.status, `command ${command.id}`),
+    exitCode: command.exitCode,
+    summary: sanitizeText(command.summary ?? `${command.id}: ${command.status}`),
+    rawOutputStored: false
+  }));
+  const acceptanceResults = (input.acceptanceResults ?? []).map((result) => ({
+    id: sanitizeId(result.id),
+    status: assertAcceptanceResultStatus(result.status, `acceptance ${result.id}`),
+    summary: sanitizeText(result.summary ?? `${result.id}: ${result.status}`)
+  }));
+  const antiCriteriaResults = (input.antiCriteriaResults ?? []).map((result) => ({
+    id: sanitizeId(result.id),
+    status: assertAntiCriteriaResultStatus(result.status, `anti-criteria ${result.id}`),
+    summary: sanitizeText(result.summary ?? `${result.id}: ${result.status}`)
+  }));
+  const evidence = (input.evidence ?? []).map((item) => ({
+    type: assertEvidenceType(item.type, `evidence ${item.id}`),
+    id: sanitizeId(item.id),
+    status: assertVerificationStatus(item.status, `evidence ${item.id}`),
+    summary: sanitizeText(item.summary ?? `${item.id}: ${item.status}`),
+    rawOutputStored: false,
+    sourceContentStored: false
+  }));
+  const failures = collectVerificationFailures(contract, commands, acceptanceResults, antiCriteriaResults, evidence);
+  const ok = failures.length === 0;
+  const summary = ok ? "Verification passed." : `Verification failed: ${failures.join("; ")}`;
+  return {
+    ok,
+    summary,
+    contract: {
+      ...contract,
+      status: ok ? "verified" : "failed",
+      acceptanceCriteria: contract.acceptanceCriteria.map((criterion) => ({
+        ...criterion,
+        status: acceptanceResults.find((result) => result.id === criterion.id)?.status ?? criterion.status
+      })),
+      antiCriteria: contract.antiCriteria.map((criterion) => ({
+        ...criterion,
+        status: antiCriteriaResults.find((result) => result.id === criterion.id)?.status ?? criterion.status
+      })),
+      verification: {
+        policy: "fail-closed",
+        commands,
+        acceptanceResults,
+        antiCriteriaResults,
+        status: ok ? "pass" : "fail",
+        summary
+      },
+      evidence: {
+        metadataOnly: true,
+        items: evidence
+      }
+    }
+  };
+}
+async function readTaskContract(path) {
+  return parseTaskContract(JSON.parse(await readFile3(path, "utf8")));
+}
+async function writeTaskContract(path, contract, options = {}) {
+  await assertTaskContractWritePathAllowed(path);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(contract, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: options.overwrite === true ? "w" : "wx"
+  });
+}
+async function resolveTaskContractOutputPath(input) {
+  if (input.outputDir !== undefined) {
+    const outputPath = join2(input.outputDir, input.taskId, "contract.json");
+    await assertTaskContractWritePathAllowed(outputPath);
+    return outputPath;
+  }
+  if (input.projectDir !== undefined) {
+    const projectContextPath = join2(input.projectDir, ".evodev", "project.json");
+    if (!await pathExists2(projectContextPath)) {
+      throw new Error("Project mode requires existing .evodev/project.json; use --output-dir instead.");
+    }
+    const outputPath = join2(input.projectDir, ".evodev", "tasks", input.taskId, "contract.json");
+    await assertTaskContractWritePathAllowed(outputPath);
+    return outputPath;
+  }
+  throw new Error("Task writes require --output-dir or --project-dir with existing project context.");
+}
+function formatTaskContract(contract) {
+  return [
+    "EvoDev task contract",
+    "",
+    `Task id: ${contract.taskId}`,
+    `Status: ${contract.status}`,
+    `Summary: ${contract.source.summary}`,
+    `Mode: ${contract.route.mode ?? "not routed"}`,
+    `Workflow: ${contract.route.workflowId ?? "not routed"}`,
+    `Required verification: ${formatList(contract.route.requiredVerification)}`,
+    `Required review: ${formatList(contract.route.requiredReview)}`,
+    `Route rationale: ${contract.route.rationale}`,
+    `Verification: ${contract.verification.status}`,
+    `Verification summary: ${contract.verification.summary}`
+  ].join(`
+`);
+}
+function selectMode(contract) {
+  if (selectRigorousTrigger(contract) !== null) {
+    return "rigorous";
+  }
+  const allowedPaths = contract.scope.allowedPaths ?? [];
+  if (allowedPaths.length <= 1 && contract.acceptanceCriteria.length <= 1) {
+    return "minimal";
+  }
+  return "standard";
+}
+function selectWorkflowId(contract, mode) {
+  const text = collectRouteText(contract);
+  if (text.includes("release") || text.includes("publish"))
+    return "rd-release-readiness";
+  if (hasSecurityBoundaryTerms(text) || mode === "rigorous") {
+    return "rd-security-boundary-review";
+  }
+  if (text.includes("bug"))
+    return "rd-bug-fix";
+  if (text.includes("refactor"))
+    return "rd-refactor";
+  if (text.includes("review"))
+    return "rd-code-review";
+  if (text.includes("doc"))
+    return "rd-docs-update";
+  if (text.includes("test"))
+    return "rd-test-generation";
+  if (mode === "minimal")
+    return "rd-docs-update";
+  return "rd-feature-implementation";
+}
+function collectRouteText(contract) {
+  return [
+    contract.taskId,
+    contract.source.summary,
+    contract.currentState.summary,
+    ...contract.currentState.evidenceRefs,
+    contract.targetState.summary,
+    ...contract.targetState.nonGoals,
+    ...contract.targetState.constraints,
+    ...contract.context.relatedFiles.map((file) => `${file.path} ${file.reason}`),
+    ...contract.context.assumptions,
+    ...contract.context.openQuestions,
+    ...contract.scope.allowedPaths ?? [],
+    ...contract.scope.allowedOperations ?? [],
+    ...contract.scope.requiresUserConfirmation ?? [],
+    ...contract.acceptanceCriteria.map((criterion) => criterion.statement),
+    ...contract.acceptanceCriteria.flatMap((criterion) => criterion.requiredEvidence),
+    ...contract.route.requiredVerification ?? []
+  ].join(" ").toLowerCase();
+}
+function createRouteRationale(contract, mode) {
+  const trigger = selectRigorousTrigger(contract);
+  if (mode === "rigorous")
+    return `Selected rigorous due to ${trigger ?? "high-risk"} trigger.`;
+  if (mode === "minimal")
+    return "Selected minimal for narrow scope and simple acceptance criteria.";
+  return "Selected standard for bounded engineering work requiring Task Contract verification.";
+}
+function selectRigorousTrigger(contract) {
+  const text = collectRouteText(contract);
+  if (text.includes("[redacted]") || hasSecurityBoundaryTerms(text))
+    return "privacy/security";
+  if (/\b(release|publish|publishing|package distribution|npm publish)\b/.test(text)) {
+    return "release/publish";
+  }
+  if (/\b(hook|hooks|learning|memory|telemetry|observability)\b/.test(text)) {
+    return "hook/learning/telemetry";
+  }
+  if (/\b(migration|migrate|hard to rollback|hard-to-rollback|irreversible|destructive)\b/.test(text)) {
+    return "hard-to-rollback";
+  }
+  if (hasHighRiskOperationTerms(text)) {
+    return "high-risk operation";
+  }
+  if ((contract.scope.requiresUserConfirmation ?? []).length > 0) {
+    return "explicit user confirmation";
+  }
+  for (const path of contract.scope.allowedPaths ?? []) {
+    const trigger = selectRigorousPathTrigger(path);
+    if (trigger !== null)
+      return trigger;
+  }
+  for (const operation of contract.scope.allowedOperations ?? []) {
+    if (hasHighRiskOperationTerms(operation))
+      return "high-risk operation";
+  }
+  return null;
+}
+function hasSecurityBoundaryTerms(text) {
+  return /\b(security|privacy|private data|auth|authentication|authorization|credential|credentials|secret|secrets|token|tokens|api key|api-key|apikey|password|passwd)\b/.test(text);
+}
+function selectRigorousPathTrigger(path) {
+  const normalized = path.trim().replace(/\\/g, "/").toLowerCase();
+  if (/^~\/\.(evodev|claude|codex)(\/|$)/.test(normalized)) {
+    return "user-level Code Agent/EvoDev path";
+  }
+  if (normalized === ".evodev" || normalized.startsWith(".evodev/") || normalized.includes("/.evodev/")) {
+    return "project .evodev path";
+  }
+  if (normalized === ".claude" || normalized.startsWith(".claude/") || normalized.includes("/.claude/") || normalized === ".codex" || normalized.startsWith(".codex/") || normalized.includes("/.codex/")) {
+    return "project Code Agent config path";
+  }
+  const fileName = basename(normalized);
+  if (fileName === "claude.md" || fileName === "agents.md")
+    return "agent instruction file";
+  return null;
+}
+function hasHighRiskOperationTerms(text) {
+  const normalized = text.toLowerCase().replace(/[_-]+/g, " ");
+  return /\b(delete|remove|publish|release|install|uninstall|network|external|external service|external api|write user config|user config|write project context|project context|hook|learning|memory|telemetry)\b/.test(normalized);
+}
+function collectVerificationFailures(contract, commands, acceptanceResults, antiCriteriaResults, evidence) {
+  const failures = [];
+  if (!isVerificationReady(contract)) {
+    failures.push("task contract must be routed before verification");
+  }
+  failures.push(...collectDuplicateIdFailures("command", commands));
+  failures.push(...collectDuplicateIdFailures("evidence", evidence));
+  failures.push(...collectDuplicateIdFailures("acceptance result", acceptanceResults));
+  failures.push(...collectDuplicateIdFailures("anti-criteria result", antiCriteriaResults));
+  for (const requiredId of contract.route.requiredVerification ?? []) {
+    const matches = [
+      ...commands.filter((command) => command.id === requiredId),
+      ...evidence.filter((item) => item.id === requiredId)
+    ];
+    if (matches.length === 0) {
+      failures.push(`missing required verification: ${requiredId}`);
+      continue;
+    }
+    if (matches.some((item) => !isSatisfyingVerificationItem(item))) {
+      failures.push(`required verification ${requiredId} is not satisfied`);
+    }
+  }
+  for (const criterion of contract.acceptanceCriteria) {
+    const result = acceptanceResults.find((candidate) => candidate.id === criterion.id);
+    if (result === undefined || result.status !== "pass" && result.status !== "not-applicable") {
+      failures.push(`acceptance ${criterion.id} is not satisfied`);
+    }
+    for (const evidenceId of criterion.requiredEvidence) {
+      const matches = evidence.filter((item) => item.id === evidenceId);
+      if (matches.length === 0) {
+        failures.push(`missing evidence for ${criterion.id}: ${evidenceId}`);
+        continue;
+      }
+      if (matches.some((item) => !isSatisfyingEvidenceItem(item))) {
+        failures.push(`evidence for ${criterion.id} is not satisfied: ${evidenceId}`);
+      }
+    }
+  }
+  for (const criterion of contract.antiCriteria) {
+    const result = antiCriteriaResults.find((candidate) => candidate.id === criterion.id);
+    if (result === undefined || result.status === "unknown" || result.status === "triggered") {
+      failures.push(`anti-criteria ${criterion.id} is not clear`);
+    }
+  }
+  return failures;
+}
+function collectDuplicateIdFailures(label, items) {
+  const seen = new Set;
+  const duplicates = new Set;
+  for (const item of items) {
+    if (seen.has(item.id))
+      duplicates.add(item.id);
+    seen.add(item.id);
+  }
+  return Array.from(duplicates).map((id) => `duplicate ${label} id: ${id}`);
+}
+function isSatisfyingVerificationItem(item) {
+  if ("rawOutputStored" in item && "type" in item)
+    return isSatisfyingEvidenceItem(item);
+  return item.status === "pass";
+}
+function isSatisfyingEvidenceItem(item) {
+  if (item.type === "command-result")
+    return item.status === "pass";
+  return item.status === "pass" || item.status === "clear";
+}
+function isVerificationReady(contract) {
+  return contract.status !== "draft" && contract.route.mode !== null && contract.route.workflowId !== null && (contract.route.requiredVerification ?? []).length > 0;
+}
+function parseTaskContract(value) {
+  if (!isRecord2(value) || value.version !== 1 || typeof value.taskId !== "string") {
+    throw new Error("Invalid Task Contract JSON.");
+  }
+  return value;
+}
+function assertMetadataOnly(value) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertMetadataOnly(item);
+    return;
+  }
+  if (!isRecord2(value)) {
+    if (typeof value === "string" && containsSensitiveText(value)) {
+      throw new Error("Verification input contains sensitive content in metadata field.");
+    }
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (FORBIDDEN_RAW_KEYS.has(key) || FORBIDDEN_RAW_KEYS.has(normalizedKey)) {
+      throw new Error(`Verification input contains forbidden raw field: ${key}`);
+    }
+    if (!ALLOWED_VERIFICATION_KEYS.has(key)) {
+      throw new Error(`Verification input contains unsupported field: ${key}`);
+    }
+    assertMetadataOnly(child);
+  }
+}
+function assertVerificationCommandStatus(value, label) {
+  if (value === "pass" || value === "fail" || value === "not-run")
+    return value;
+  throw new Error(`Invalid verification command status for ${label}: ${String(value)}`);
+}
+function assertAcceptanceResultStatus(value, label) {
+  if (value === "pass" || value === "fail" || value === "not-run" || value === "not-applicable") {
+    return value;
+  }
+  throw new Error(`Invalid acceptance result status for ${label}: ${String(value)}`);
+}
+function assertAntiCriteriaResultStatus(value, label) {
+  if (value === "clear" || value === "triggered" || value === "unknown")
+    return value;
+  throw new Error(`Invalid anti-criteria result status for ${label}: ${String(value)}`);
+}
+function assertVerificationStatus(value, label) {
+  if (value === "pass" || value === "fail" || value === "not-run" || value === "not-applicable" || value === "unknown" || value === "triggered" || value === "clear") {
+    return value;
+  }
+  throw new Error(`Invalid verification status for ${label}: ${String(value)}`);
+}
+function assertEvidenceType(value, label) {
+  if (value === "command-result" || value === "manual-check" || value === "review")
+    return value;
+  throw new Error(`Invalid evidence type for ${label}: ${String(value)}`);
+}
+function sanitizeText(value) {
+  return value.replace(SENSITIVE_TEXT_PATTERN, "[redacted]").slice(0, 500);
+}
+function containsSensitiveText(value) {
+  SENSITIVE_TEXT_PATTERN.lastIndex = 0;
+  return SENSITIVE_TEXT_PATTERN.test(value);
+}
+async function assertTaskContractWritePathAllowed(path) {
+  assertTaskContractWritePathSegmentsAllowed(resolve(path));
+  assertTaskContractWritePathSegmentsAllowed(await resolveTaskWriteRealPath(path));
+}
+function assertTaskContractWritePathSegmentsAllowed(path) {
+  const segments = path.replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0).map((segment) => segment.toLowerCase());
+  const protectedSegment = segments.find((segment) => FORBIDDEN_TASK_WRITE_SEGMENTS.has(segment));
+  if (protectedSegment !== undefined) {
+    throw new Error(`Task contract write path is protected: ${protectedSegment}`);
+  }
+  if (!isTaskStoragePath(segments)) {
+    const protectedProjectAssetSegment = segments.find((segment) => FORBIDDEN_PROJECT_ASSET_SEGMENTS.has(segment));
+    if (protectedProjectAssetSegment !== undefined) {
+      throw new Error(`Task contract write path is protected: ${protectedProjectAssetSegment}`);
+    }
+  }
+  const protectedFile = segments.find((segment) => FORBIDDEN_TASK_WRITE_FILES.has(segment));
+  if (protectedFile !== undefined) {
+    throw new Error(`Task contract write path is protected: ${protectedFile}`);
+  }
+}
+async function resolveTaskWriteRealPath(path) {
+  let currentPath = resolve(path);
+  const missingSegments = [];
+  while (true) {
+    try {
+      await lstat(currentPath);
+      return join2(await realpath(currentPath), ...missingSegments.reverse());
+    } catch (error) {
+      if (!isMissingPathError(error))
+        throw error;
+      const parentPath = dirname(currentPath);
+      if (parentPath === currentPath)
+        return resolve(path);
+      missingSegments.push(basename(currentPath));
+      currentPath = parentPath;
+    }
+  }
+}
+function isTaskStoragePath(segments) {
+  return segments.some((segment, index) => segment === ".evodev" && (segments[index + 1] === "tasks" || segments[index + 1] === "state" && segments[index + 2] === "tasks"));
+}
+function sanitizeTextList(values) {
+  return values.map((value) => sanitizeText(value)).filter((value) => value.length > 0);
+}
+function sanitizeId(value) {
+  const sanitized = sanitizeText(value).replace(/\[redacted\]/gi, "redacted").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return sanitized || "item";
+}
+function uniqueSanitizedIds(values) {
+  return Array.from(new Set(values.map((value) => sanitizeId(value))));
+}
+function formatList(values) {
+  return values.length === 0 ? "none" : values.join(", ");
+}
+function createTaskId(title) {
+  const slug = sanitizeId(title.toLowerCase()) || "task";
+  return `task-${slug}`.slice(0, 80);
+}
+async function pathExists2(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function isMissingPathError(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/core/src/hooks/index.ts
+var CANONICAL_HOOK_EVENT_TYPES = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "UserPromptExpansion",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PostToolBatch",
+  "PermissionDenied",
+  "SubagentStart",
+  "Stop",
+  "StopFailure",
+  "TeammateIdle",
+  "SubagentStop",
+  "TaskCreated",
+  "TaskCompleted",
+  "PreCompact",
+  "PostCompact",
+  "SessionEnd",
+  "ConfigChange",
+  "CwdChanged",
+  "FileChanged",
+  "WorktreeCreate",
+  "WorktreeRemove"
+];
+var DEFAULT_EVENT_SETTINGS = {
+  SessionStart: false,
+  UserPromptSubmit: false,
+  UserPromptExpansion: false,
+  PreToolUse: false,
+  PermissionRequest: false,
+  PostToolUse: false,
+  PostToolUseFailure: false,
+  PostToolBatch: false,
+  PermissionDenied: false,
+  SubagentStart: false,
+  Stop: false,
+  StopFailure: false,
+  TeammateIdle: false,
+  SubagentStop: false,
+  TaskCreated: false,
+  TaskCompleted: false,
+  PreCompact: false,
+  PostCompact: false,
+  SessionEnd: false,
+  ConfigChange: false,
+  CwdChanged: false,
+  FileChanged: false,
+  WorktreeCreate: false,
+  WorktreeRemove: false
+};
+var SENSITIVE_TEXT_PATTERN2 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|\.env)\b/i;
+var SOURCE_LIKE_PATTERN = /\b(function|class|import|export|const|let|var)\b.*[{};]/s;
+function createDefaultHookSettings() {
+  return {
+    enabled: false,
+    targets: {
+      claude: {
+        enabled: false,
+        events: { ...DEFAULT_EVENT_SETTINGS }
+      },
+      codex: {
+        enabled: false,
+        events: { ...DEFAULT_EVENT_SETTINGS }
+      }
+    },
+    observability: {
+      metadataOnly: true,
+      rawPayloadStorage: false,
+      appendEvents: false
+    },
+    learning: {
+      emitCandidates: false,
+      writeMemory: false
+    }
+  };
+}
+function parseHookSettings(value) {
+  const defaults = createDefaultHookSettings();
+  if (value === undefined || value === null)
+    return defaults;
+  if (!isRecord3(value))
+    throw new Error("Invalid hooks settings; expected object.");
+  return {
+    enabled: optionalBoolean(value.enabled, defaults.enabled, "hooks.enabled"),
+    targets: {
+      claude: parseHookTargetSettings(value.targets, defaults.targets.claude, "claude"),
+      codex: parseHookTargetSettings(value.targets, defaults.targets.codex, "codex")
+    },
+    observability: {
+      metadataOnly: true,
+      rawPayloadStorage: false,
+      appendEvents: false
+    },
+    learning: {
+      emitCandidates: false,
+      writeMemory: false
+    }
+  };
+}
+function normalizeHookEvent(input) {
+  const warnings = [];
+  const type = normalizeHookEventType(input.type, warnings);
+  const redactions = [];
+  const metadata = extractMetadata(type, input.payload, redactions);
+  const commandClass = typeof metadata.commandClass === "string" ? metadata.commandClass : undefined;
+  const decision = decideHookPolicy(commandClass);
+  const sessionIdHash = hashOptionalIdentifier(input.payload.session_id ?? input.payload.sessionId);
+  return {
+    version: 1,
+    eventId: stableEventId(input.pluginId, type, sessionIdHash),
+    type,
+    source: {
+      pluginId: sanitizeScalar(input.pluginId, redactions),
+      agent: sanitizeScalar(input.agent ?? "unknown", redactions),
+      sessionIdHash,
+      rawPayloadStored: false
+    },
+    time: {
+      occurredAt: optionalSanitizedString(input.payload.timestamp ?? input.payload.occurredAt, redactions),
+      receivedAt: input.receivedAt ?? "dry-run"
+    },
+    scope: {
+      taskId: optionalSanitizedString(input.payload.taskId, redactions),
+      projectId: optionalSanitizedString(input.payload.projectId, redactions),
+      cwdPolicy: "metadata-only",
+      projectContextOptedIn: false
+    },
+    payload: {
+      summary: summarizeEvent(type, metadata),
+      metadata,
+      redactions,
+      redactionCount: redactions.length,
+      rawContentIncluded: false
+    },
+    policy: {
+      classification: "local-private",
+      allowedUses: ["observability", "safety-check", "workflow-suggestion"],
+      learningAllowed: false,
+      externalUploadAllowed: false
+    },
+    decision,
+    warnings
+  };
+}
+function classifyCommandRisk(command) {
+  if (command === undefined || command.trim() === "")
+    return "unknown";
+  const lower = command.toLowerCase();
+  if (/(^|\s)(\.\.\/|\/\.\.)/.test(lower))
+    return "path-escaping";
+  if (/\b(npm|pnpm|yarn|bun)\s+publish\b|\bgh\s+release\b/.test(lower))
+    return "publish";
+  if (/\b(curl|wget|scp|rsync|ssh|ftp)\b|https?:\/\//.test(lower))
+    return "network";
+  if (/\b(rm|rmdir|unlink)\b|--delete\b/.test(lower))
+    return "delete";
+  if (/\b(secret|token|password|passwd|credential|api[_-]?key)\b|(^|\s)\.env(\s|$)/.test(lower)) {
+    return "credential-sensitive";
+  }
+  if (/\b(vim|nano|tee|touch|mkdir|mv|cp|chmod|chown)\b|>/.test(lower))
+    return "write";
+  if (/\b(test|lint|typecheck|check)\b/.test(lower))
+    return "test-command";
+  if (/\b(ls|pwd|grep|rg|find|git status|git diff|cat)\b/.test(lower))
+    return "read-only";
+  return "unknown";
+}
+function formatHookInstallDryRun(plan) {
+  return [
+    "EvoDev hook install dry-run",
+    "",
+    `Target: ${plan.target}`,
+    "Mode: dry-run (no writes)",
+    `Hooks enabled by default: ${plan.settings.enabled}`,
+    "Selected events:",
+    ...CANONICAL_HOOK_EVENT_TYPES.map((eventType) => `  - ${eventType}: ${plan.settings.targets[plan.target].events[eventType]}`),
+    "Boundaries:",
+    "  - observability: metadata-only, appendEvents=false, rawPayloadStorage=false",
+    "  - learning: emitCandidates=false, writeMemory=false",
+    "  - external upload: false",
+    "  - protected project writes: .claude/.codex/CLAUDE.md/AGENTS.md not targeted",
+    "  - backup/merge: required before any future real install; dry-run writes nothing",
+    "Planned writes:",
+    ...plan.plannedWrites.map((write) => `  - ${write.action}: ${write.targetPath} (${write.reason})`),
+    "Warnings:",
+    ...plan.warnings.length === 0 ? ["  - none"] : plan.warnings.map((warning) => `  - ${warning}`),
+    "Blockers:",
+    ...plan.blockers.length === 0 ? ["  - none"] : plan.blockers.map((blocker) => `  - ${blocker}`)
+  ].join(`
+`);
+}
+function formatHookEventDryRun(event) {
+  return [
+    "EvoDev hook event dry-run",
+    "",
+    `Type: ${event.type}`,
+    `Plugin: ${event.source.pluginId}`,
+    `Summary: ${event.payload.summary}`,
+    `Decision: ${event.decision.action} (${event.decision.reason})`,
+    "Metadata:",
+    ...Object.entries(event.payload.metadata).map(([key, value]) => `  - ${key}: ${formatMetadataValue(value)}`),
+    "Redactions:",
+    ...event.payload.redactions.length === 0 ? ["  - none"] : event.payload.redactions.map((redaction) => `  - ${redaction}`),
+    "Warnings:",
+    ...event.warnings.length === 0 ? ["  - none"] : event.warnings.map((warning) => `  - ${warning}`)
+  ].join(`
+`);
+}
+function resolveHookRuntimeSessionPaths(input) {
+  const sessionDir = join3(input.homeDir, ".evodev", "STATE", "hooks", "sessions", input.sessionKey);
+  return {
+    sessionDir,
+    bindingPath: join3(sessionDir, "binding.json"),
+    contractPath: join3(sessionDir, "contract.json")
+  };
+}
+async function handleHookRuntime(input) {
+  const enabled = isHookEventEnabled(input.settings, input.target, input.event.type);
+  if (!enabled) {
+    return {
+      target: input.target,
+      event: input.event.type,
+      enabled,
+      output: null,
+      stateWrites: [],
+      summary: `Hook ${input.event.type} ignored because EvoDev hooks are disabled.`
+    };
+  }
+  if (input.event.type === "SessionStart")
+    return handleSessionStart(input);
+  if (input.event.type === "UserPromptSubmit")
+    return handleUserPromptSubmit(input);
+  if (input.event.type === "PreToolUse")
+    return handlePreToolUse(input);
+  if (input.event.type === "PostToolUse" || input.event.type === "PostToolUseFailure") {
+    return handlePostToolUse(input);
+  }
+  if (input.event.type === "PostToolBatch")
+    return handleAdditionalContext(input, "PostToolBatch");
+  if (input.event.type === "SubagentStart" || input.event.type === "TaskCreated" || input.event.type === "PermissionRequest") {
+    return handlePreToolUse(input);
+  }
+  if (input.event.type === "Stop" || input.event.type === "SubagentStop" || input.event.type === "TaskCompleted" || input.event.type === "TeammateIdle") {
+    return handleCompletionGate(input);
+  }
+  if (input.event.type === "PreCompact")
+    return handlePreCompact(input);
+  if (input.event.type === "SessionEnd")
+    return handleSessionEnd(input);
+  return handleAdditionalContext(input, input.event.type);
+}
+function formatHookRuntimeOutput(result) {
+  return result.output === null ? "" : `${JSON.stringify(result.output)}
+`;
+}
+function isHookEventEnabled(settings, target, eventType) {
+  return settings.enabled === true && settings.targets[target]?.enabled === true && settings.targets[target]?.events[eventType] === true;
+}
+async function handleSessionStart(input) {
+  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
+  const context = [
+    "EvoDev session initialized.",
+    binding?.contractPath ? `Active Task Contract: ${binding.contractPath}` : "No active Task Contract yet.",
+    "User prompts will be routed through EvoDev before execution."
+  ].join(" ");
+  return createRuntimeResult(input, hookOutput(input.event.type, { additionalContext: context }), {
+    summary: "Session context prepared."
+  });
+}
+async function handleUserPromptSubmit(input) {
+  const classification = classifyUserPrompt(input.rawPayload.prompt ?? input.rawPayload.userPrompt);
+  const sessionKey = resolveHookSessionKey(input.rawPayload);
+  const paths = resolveHookRuntimeSessionPaths({ homeDir: input.homeDir, sessionKey });
+  const contract = routeTaskContract(createHookTaskContract(input, classification));
+  const binding = {
+    version: 1,
+    target: input.target,
+    sessionKey,
+    taskId: contract.taskId,
+    contractPath: paths.contractPath,
+    cwd: optionalPayloadString(input.rawPayload.cwd),
+    route: contract.route,
+    updatedAt: input.receivedAt ?? new Date().toISOString()
+  };
+  await writeTaskContract(paths.contractPath, contract, { overwrite: true });
+  await writeJsonFile(paths.bindingPath, binding);
+  const context = [
+    `EvoDev routed this request before ${formatHookTargetName(input.target)} execution.`,
+    `Task Contract: ${paths.contractPath}`,
+    `Mode: ${contract.route.mode ?? "unknown"}`,
+    `Workflow: ${contract.route.workflowId ?? "none"}`,
+    `Reason: ${contract.route.rationale}`,
+    "Follow the contract scope, anti-criteria, and verification plan before finishing."
+  ].join(" ");
+  return createRuntimeResult(input, hookOutput(input.event.type, { additionalContext: context }), {
+    summary: "User prompt routed through Task Contract.",
+    stateWrites: [paths.contractPath, paths.bindingPath]
+  });
+}
+async function handlePreToolUse(input) {
+  const contract = await readActiveContract(input.homeDir, input.rawPayload);
+  const commandClass = typeof input.event.payload.metadata.commandClass === "string" ? input.event.payload.metadata.commandClass : undefined;
+  const protectedPath = findProtectedPath(input.rawPayload);
+  if (contract === null) {
+    return createRuntimeResult(input, hookOutput(input.event.type, {
+      permissionDecision: "ask",
+      permissionDecisionReason: "EvoDev requires an active Task Contract before tool use.",
+      additionalContext: "Submit the user prompt through UserPromptSubmit to create the Task Contract first."
+    }), { summary: "Tool use requires user confirmation because no active contract exists." });
+  }
+  if (protectedPath !== null) {
+    return createRuntimeResult(input, hookOutput(input.event.type, {
+      permissionDecision: "deny",
+      permissionDecisionReason: `EvoDev blocked access to protected project asset: ${protectedPath}`
+    }), { summary: "Protected path access denied." });
+  }
+  if (commandClass === "delete" || commandClass === "publish" || commandClass === "credential-sensitive" || commandClass === "path-escaping") {
+    return createRuntimeResult(input, hookOutput(input.event.type, {
+      permissionDecision: "deny",
+      permissionDecisionReason: `EvoDev blocked high-risk tool action: ${commandClass}`
+    }), { summary: "High-risk tool action denied." });
+  }
+  if (commandClass === "network" || commandClass === "unknown" || commandClass === "write") {
+    return createRuntimeResult(input, hookOutput(input.event.type, {
+      permissionDecision: "ask",
+      permissionDecisionReason: `EvoDev requires confirmation for ${commandClass} action under ${contract.route.mode ?? "unrouted"} mode.`,
+      additionalContext: `Active Task Contract: ${contract.taskId}. Confirm scope before continuing.`
+    }), { summary: "Tool use requires user confirmation." });
+  }
+  return createRuntimeResult(input, hookOutput(input.event.type, {
+    permissionDecision: "allow",
+    permissionDecisionReason: `EvoDev allowed ${commandClass ?? "metadata-only"} action under Task Contract ${contract.taskId}.`
+  }), { summary: "Tool use allowed by EvoDev policy." });
+}
+async function handlePostToolUse(input) {
+  const contract = await readActiveContract(input.homeDir, input.rawPayload);
+  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
+  if (contract === null || binding?.contractPath === null || binding?.contractPath === undefined) {
+    return handleAdditionalContext(input, input.event.type);
+  }
+  const status = optionalPayloadNumber(input.rawPayload.exit_code ?? input.rawPayload.exitCode);
+  const nextContract = {
+    ...contract,
+    evidence: {
+      metadataOnly: true,
+      items: [
+        ...contract.evidence.items,
+        {
+          type: "command-result",
+          id: input.event.eventId,
+          status: status === 0 ? "pass" : status === null ? "unknown" : "fail",
+          summary: input.event.payload.summary,
+          rawOutputStored: false,
+          sourceContentStored: false
+        }
+      ]
+    }
+  };
+  await writeTaskContract(binding.contractPath, nextContract, { overwrite: true });
+  return createRuntimeResult(input, hookOutput(input.event.type, {
+    additionalContext: `EvoDev recorded metadata-only evidence for Task Contract ${contract.taskId}. Raw output was not stored.`
+  }), {
+    summary: "Post-tool metadata evidence recorded.",
+    stateWrites: [binding.contractPath]
+  });
+}
+async function handleCompletionGate(input) {
+  const contract = await readActiveContract(input.homeDir, input.rawPayload);
+  if (contract === null)
+    return handleAdditionalContext(input, input.event.type);
+  const stopHookActive = input.rawPayload.stop_hook_active === true;
+  if (!stopHookActive && contract.route.mode === "rigorous" && contract.evidence.items.length === 0) {
+    return createRuntimeResult(input, {
+      decision: "block",
+      reason: "EvoDev rigorous mode requires metadata-only evidence before stopping.",
+      ...hookOutput(input.event.type, {
+        additionalContext: "Run the required verification or record metadata-only evidence before finishing."
+      })
+    }, { summary: "Completion blocked until evidence exists." });
+  }
+  return createRuntimeResult(input, hookOutput(input.event.type, {
+    additionalContext: `EvoDev completion gate checked Task Contract ${contract.taskId}. Evidence items: ${contract.evidence.items.length}.`
+  }), { summary: "Completion gate checked." });
+}
+async function handlePreCompact(input) {
+  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
+  return createRuntimeResult(input, hookOutput(input.event.type, {
+    additionalContext: binding?.contractPath ? `Preserve EvoDev Task Contract reference across compaction: ${binding.contractPath}` : "No EvoDev Task Contract is active for this session."
+  }), { summary: "PreCompact context prepared." });
+}
+async function handleSessionEnd(input) {
+  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
+  if (binding === null)
+    return createRuntimeResult(input, null, { summary: "No session state to close." });
+  const nextBinding = {
+    ...binding,
+    updatedAt: input.receivedAt ?? new Date().toISOString()
+  };
+  const paths = resolveHookRuntimeSessionPaths({
+    homeDir: input.homeDir,
+    sessionKey: binding.sessionKey
+  });
+  await writeJsonFile(paths.bindingPath, nextBinding);
+  return createRuntimeResult(input, null, {
+    summary: "Session state updated for SessionEnd.",
+    stateWrites: [paths.bindingPath]
+  });
+}
+function handleAdditionalContext(input, eventName) {
+  return Promise.resolve(createRuntimeResult(input, hookOutput(eventName, {
+    additionalContext: `EvoDev processed ${eventName} as metadata-only hook context.`
+  }), { summary: `${eventName} processed as metadata-only context.` }));
+}
+function createRuntimeResult(input, output, options) {
+  return {
+    target: input.target,
+    event: input.event.type,
+    enabled: true,
+    output,
+    stateWrites: options.stateWrites ?? [],
+    summary: options.summary
+  };
+}
+function hookOutput(eventName, output) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: eventName,
+      ...output
+    }
+  };
+}
+function createHookTaskContract(input, classification) {
+  const sessionKey = resolveHookSessionKey(input.rawPayload);
+  const targetName = formatHookTargetName(input.target);
+  const contract = createTaskContract({
+    title: `${targetName} hook task ${sessionKey}`,
+    summary: `${targetName} prompt classified as ${classification.kind}; raw prompt not stored.`,
+    projectId: null
+  });
+  return {
+    ...contract,
+    currentState: {
+      summary: `UserPromptSubmit received through ${targetName} hooks; raw prompt omitted.`,
+      evidenceRefs: []
+    },
+    targetState: {
+      summary: `Complete the ${classification.kind} task through EvoDev-controlled workflow.`,
+      nonGoals: ["Do not store raw prompts, transcripts, source content, secrets, or raw output."],
+      constraints: [
+        `prompt-kind:${classification.kind}`,
+        ...classification.riskTerms.map((term) => `risk:${term}`)
+      ]
+    },
+    scope: {
+      ...contract.scope,
+      requiresUserConfirmation: classification.riskTerms
+    },
+    context: {
+      ...contract.context,
+      assumptions: [
+        `hook-session:${sessionKey}`,
+        `cwd:${optionalPayloadString(input.rawPayload.cwd) ?? "unknown"}`
+      ],
+      openQuestions: classification.needsClarification ? ["User request may need clarification before broad changes."] : []
+    }
+  };
+}
+function formatHookTargetName(target) {
+  return target === "codex" ? "Codex" : "Claude";
+}
+function classifyUserPrompt(value) {
+  const text = typeof value === "string" ? value.toLowerCase() : "";
+  const riskTerms = [
+    "security",
+    "release",
+    "publish",
+    "hook",
+    "memory",
+    "learning",
+    "secret",
+    "privacy"
+  ].filter((term) => text.includes(term));
+  let kind = "feature";
+  if (/\bbug|fix|error|failed|failure\b/.test(text))
+    kind = "bugfix";
+  if (/\brefactor|migration|migrate\b/.test(text))
+    kind = "refactor";
+  if (/\breview|audit\b/.test(text))
+    kind = "review";
+  if (/\btest|coverage\b/.test(text))
+    kind = "test";
+  if (/\bdoc|readme|guide\b/.test(text))
+    kind = "docs";
+  if (riskTerms.includes("security") || riskTerms.includes("privacy"))
+    kind = "security";
+  if (riskTerms.includes("release") || riskTerms.includes("publish"))
+    kind = "release";
+  return {
+    kind,
+    riskTerms,
+    needsClarification: text.trim().length < 12 || /\bmaybe|unclear|not sure\b/.test(text)
+  };
+}
+async function readActiveContract(homeDir, payload) {
+  const binding = await readSessionBinding(homeDir, payload);
+  if (binding?.contractPath === null || binding?.contractPath === undefined)
+    return null;
+  try {
+    return JSON.parse(await readFile4(binding.contractPath, "utf8"));
+  } catch (error) {
+    if (isNotFoundError(error))
+      return null;
+    throw error;
+  }
+}
+async function readSessionBinding(homeDir, payload) {
+  const sessionKey = resolveHookSessionKey(payload);
+  const paths = resolveHookRuntimeSessionPaths({ homeDir, sessionKey });
+  try {
+    return JSON.parse(await readFile4(paths.bindingPath, "utf8"));
+  } catch (error) {
+    if (isNotFoundError(error))
+      return null;
+    throw error;
+  }
+}
+function resolveHookSessionKey(payload) {
+  const sessionId = optionalPayloadString(payload.session_id ?? payload.sessionId);
+  const cwd = optionalPayloadString(payload.cwd);
+  const source = sessionId ?? cwd ?? "local";
+  return `session-${createHash("sha256").update(source).digest("hex").slice(0, 16)}`;
+}
+async function writeJsonFile(path, value) {
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function findProtectedPath(payload) {
+  const candidates = collectStringValues(payload).filter((value) => value.length < 500);
+  for (const candidate of candidates) {
+    if (candidate === "CLAUDE.md" || candidate === "AGENTS.md" || candidate.includes("/CLAUDE.md") || candidate.includes("/AGENTS.md") || candidate.includes(".claude/") || candidate.includes(".codex/")) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function collectStringValues(value) {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value.flatMap((item) => collectStringValues(item));
+  if (isRecord3(value))
+    return Object.values(value).flatMap((item) => collectStringValues(item));
+  return [];
+}
+function optionalPayloadString(value) {
+  return typeof value === "string" && value.length > 0 ? value.slice(0, 300) : null;
+}
+function optionalPayloadNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function normalizeHookEventType(type, warnings) {
+  if (type === "AgentStop") {
+    warnings.push("Legacy AgentStop event normalized to SubagentStop.");
+    return "SubagentStop";
+  }
+  if (CANONICAL_HOOK_EVENT_TYPES.includes(type))
+    return type;
+  throw new Error(`Unsupported hook event type: ${type}`);
+}
+function parseHookTargetSettings(value, defaults, target) {
+  const targets = isRecord3(value) ? value : {};
+  const targetSettings = isRecord3(targets[target]) ? targets[target] : {};
+  const events = isRecord3(targetSettings.events) ? targetSettings.events : {};
+  const parsedEvents = { ...defaults.events };
+  for (const eventType of CANONICAL_HOOK_EVENT_TYPES) {
+    parsedEvents[eventType] = optionalBoolean(events[eventType], defaults.events[eventType], `hooks.targets.${target}.events.${eventType}`);
+  }
+  return {
+    enabled: optionalBoolean(targetSettings.enabled, defaults.enabled, `hooks.targets.${target}.enabled`),
+    events: parsedEvents
+  };
+}
+function extractMetadata(type, payload, redactions) {
+  const metadata = {
+    rawContentIncluded: false
+  };
+  const toolInput = isRecord3(payload.tool_input) ? payload.tool_input : isRecord3(payload.toolInput) ? payload.toolInput : {};
+  const toolName = optionalSanitizedString(payload.tool_name ?? payload.toolName, redactions);
+  if (toolName !== null)
+    metadata.toolName = toolName;
+  const rawCommand = typeof payload.command === "string" ? payload.command : typeof toolInput.command === "string" ? toolInput.command : undefined;
+  const command = optionalSanitizedString(rawCommand, redactions, { classifyOnly: true });
+  if (rawCommand !== undefined)
+    redactions.push("raw-command");
+  if (type === "PreToolUse" || type === "PostToolUse" || type === "PostToolUseFailure" || type === "PermissionRequest" || type === "PermissionDenied") {
+    const commandClass = classifyCommandRisk(command ?? undefined);
+    metadata.commandClass = commandClass;
+  }
+  const exitCode = optionalNumber(payload.exit_code ?? payload.exitCode);
+  if (exitCode !== null)
+    metadata.exitCode = exitCode;
+  const status = optionalSanitizedString(payload.status, redactions);
+  if (status !== null)
+    metadata.status = status;
+  const redactedPrompt = payload.prompt ?? payload.userPrompt;
+  if (redactedPrompt !== undefined)
+    redactions.push("raw-prompt");
+  const rawOutput = payload.stdout ?? payload.stderr ?? payload.output;
+  if (rawOutput !== undefined)
+    redactions.push("raw-command-output");
+  return metadata;
+}
+function decideHookPolicy(commandClass) {
+  if (commandClass === "delete" || commandClass === "network" || commandClass === "publish" || commandClass === "credential-sensitive" || commandClass === "path-escaping" || commandClass === "unknown") {
+    return {
+      action: "ask-user",
+      reason: `Command risk requires explicit confirmation: ${commandClass}`,
+      requiresUserConfirmation: true
+    };
+  }
+  if (commandClass === "write") {
+    return {
+      action: "warn",
+      reason: "Write-like command requires scope review.",
+      requiresUserConfirmation: true
+    };
+  }
+  return {
+    action: "allow",
+    reason: "No policy violation detected.",
+    requiresUserConfirmation: false
+  };
+}
+function summarizeEvent(type, metadata) {
+  if (type === "PreToolUse")
+    return `Tool use requested (${metadata.commandClass ?? "unknown"}).`;
+  if (type === "PostToolUse")
+    return "Tool use completed with metadata-only result.";
+  if (type === "UserPromptSubmit")
+    return "User prompt submitted; raw prompt redacted.";
+  if (type === "SubagentStop")
+    return "Subagent stopped; transcript omitted.";
+  return `${type} received; metadata-only dry-run.`;
+}
+function optionalSanitizedString(value, redactions, options = {}) {
+  if (typeof value !== "string" || value.length === 0)
+    return null;
+  if (SENSITIVE_TEXT_PATTERN2.test(value) || SOURCE_LIKE_PATTERN.test(value)) {
+    redactions.push(options.classifyOnly ? "sensitive-command" : "sensitive-text");
+    return options.classifyOnly ? value : "[redacted]";
+  }
+  return value.slice(0, 120);
+}
+function sanitizeScalar(value, redactions) {
+  return optionalSanitizedString(value, redactions) ?? "unknown";
+}
+function stableEventId(pluginId, type, sessionIdHash) {
+  const stableSessionPart = sessionIdHash ?? "local";
+  return `hook-${pluginId}-${type}-${stableSessionPart}`.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 100);
+}
+function hashOptionalIdentifier(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return null;
+  return `sha256-${createHash("sha256").update(value).digest("hex").slice(0, 16)}`;
+}
+function optionalBoolean(value, fallback, path) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value !== "boolean")
+    throw new Error(`Invalid ${path}; expected boolean.`);
+  return value;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function formatMetadataValue(value) {
+  return Array.isArray(value) ? value.join(",") : String(value);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/core/src/config/settings.ts
+function createDefaultSettings(os = process.platform) {
+  return {
+    version: 1,
+    platform: {
+      os
+    },
+    plugins: {
+      claude: {
+        enabled: true,
+        autoSyncSkills: true,
+        autoSyncAgents: true
+      },
+      codex: {
+        enabled: false
+      }
+    },
+    assets: {
+      skills: {
+        enabled: true
+      },
+      agents: {
+        enabled: true
+      }
+    },
+    doctor: {
+      lastRunAt: null
+    },
+    hooks: createDefaultHookSettings()
+  };
+}
+function mergeSettings(existing, defaults = createDefaultSettings()) {
+  const merged = {
+    ...defaults,
+    ...existing,
+    platform: {
+      ...defaults.platform,
+      ...existing.platform
+    },
+    plugins: {
+      claude: {
+        ...defaults.plugins.claude,
+        ...existing.plugins?.claude
+      },
+      codex: {
+        ...defaults.plugins.codex,
+        ...existing.plugins?.codex
+      }
+    },
+    assets: {
+      skills: {
+        ...defaults.assets.skills,
+        ...existing.assets?.skills
+      },
+      agents: {
+        ...defaults.assets.agents,
+        ...existing.assets?.agents
+      }
+    },
+    doctor: {
+      ...defaults.doctor,
+      ...existing.doctor
+    },
+    hooks: existing.hooks ?? defaults.hooks
+  };
+  return parseSettings(merged);
+}
+function parseSettings(value) {
+  const root = expectRecord3(value, "settings");
+  const version = root.version;
+  if (version !== 1) {
+    throw new EvoDevConfigError("Invalid settings.version; expected 1");
+  }
+  const platform = expectRecord3(root.platform, "settings.platform");
+  const plugins = expectRecord3(root.plugins, "settings.plugins");
+  const assets = expectRecord3(root.assets, "settings.assets");
+  const doctor = expectRecord3(root.doctor, "settings.doctor");
+  const parsed = {
+    version: 1,
+    platform: {
+      os: expectString2(platform.os, "settings.platform.os")
+    },
+    plugins: {
+      claude: parsePluginSettings(plugins.claude, "settings.plugins.claude"),
+      codex: parsePluginSettings(plugins.codex, "settings.plugins.codex")
+    },
+    assets: {
+      skills: {
+        enabled: expectBoolean(expectRecord3(assets.skills, "settings.assets.skills").enabled, "settings.assets.skills.enabled")
+      },
+      agents: {
+        enabled: expectBoolean(expectRecord3(assets.agents, "settings.assets.agents").enabled, "settings.assets.agents.enabled")
+      }
+    },
+    doctor: {
+      lastRunAt: expectNullableString(doctor.lastRunAt, "settings.doctor.lastRunAt")
+    },
+    hooks: parseHookSettings(root.hooks)
+  };
+  return parsed;
+}
+function parsePluginSettings(value, path) {
+  const input = expectRecord3(value, path);
+  const parsed = {
+    enabled: expectBoolean(input.enabled, `${path}.enabled`)
+  };
+  if (input.autoSyncSkills !== undefined) {
+    parsed.autoSyncSkills = expectBoolean(input.autoSyncSkills, `${path}.autoSyncSkills`);
+  }
+  if (input.autoSyncAgents !== undefined) {
+    parsed.autoSyncAgents = expectBoolean(input.autoSyncAgents, `${path}.autoSyncAgents`);
+  }
+  return parsed;
+}
+function expectRecord3(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected object, got ${describeType2(value)}`);
+  }
+  return value;
+}
+function expectString2(value, path) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected non-empty string`);
+  }
+  return value;
+}
+function expectNullableString(value, path) {
+  if (value === null || typeof value === "string") {
+    return value;
+  }
+  throw new EvoDevConfigError(`Invalid ${path}; expected string or null`);
+}
+function expectBoolean(value, path) {
+  if (typeof value !== "boolean") {
+    throw new EvoDevConfigError(`Invalid ${path}; expected boolean`);
+  }
+  return value;
+}
+// packages/core/src/config/state.ts
+function createDefaultInstallState() {
+  return {
+    version: 1,
+    initializedAt: null,
+    initializedBy: "evodev",
+    selectedPlugins: []
+  };
+}
+function createDefaultSyncState() {
+  return {
+    version: 1,
+    lastSyncAt: null,
+    targets: {}
+  };
+}
+function parseInstallState(value) {
+  const root = expectRecord4(value, "install state");
+  if (root.version !== 1) {
+    throw new EvoDevConfigError("Invalid install state.version; expected 1");
+  }
+  if (root.initializedBy !== "evodev") {
+    throw new EvoDevConfigError("Invalid install state.initializedBy; expected evodev");
+  }
+  if (!Array.isArray(root.selectedPlugins) || !root.selectedPlugins.every((plugin) => typeof plugin === "string")) {
+    throw new EvoDevConfigError("Invalid install state.selectedPlugins; expected string array");
+  }
+  return {
+    version: 1,
+    initializedAt: expectNullableString2(root.initializedAt, "install state.initializedAt"),
+    initializedBy: "evodev",
+    selectedPlugins: [...root.selectedPlugins]
+  };
+}
+function parseSyncState(value) {
+  const root = expectRecord4(value, "sync state");
+  if (root.version !== 1) {
+    throw new EvoDevConfigError("Invalid sync state.version; expected 1");
+  }
+  const targets = expectRecord4(root.targets, "sync state.targets");
+  const parsedTargets = {};
+  for (const [pluginId, state] of Object.entries(targets)) {
+    parsedTargets[pluginId] = parsePluginSyncState(state, `sync state.targets.${pluginId}`);
+  }
+  return {
+    version: 1,
+    lastSyncAt: expectNullableString2(root.lastSyncAt, "sync state.lastSyncAt"),
+    targets: parsedTargets
+  };
+}
+function parsePluginSyncState(value, path) {
+  const root = expectRecord4(value, path);
+  const status = root.status;
+  if (status !== "success" && status !== "partial" && status !== "failed" && status !== "never-run") {
+    throw new EvoDevConfigError(`Invalid ${path}.status; expected success, partial, failed, or never-run`);
+  }
+  return {
+    skills: expectNonNegativeInteger(root.skills, `${path}.skills`),
+    agents: expectNonNegativeInteger(root.agents, `${path}.agents`),
+    status
+  };
+}
+function expectRecord4(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected object, got ${describeType2(value)}`);
+  }
+  return value;
+}
+function expectNullableString2(value, path) {
+  if (value === null || typeof value === "string") {
+    return value;
+  }
+  throw new EvoDevConfigError(`Invalid ${path}; expected string or null`);
+}
+function expectNonNegativeInteger(value, path) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected non-negative integer`);
+  }
+  return value;
+}
+// packages/core/src/config/store.ts
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+function createCoreConfigStore(homeDir) {
+  const paths = resolveEvoDevPaths(homeDir);
+  return {
+    paths,
+    async ensureBaseDirs() {
+      await mkdir3(paths.stateDir, { recursive: true });
+    },
+    async readSettings() {
+      return readJsonFile(paths.settingsPath, parseSettings);
+    },
+    async writeSettings(settings) {
+      await writeJsonFile2(paths.settingsPath, parseSettings(settings));
+    },
+    async mergeAndWriteSettings(input) {
+      const current = await readJsonFileOrDefault(paths.settingsPath, parseSettings, createDefaultSettings());
+      const merged = mergeSettings(input, current);
+      await writeJsonFile2(paths.settingsPath, merged);
+      return merged;
+    },
+    async readRegistry() {
+      return readJsonFile(paths.registryPath, parseRegistry);
+    },
+    async writeRegistry(registry) {
+      await writeJsonFile2(paths.registryPath, parseRegistry(registry));
+    },
+    async readInstallState() {
+      return readJsonFile(paths.installStatePath, parseInstallState);
+    },
+    async writeInstallState(state) {
+      await writeJsonFile2(paths.installStatePath, parseInstallState(state));
+    },
+    async readSyncState() {
+      return readJsonFile(paths.syncStatePath, parseSyncState);
+    },
+    async writeSyncState(state) {
+      await writeJsonFile2(paths.syncStatePath, parseSyncState(state));
+    }
+  };
+}
+async function initializeCoreConfig(homeDir) {
+  const store = createCoreConfigStore(homeDir);
+  await store.ensureBaseDirs();
+  await writeIfMissing(store.paths.settingsPath, createDefaultSettings());
+  await writeIfMissing(store.paths.registryPath, createDefaultRegistry());
+  await writeIfMissing(store.paths.installStatePath, createDefaultInstallState());
+  await writeIfMissing(store.paths.syncStatePath, createDefaultSyncState());
+  return store;
+}
+async function readJsonFile(filePath, parse) {
+  let raw;
+  try {
+    raw = await readFile5(filePath, "utf8");
+  } catch (error) {
+    throw new EvoDevConfigError(`Cannot read config file (${describeFileError2(error)})`, filePath);
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevConfigError(`Invalid JSON (${describeFileError2(error)})`, filePath);
+  }
+  try {
+    return parse(json);
+  } catch (error) {
+    if (error instanceof EvoDevConfigError) {
+      throw new EvoDevConfigError(error.message, filePath);
+    }
+    throw error;
+  }
+}
+async function readJsonFileOrDefault(filePath, parse, fallback) {
+  try {
+    return await readJsonFile(filePath, parse);
+  } catch (error) {
+    if (error instanceof EvoDevConfigError && error.message.includes("ENOENT")) {
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function writeIfMissing(filePath, value) {
+  try {
+    await readFile5(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      await writeJsonFile2(filePath, value);
+      return;
+    }
+    throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError2(error)})`, filePath);
+  }
+}
+async function writeJsonFile2(filePath, value) {
+  await mkdir3(dirname3(filePath), { recursive: true });
+  await writeFile3(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function describeFileError2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+// packages/core/src/daemon/index.ts
+import { randomBytes } from "node:crypto";
+import { mkdir as mkdir5, readFile as readFile7, readdir as readdir3, rm, stat as stat4, writeFile as writeFile5 } from "node:fs/promises";
+import { createServer } from "node:http";
+import { dirname as dirname5, join as join5 } from "node:path";
+
+// packages/core/src/observability/index.ts
+import { mkdir as mkdir4, readFile as readFile6, readdir as readdir2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname4, join as join4 } from "node:path";
+var EVENT_TYPE_TO_DIR = {
+  "verification.completed": "verification",
+  "workflow.step.planned": "workflows",
+  "test-run.completed": "tests",
+  "review.finding": "reviews"
+};
+var FORBIDDEN_RAW_KEYS2 = new Set([
+  "commandoutput",
+  "memorybodies",
+  "memorybody",
+  "promptbody",
+  "prompttext",
+  "rawcommandoutput",
+  "rawoutput",
+  "rawpayload",
+  "secret",
+  "secretvalue",
+  "source",
+  "sourcebody",
+  "sourcecode",
+  "sourcecontent",
+  "sourcetext",
+  "stderr",
+  "stdout",
+  "transcript",
+  "transcriptbody",
+  "transcripttext"
+]);
+var SENSITIVE_TEXT_PATTERN3 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw source|raw prompt)\b/i;
+function createObservabilityEvent(input) {
+  const event = {
+    version: 1,
+    eventId: sanitizeId2(input.eventId),
+    type: input.type,
+    timestamp: input.timestamp ?? new Date().toISOString(),
+    scope: input.scope,
+    privacy: {
+      classification: "local-private",
+      metadataOnly: true,
+      rawPayloadStored: false,
+      rawOutputStored: false,
+      sourceContentStored: false,
+      promptStored: false
+    },
+    summary: sanitizeText2(input.summary),
+    data: sanitizeData(input.data ?? {})
+  };
+  validateObservabilityEvent(event);
+  return event;
+}
+function validateObservabilityEvent(event) {
+  if (event.version !== 1)
+    throw new Error("Observability event version must be 1.");
+  if (event.privacy.metadataOnly !== true)
+    throw new Error("Observability event must be metadata-only.");
+  if (event.privacy.rawPayloadStored !== false || event.privacy.rawOutputStored !== false || event.privacy.sourceContentStored !== false || event.privacy.promptStored !== false) {
+    throw new Error("Observability event cannot store raw payload/output/source/prompt.");
+  }
+  assertNoForbiddenContent(event);
+}
+function resolveObservabilityStorePaths(homeDir, type) {
+  const rootDir = join4(homeDir, ".evodev", "OBSERVABILITY", EVENT_TYPE_TO_DIR[type]);
+  return { rootDir, eventsPath: join4(rootDir, "events.jsonl") };
+}
+async function appendObservabilityEvent(homeDir, event) {
+  validateObservabilityEvent(event);
+  const paths = resolveObservabilityStorePaths(homeDir, event.type);
+  await mkdir4(dirname4(paths.eventsPath), { recursive: true });
+  await writeFile4(paths.eventsPath, `${JSON.stringify(event)}
+`, { encoding: "utf8", flag: "a" });
+  return paths.eventsPath;
+}
+async function listObservabilityEvents(homeDir, type) {
+  const eventTypes = type === undefined ? Object.keys(EVENT_TYPE_TO_DIR) : [type];
+  const events = [];
+  for (const eventType of eventTypes) {
+    const path = resolveObservabilityStorePaths(homeDir, eventType).eventsPath;
+    if (!await pathExists3(path))
+      continue;
+    const lines = (await readFile6(path, "utf8")).split(`
+`).filter(Boolean);
+    for (const line of lines) {
+      const event = JSON.parse(line);
+      validateObservabilityEvent(event);
+      events.push(event);
+    }
+  }
+  return events.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
+}
+async function dryRunObservabilityRetentionCleanup(homeDir) {
+  const root = join4(homeDir, ".evodev", "OBSERVABILITY");
+  const candidates = [];
+  if (!await pathExists3(root))
+    return { candidates, totalBytes: 0 };
+  for (const file of await collectJsonlFiles(root)) {
+    const fileStat = await stat3(file);
+    candidates.push({ path: file, sizeBytes: fileStat.size, reason: "observability-jsonl" });
+  }
+  return {
+    candidates,
+    totalBytes: candidates.reduce((sum, candidate) => sum + candidate.sizeBytes, 0)
+  };
+}
+function formatObservabilityEvents(events) {
+  return [
+    "EvoDev observability events",
+    "",
+    ...events.map((event) => `- ${event.timestamp} ${event.type} ${event.eventId}: ${event.summary}`)
+  ].join(`
+`);
+}
+function formatRetentionDryRun(result) {
+  return [
+    "EvoDev observability cleanup dry-run",
+    "",
+    `Candidates: ${result.candidates.length}`,
+    `Total bytes: ${result.totalBytes}`,
+    ...result.candidates.map((candidate) => `- ${candidate.path} (${candidate.sizeBytes} bytes, ${candidate.reason})`)
+  ].join(`
+`);
+}
+function sanitizeData(data) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(data)) {
+    const normalizedKey = normalizeKey(key);
+    if (FORBIDDEN_RAW_KEYS2.has(normalizedKey)) {
+      throw new Error(`Observability data contains forbidden raw field: ${key}`);
+    }
+    if (typeof value === "string")
+      sanitized[key] = sanitizeText2(value);
+    else if (Array.isArray(value))
+      sanitized[key] = value.map(sanitizeText2);
+    else
+      sanitized[key] = value;
+  }
+  return sanitized;
+}
+function assertNoForbiddenContent(value) {
+  if (typeof value === "string") {
+    if (value === "local-private")
+      return;
+    if (SENSITIVE_TEXT_PATTERN3.test(value))
+      throw new Error("Observability event contains sensitive content.");
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertNoForbiddenContent(item);
+    return;
+  }
+  if (typeof value !== "object" || value === null)
+    return;
+  for (const [key, child] of Object.entries(value)) {
+    const normalizedKey = normalizeKey(key);
+    if (FORBIDDEN_RAW_KEYS2.has(normalizedKey)) {
+      throw new Error(`Observability event contains forbidden raw field: ${key}`);
+    }
+    assertNoForbiddenContent(child);
+  }
+}
+async function collectJsonlFiles(root) {
+  const entries = await readdir2(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const path = join4(root, entry.name);
+    if (entry.isDirectory())
+      files.push(...await collectJsonlFiles(path));
+    if (entry.isFile() && entry.name.endsWith(".jsonl"))
+      files.push(path);
+  }
+  return files.sort();
+}
+async function pathExists3(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function sanitizeText2(value) {
+  return value.replace(SENSITIVE_TEXT_PATTERN3, "[redacted]").slice(0, 500);
+}
+function sanitizeId2(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 80) || "event";
+}
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+// packages/core/src/daemon/index.ts
+var DEFAULT_PORT = 37645;
+var SENSITIVE_TEXT_PATTERN4 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw output|raw source|raw prompt|transcript|stdout|stderr)\b/i;
+function resolveDaemonPaths(homeDir) {
+  const rootDir = join5(homeDir, ".evodev", "STATE", "daemon");
+  return { rootDir, lockPath: join5(rootDir, "lock.json"), tokenPath: join5(rootDir, "token") };
+}
+function validateDaemonBindHost(host) {
+  if (host === "127.0.0.1" || host === "localhost")
+    return host;
+  throw new Error("Daemon bind host must be local-only: 127.0.0.1 or localhost.");
+}
+function createDaemonStartPlan(input) {
+  const host = validateDaemonBindHost(input.host ?? "127.0.0.1");
+  const port = input.port ?? DEFAULT_PORT;
+  if (!Number.isInteger(port) || port <= 0 || port > 65535)
+    throw new Error("Invalid daemon port.");
+  const paths = resolveDaemonPaths(input.homeDir);
+  return {
+    host,
+    port,
+    paths,
+    writes: [paths.lockPath, paths.tokenPath],
+    warnings: ["Daemon is disabled by default and starts only via explicit daemon start."]
+  };
+}
+async function writeDaemonState(input) {
+  const plan = createDaemonStartPlan(input);
+  if (await readDaemonLock(input.homeDir) !== null) {
+    throw new Error("Existing daemon lock found; refusing to overwrite daemon state.");
+  }
+  const token = createDaemonToken();
+  const now = input.now ?? new Date().toISOString();
+  const lock = {
+    version: 1,
+    component: "evodev-daemon",
+    pid: input.pid ?? process.pid,
+    host: plan.host,
+    port: plan.port,
+    startedAt: now,
+    heartbeatAt: now,
+    status: "running",
+    tokenPath: plan.paths.tokenPath,
+    versionText: input.versionText ?? "evodev 0.0.1-alpha"
+  };
+  await mkdir5(dirname5(plan.paths.lockPath), { recursive: true });
+  await writeFile5(plan.paths.tokenPath, `${token}
+`, {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  await writeFile5(plan.paths.lockPath, `${JSON.stringify(lock, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  return { lock, token, paths: plan.paths };
+}
+async function readDaemonLock(homeDir) {
+  const paths = resolveDaemonPaths(homeDir);
+  if (!await pathExists4(paths.lockPath))
+    return null;
+  const lock = JSON.parse(await readFile7(paths.lockPath, "utf8"));
+  if (lock.version !== 1 || lock.component !== "evodev-daemon")
+    throw new Error("Invalid daemon lock.");
+  return lock;
+}
+async function readDaemonToken(homeDir) {
+  const paths = resolveDaemonPaths(homeDir);
+  if (!await pathExists4(paths.tokenPath))
+    return null;
+  return (await readFile7(paths.tokenPath, "utf8")).trim();
+}
+async function cleanupDaemonState(homeDir, token) {
+  const paths = resolveDaemonPaths(homeDir);
+  const currentToken = await readDaemonToken(homeDir);
+  if (currentToken === null || currentToken !== token)
+    throw new Error("Invalid daemon token.");
+  const lock = await readDaemonLock(homeDir);
+  if (lock === null || lock.component !== "evodev-daemon")
+    throw new Error("Missing valid daemon lock.");
+  await rm(paths.lockPath, { force: true });
+  await rm(paths.tokenPath, { force: true });
+  return [paths.lockPath, paths.tokenPath];
+}
+async function handleDaemonRequest(input) {
+  const warnings = [];
+  if (!isAllowedLocalOrigin(input.origin ?? null)) {
+    return { status: 403, body: { ok: false, data: { error: "forbidden origin" }, warnings } };
+  }
+  if (input.path === "/health" && input.method === "GET") {
+    return ok({ status: "ok", version: 1, metadataOnly: true }, warnings);
+  }
+  const auth = await authorize(input.homeDir, input.token ?? null);
+  if (!auth.ok)
+    return { status: 401, body: { ok: false, data: { error: "unauthorized" }, warnings } };
+  if (input.path === "/shutdown" && input.method === "POST") {
+    const removed = await cleanupDaemonState(input.homeDir, input.token ?? "");
+    return ok({ stopped: true, removed }, warnings);
+  }
+  if (input.method !== "GET")
+    return notFound(warnings);
+  if (input.path === "/tasks")
+    return ok(await collectTaskSummaries(input.homeDir, warnings), warnings);
+  if (input.path === "/observability/events")
+    return ok(await collectObservabilitySummaries(input.homeDir, warnings), warnings);
+  if (input.path === "/memory/candidates")
+    return ok(await collectLearningCandidateSummaries(input.homeDir, warnings), warnings);
+  if (input.path === "/projects")
+    return ok(await collectDirectorySummaries(join5(input.homeDir, ".evodev", "PROJECTS"), warnings), warnings);
+  if (input.path === "/packs")
+    return ok(await collectDirectorySummaries(join5(input.homeDir, ".evodev", "PACKS"), warnings), warnings);
+  if (input.path === "/runs")
+    return ok([], warnings);
+  if (input.path === "/agents")
+    return ok([], warnings);
+  return notFound(warnings);
+}
+async function runDaemonForeground(input) {
+  const state = await writeDaemonState({
+    homeDir: input.homeDir,
+    host: input.host,
+    port: input.port
+  });
+  const server = createServer(async (request, response) => {
+    try {
+      const url = new URL(request.url ?? "/", `http://${state.lock.host}:${state.lock.port}`);
+      const result = await handleDaemonRequest({
+        method: request.method ?? "GET",
+        path: url.pathname,
+        token: readHeader(request, "authorization")?.replace(/^Bearer\s+/i, "") ?? readHeader(request, "x-evodev-token") ?? url.searchParams.get("token"),
+        homeDir: input.homeDir,
+        origin: readHeader(request, "origin")
+      });
+      response.writeHead(result.status, { "content-type": "application/json" });
+      response.end(JSON.stringify(result.body));
+      if (url.pathname === "/shutdown" && result.status === 200) {
+        server.close();
+      }
+    } catch (error) {
+      response.writeHead(500, { "content-type": "application/json" });
+      response.end(JSON.stringify({
+        ok: false,
+        data: { error: error instanceof Error ? error.message : String(error) },
+        warnings: []
+      }));
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve2();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(state.lock.port, state.lock.host);
+  });
+  input.write?.(`Daemon listening on ${state.lock.host}:${state.lock.port}; token path: ${state.paths.tokenPath}`);
+  await new Promise((resolve2, reject) => {
+    server.once("close", resolve2);
+    server.once("error", reject);
+  });
+}
+function readHeader(request, name) {
+  const value = request.headers[name.toLowerCase()];
+  if (Array.isArray(value))
+    return value[0] ?? null;
+  return value ?? null;
+}
+function createDaemonToken() {
+  return randomBytes(32).toString("hex");
+}
+async function authorize(homeDir, token) {
+  const expected = await readDaemonToken(homeDir);
+  return { ok: expected !== null && token !== null && token === expected };
+}
+function isAllowedLocalOrigin(origin) {
+  if (origin === null || origin === "")
+    return true;
+  try {
+    const parsed = new URL(origin);
+    return (parsed.protocol === "http:" || parsed.protocol === "https:") && (parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost");
+  } catch {
+    return false;
+  }
+}
+async function collectTaskSummaries(homeDir, warnings) {
+  const root = join5(homeDir, ".evodev", "STATE", "tasks");
+  if (!await pathExists4(root)) {
+    warnings.push("Task store not found; returning empty tasks.");
+    return [];
+  }
+  const contracts = await collectNamedFiles(root, "contract.json");
+  const summaries = [];
+  for (const file of contracts) {
+    try {
+      const contract = JSON.parse(await readFile7(file, "utf8"));
+      summaries.push(sanitizeMetadata({
+        taskId: contract.taskId,
+        status: contract.status,
+        mode: contract.route?.mode ?? null,
+        workflowId: contract.route?.workflowId ?? null,
+        verificationStatus: contract.verification?.status ?? null
+      }));
+    } catch {
+      warnings.push(`Skipped unreadable task contract: ${file}`);
+    }
+  }
+  return summaries;
+}
+async function collectObservabilitySummaries(homeDir, warnings) {
+  try {
+    return (await listObservabilityEvents(homeDir)).map((event) => sanitizeMetadata({
+      eventId: event.eventId,
+      type: event.type,
+      timestamp: event.timestamp,
+      summary: event.summary,
+      scope: event.scope ?? {}
+    }));
+  } catch (error) {
+    warnings.push(`Observability unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+async function collectLearningCandidateSummaries(homeDir, warnings) {
+  const path = join5(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
+  if (!await pathExists4(path)) {
+    warnings.push("Learning candidate store not found; returning empty candidates.");
+    return [];
+  }
+  const lines = (await readFile7(path, "utf8")).split(`
+`).filter(Boolean);
+  return lines.map((line) => {
+    const candidate = JSON.parse(line);
+    return sanitizeMetadata({
+      id: candidate.id,
+      kind: candidate.kind,
+      status: candidate.status,
+      scope: candidate.scope
+    });
+  });
+}
+async function collectDirectorySummaries(root, warnings) {
+  if (!await pathExists4(root)) {
+    warnings.push(`Store not found: ${root}`);
+    return [];
+  }
+  const entries = await readdir3(root, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => ({ id: entry.name, metadataOnly: true }));
+}
+function sanitizeMetadata(value) {
+  if (typeof value === "string") {
+    if (SENSITIVE_TEXT_PATTERN4.test(value))
+      return "[redacted]";
+    return value.slice(0, 500);
+  }
+  if (Array.isArray(value))
+    return value.map(sanitizeMetadata);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const output = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (/raw|prompt|source|stdout|stderr|secret|token|password|transcript|memorybody/i.test(key))
+      continue;
+    output[key] = sanitizeMetadata(child);
+  }
+  return output;
+}
+async function collectNamedFiles(root, name) {
+  const entries = await readdir3(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const path = join5(root, entry.name);
+    if (entry.isDirectory())
+      files.push(...await collectNamedFiles(path, name));
+    else if (entry.isFile() && entry.name === name)
+      files.push(path);
+  }
+  return files;
+}
+function ok(data, warnings) {
+  return { status: 200, body: { ok: true, data: sanitizeMetadata(data), warnings } };
+}
+function notFound(warnings) {
+  return { status: 404, body: { ok: false, data: { error: "not found" }, warnings } };
+}
+async function pathExists4(path) {
+  try {
+    await stat4(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+// packages/core/src/learning/index.ts
+import { mkdir as mkdir6, readFile as readFile8, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname6, join as join6 } from "node:path";
+var LEARNING_CANDIDATE_KINDS = [
+  "lesson",
+  "anti-criteria",
+  "workflow-improvement",
+  "skill-improvement"
+];
+var LEARNING_CANDIDATE_STATUSES = ["candidate", "rejected", "deferred"];
+var LEARNING_SCOPE_LEVELS = ["user", "project", "workflow", "skill", "asset"];
+var LEARNING_SOURCE_TYPES = [
+  "task-close",
+  "verification-failure",
+  "review-finding",
+  "user-feedback",
+  "manual-candidate"
+];
+var LEARNING_CREATED_BY_VALUES = ["evodev", "user"];
+var LEARNING_REVIEW_DECISIONS = ["pending", "rejected", "deferred"];
+var LEARNING_CONFIDENCE_VALUES = ["low", "medium", "high"];
+var LEARNING_DECISION_VALUES = ["rejected", "deferred"];
+var LEARNING_DECIDED_BY_VALUES = ["user"];
+var LEARNING_CANDIDATE_DECISION_STATUSES = ["rejected", "deferred"];
+var FORBIDDEN_RAW_KEYS3 = new Set([
+  "commandhistory",
+  "commandoutput",
+  "credential",
+  "credentials",
+  "env",
+  "internalurl",
+  "memorybody",
+  "memorybodies",
+  "password",
+  "privatekey",
+  "prompt",
+  "promptbody",
+  "prompttext",
+  "rawcommand",
+  "rawcommandoutput",
+  "rawlog",
+  "rawlogs",
+  "rawoutput",
+  "rawpayload",
+  "rawprompt",
+  "secret",
+  "secretvalue",
+  "source",
+  "sourcebody",
+  "sourcecode",
+  "sourcecontent",
+  "sourcetext",
+  "stderr",
+  "stdout",
+  "token",
+  "transcript",
+  "transcriptbody",
+  "transcripttext"
+]);
+var SENSITIVE_TEXT_PATTERN5 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw logs|raw output|raw source|raw prompt|shell history|command history)\b/i;
+var PROTECTED_PATH_PATTERN = /(^|[~/\\])(?:USER|KNOWLEDGE|LEARNING|OBSERVABILITY|PACKS|RELEASES|logs?|memory|\.env[^/\\]*)(?:$|[/\\])|PROJECTS[/\\][^/\\]+[/\\]LEARNING(?:$|[/\\])|\.evodev[/\\](?:USER|KNOWLEDGE|LEARNING|OBSERVABILITY|PACKS|RELEASES)(?:$|[/\\])/i;
+function createLearningCandidate(input) {
+  const candidate = {
+    version: 1,
+    id: sanitizeId3(input.id),
+    kind: input.kind,
+    status: "candidate",
+    routingInfluence: false,
+    scope: sanitizeScope(input.scope),
+    content: {
+      summary: sanitizeText3(input.content.summary),
+      howToApply: sanitizeText3(input.content.howToApply),
+      antiCriteriaImpact: input.content.antiCriteriaImpact.map(sanitizeText3)
+    },
+    provenance: {
+      taskId: sanitizeNullableId(input.provenance.taskId),
+      taskContractRef: sanitizeNullableText(input.provenance.taskContractRef),
+      workflowRunId: sanitizeNullableId(input.provenance.workflowRunId),
+      evidenceRefs: input.provenance.evidenceRefs.map(sanitizeText3),
+      sourceType: input.provenance.sourceType,
+      createdAt: sanitizeText3(input.provenance.createdAt),
+      createdBy: input.provenance.createdBy,
+      rawPromptStored: false,
+      sourceContentStored: false,
+      rawCommandOutputStored: false
+    },
+    privacy: createSafePrivacy(),
+    review: { decision: "pending", reviewedAt: null, reviewedBy: null },
+    retention: {
+      staleAfter: input.retention?.staleAfter === undefined ? null : sanitizeNullableText(input.retention.staleAfter),
+      deleteAllowed: true,
+      exportAllowed: true
+    },
+    confidence: input.confidence ?? "medium"
+  };
+  validateLearningCandidate(candidate);
+  return candidate;
+}
+function validateLearningCandidate(candidate) {
+  if (!isRecord4(candidate))
+    throw new Error("Learning candidate must be an object.");
+  if (candidate.version !== 1)
+    throw new Error("Learning candidate version must be 1.");
+  assertEnumValue("kind", candidate.kind, LEARNING_CANDIDATE_KINDS);
+  assertEnumValue("status", candidate.status, LEARNING_CANDIDATE_STATUSES);
+  if (candidate.status !== "candidate") {
+    throw new Error("Learning review queue accepts candidate status only.");
+  }
+  if (candidate.routingInfluence !== false) {
+    throw new Error("Learning candidate routingInfluence must be false in I5.");
+  }
+  if (!isRecord4(candidate.scope))
+    throw new Error("Learning candidate scope must be an object.");
+  assertEnumValue("scope.level", candidate.scope.level, LEARNING_SCOPE_LEVELS);
+  if (!isRecord4(candidate.content)) {
+    throw new Error("Learning candidate content must be an object.");
+  }
+  assertStringField("content.summary", candidate.content.summary);
+  assertStringField("content.howToApply", candidate.content.howToApply);
+  assertStringArrayField("content.antiCriteriaImpact", candidate.content.antiCriteriaImpact);
+  if (!isRecord4(candidate.provenance)) {
+    throw new Error("Learning candidate provenance must be an object.");
+  }
+  assertEnumValue("provenance.sourceType", candidate.provenance.sourceType, LEARNING_SOURCE_TYPES);
+  assertEnumValue("provenance.createdBy", candidate.provenance.createdBy, LEARNING_CREATED_BY_VALUES);
+  assertStringField("provenance.createdAt", candidate.provenance.createdAt);
+  assertStringArrayField("provenance.evidenceRefs", candidate.provenance.evidenceRefs);
+  if (!isRecord4(candidate.privacy)) {
+    throw new Error("Learning candidate privacy must be an object.");
+  }
+  assertEnumValue("privacy.classification", candidate.privacy.classification, ["local-private"]);
+  if (!isRecord4(candidate.review))
+    throw new Error("Learning candidate review must be an object.");
+  assertEnumValue("review.decision", candidate.review.decision, LEARNING_REVIEW_DECISIONS);
+  if (candidate.review.decision !== "pending") {
+    throw new Error("Learning candidate review decision must be pending.");
+  }
+  if (!isRecord4(candidate.retention)) {
+    throw new Error("Learning candidate retention must be an object.");
+  }
+  assertEnumValue("confidence", candidate.confidence, LEARNING_CONFIDENCE_VALUES);
+  if (candidate.provenance.rawPromptStored !== false || candidate.provenance.sourceContentStored !== false || candidate.provenance.rawCommandOutputStored !== false) {
+    throw new Error("Learning candidate cannot store raw prompt/source/command output.");
+  }
+  if (candidate.privacy.containsSource !== false || candidate.privacy.containsSecrets !== false || candidate.privacy.containsInternalLinks !== false || candidate.privacy.containsPersonalData !== false) {
+    throw new Error("Learning candidate privacy fields must be local-private and raw-content-free.");
+  }
+  if (candidate.retention.deleteAllowed !== true || candidate.retention.exportAllowed !== true) {
+    throw new Error("Learning candidate retention must allow delete and export.");
+  }
+  assertNoForbiddenContent2(candidate);
+}
+function validateLearningReviewDecisionRecord(record) {
+  if (!isRecord4(record))
+    throw new Error("Learning review decision must be an object.");
+  if (record.version !== 1)
+    throw new Error("Learning review decision version must be 1.");
+  assertStringField("candidateId", record.candidateId);
+  assertEnumValue("decision", record.decision, LEARNING_DECISION_VALUES);
+  assertStringField("decidedAt", record.decidedAt);
+  assertEnumValue("decidedBy", record.decidedBy, LEARNING_DECIDED_BY_VALUES);
+  if (record.reason !== null)
+    assertStringField("reason", record.reason);
+  if (record.writesAcceptedMemory !== false) {
+    throw new Error("Learning review decision writesAcceptedMemory must be false in I5.");
+  }
+  if (record.affectsRouting !== false) {
+    throw new Error("Learning review decision affectsRouting must be false in I5.");
+  }
+  assertEnumValue("candidateStatus", record.candidateStatus, LEARNING_CANDIDATE_DECISION_STATUSES);
+  if (record.candidateStatus !== record.decision) {
+    throw new Error("Learning review decision candidateStatus must match decision.");
+  }
+  assertNoForbiddenContent2(record);
+}
+function parseLearningCandidate(value) {
+  if (!isRecord4(value))
+    throw new Error("Invalid learning candidate JSON.");
+  validateLearningCandidate(value);
+  return value;
+}
+function parseLearningReviewDecisionRecord(value) {
+  if (!isRecord4(value))
+    throw new Error("Invalid learning review decision JSON.");
+  validateLearningReviewDecisionRecord(value);
+  return value;
+}
+async function readLearningCandidates(path) {
+  return parseJsonOrJsonlFile(path, parseLearningCandidate);
+}
+async function readLearningReviewDecisions(path) {
+  return parseJsonOrJsonlFile(path, parseLearningReviewDecisionRecord);
+}
+function resolveLearningCandidateQueuePath(homeDir) {
+  return join6(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
+}
+function resolveLearningDecisionPath(homeDir) {
+  return join6(homeDir, ".evodev", "STATE", "learning", "review-decisions.jsonl");
+}
+async function appendLearningCandidate(homeDir, candidate) {
+  validateLearningCandidate(candidate);
+  const path = resolveLearningCandidateQueuePath(homeDir);
+  await mkdir6(dirname6(path), { recursive: true });
+  await writeFile6(path, `${JSON.stringify(candidate)}
+`, { encoding: "utf8", flag: "a" });
+  return path;
+}
+async function listLearningCandidates(homeDir) {
+  const path = resolveLearningCandidateQueuePath(homeDir);
+  if (!await pathExists5(path))
+    return [];
+  return readLearningCandidates(path);
+}
+async function listLearningReviewDecisions(homeDir) {
+  const path = resolveLearningDecisionPath(homeDir);
+  if (!await pathExists5(path))
+    return [];
+  return readLearningReviewDecisions(path);
+}
+function lintLearningCandidates(candidates, options = {}) {
+  const findings = [];
+  for (const candidate of candidates) {
+    try {
+      validateLearningCandidate(candidate);
+    } catch (error) {
+      findings.push({
+        candidateId: typeof candidate.id === "string" ? candidate.id : "unknown",
+        severity: "error",
+        field: "candidate",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    for (const [field, value] of requiredFields(candidate)) {
+      if (value === undefined || value === null || value === "") {
+        findings.push({
+          candidateId: candidate.id,
+          severity: "error",
+          field,
+          message: "Required learning candidate field is missing."
+        });
+      }
+    }
+    if (candidate.provenance.evidenceRefs.length === 0) {
+      findings.push({
+        candidateId: candidate.id,
+        severity: "error",
+        field: "provenance.evidenceRefs",
+        message: "Learning candidate must include at least one evidence ref."
+      });
+    }
+    if (isCandidateStale(candidate, options.now)) {
+      findings.push({
+        candidateId: candidate.id,
+        severity: "error",
+        field: "retention.staleAfter",
+        message: "Learning candidate is stale and requires review before use."
+      });
+    }
+    for (const [field, path] of candidatePathFields(candidate)) {
+      if (PROTECTED_PATH_PATTERN.test(path)) {
+        findings.push({
+          candidateId: candidate.id,
+          severity: "error",
+          field,
+          message: "Learning candidate references a protected/private path zone."
+        });
+      }
+    }
+  }
+  for (const decision of options.decisions ?? []) {
+    try {
+      validateLearningReviewDecisionRecord(decision);
+    } catch (error) {
+      findings.push({
+        candidateId: isRecord4(decision) && typeof decision.candidateId === "string" ? decision.candidateId : "unknown",
+        severity: "error",
+        field: "decision",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    ok: findings.every((finding) => finding.severity !== "error"),
+    candidatesChecked: candidates.length,
+    decisionsChecked: options.decisions?.length ?? 0,
+    findings
+  };
+}
+function buildLearningReviewEntries(candidates, decisions = [], options = {}) {
+  const latestDecision = new Map;
+  for (const decision of decisions) {
+    validateLearningReviewDecisionRecord(decision);
+    latestDecision.set(decision.candidateId, decision);
+  }
+  return candidates.map((candidate) => {
+    validateLearningCandidate(candidate);
+    const decisionRecord = latestDecision.get(candidate.id) ?? null;
+    const decision = decisionRecord?.decision ?? "pending";
+    return {
+      candidate,
+      decision,
+      decisionRecord,
+      stale: isCandidateStale(candidate, options.now)
+    };
+  }).filter((entry) => options.includeRejected === true || entry.decision !== "rejected");
+}
+function formatLearningReview(candidates, decisions = [], options = {}) {
+  const entries = buildLearningReviewEntries(candidates, decisions, options);
+  return [
+    "EvoDev learning review queue",
+    "",
+    "Preview only: candidates are not accepted memory; accepted memory write is not implemented in I5.",
+    "Pending/deferred candidates do not affect routing; routingInfluence must remain false.",
+    `Candidates shown: ${entries.length}`,
+    ...entries.flatMap((entry) => [
+      "",
+      `- ${entry.candidate.id} (${entry.candidate.kind}, ${entry.candidate.scope.level}, ${entry.candidate.confidence})`,
+      `  Candidate status: ${entry.candidate.status}; decision state: ${entry.decision}`,
+      `  routingInfluence: ${entry.candidate.routingInfluence}; future influence: none in I5`,
+      `  Stale: ${entry.stale ? "yes" : "no"}; staleAfter: ${entry.candidate.retention.staleAfter ?? "none"}`,
+      `  Retention: deleteAllowed=${entry.candidate.retention.deleteAllowed}; exportAllowed=${entry.candidate.retention.exportAllowed}`,
+      `  Summary: ${entry.candidate.content.summary}`,
+      `  How to apply: ${entry.candidate.content.howToApply}`,
+      `  Provenance: task=${entry.candidate.provenance.taskId ?? "none"}, workflow=${entry.candidate.provenance.workflowRunId ?? "none"}, evidence=${entry.candidate.provenance.evidenceRefs.length}`,
+      "  Privacy: local-private; rawPrompt=false; sourceContent=false; rawCommandOutput=false; secrets=false; internalLinks=false"
+    ])
+  ].join(`
+`);
+}
+function formatLearningLint(result) {
+  return [
+    "EvoDev learning lint",
+    "",
+    `Status: ${result.ok ? "PASS" : "FAIL"}`,
+    `Candidates checked: ${result.candidatesChecked}`,
+    `Decisions checked: ${result.decisionsChecked}`,
+    `Findings: ${result.findings.length}`,
+    ...result.findings.map((finding) => `- ${finding.severity.toUpperCase()} ${finding.candidateId} ${finding.field}: ${finding.message}`)
+  ].join(`
+`);
+}
+function createLearningReviewDecisionRecord(input) {
+  assertEnumValue("decision", input.decision, LEARNING_DECISION_VALUES);
+  const candidateStatus = input.decision === "rejected" ? "rejected" : "deferred";
+  const record = {
+    version: 1,
+    candidateId: sanitizeId3(input.candidateId),
+    decision: input.decision,
+    decidedAt: sanitizeText3(input.decidedAt ?? new Date().toISOString()),
+    decidedBy: "user",
+    reason: input.reason === undefined ? null : sanitizeNullableText(input.reason),
+    writesAcceptedMemory: false,
+    affectsRouting: false,
+    candidateStatus
+  };
+  validateLearningReviewDecisionRecord(record);
+  return record;
+}
+async function appendLearningReviewDecision(homeDir, record) {
+  validateLearningReviewDecisionRecord(record);
+  const path = resolveLearningDecisionPath(homeDir);
+  await mkdir6(dirname6(path), { recursive: true });
+  await writeFile6(path, `${JSON.stringify(record)}
+`, { encoding: "utf8", flag: "a" });
+  return path;
+}
+async function pathExists5(path) {
+  try {
+    await stat5(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function createSafePrivacy() {
+  return {
+    classification: "local-private",
+    containsSource: false,
+    containsSecrets: false,
+    containsInternalLinks: false,
+    containsPersonalData: false
+  };
+}
+function sanitizeScope(scope) {
+  return {
+    level: scope.level,
+    projectId: sanitizeNullableId(scope.projectId),
+    workflowId: sanitizeNullableId(scope.workflowId),
+    skillId: sanitizeNullableId(scope.skillId),
+    assetId: scope.assetId === undefined ? undefined : sanitizeNullableId(scope.assetId)
+  };
+}
+function requiredFields(candidate) {
+  return [
+    ["id", candidate.id],
+    ["kind", candidate.kind],
+    ["status", candidate.status],
+    ["routingInfluence", candidate.routingInfluence],
+    ["scope.level", candidate.scope.level],
+    ["content.summary", candidate.content.summary],
+    ["content.howToApply", candidate.content.howToApply],
+    ["provenance.sourceType", candidate.provenance.sourceType],
+    ["provenance.createdAt", candidate.provenance.createdAt],
+    ["provenance.createdBy", candidate.provenance.createdBy],
+    ["privacy.classification", candidate.privacy.classification],
+    ["review.decision", candidate.review.decision],
+    ["retention.deleteAllowed", candidate.retention.deleteAllowed],
+    ["retention.exportAllowed", candidate.retention.exportAllowed],
+    ["confidence", candidate.confidence]
+  ];
+}
+async function parseJsonOrJsonlFile(path, parseItem) {
+  const raw = await readFile8(path, "utf8");
+  if (raw.trim() === "")
+    return [];
+  if (path.endsWith(".jsonl")) {
+    const lines = raw.split(`
+`).filter((line) => line.trim() !== "");
+    return lines.map((line) => parseItem(JSON.parse(line)));
+  }
+  const parsed = JSON.parse(raw);
+  const values = Array.isArray(parsed) ? parsed : [parsed];
+  return values.map(parseItem);
+}
+function candidatePathFields(candidate) {
+  return [
+    ["provenance.taskContractRef", candidate.provenance.taskContractRef],
+    ...candidate.provenance.evidenceRefs.map((ref, index) => [
+      `provenance.evidenceRefs[${index}]`,
+      ref
+    ])
+  ].filter((entry) => typeof entry[1] === "string");
+}
+function isCandidateStale(candidate, now) {
+  if (candidate.retention.staleAfter === null)
+    return false;
+  const staleAfter = Date.parse(candidate.retention.staleAfter);
+  const current = Date.parse(now ?? new Date().toISOString());
+  return Number.isFinite(staleAfter) && Number.isFinite(current) && staleAfter < current;
+}
+function assertEnumValue(field, value, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(`${field} must be one of: ${allowed.join(", ")}.`);
+  }
+}
+function assertStringField(field, value) {
+  if (typeof value !== "string") {
+    throw new Error(`${field} must be a string.`);
+  }
+}
+function assertStringArrayField(field, value) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${field} must be an array of strings.`);
+  }
+}
+function assertNoForbiddenContent2(value) {
+  if (typeof value === "string") {
+    if (value === "local-private")
+      return;
+    if (SENSITIVE_TEXT_PATTERN5.test(value)) {
+      throw new Error("Learning candidate contains sensitive content.");
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertNoForbiddenContent2(item);
+    return;
+  }
+  if (!isRecord4(value))
+    return;
+  for (const [key, child] of Object.entries(value)) {
+    const normalizedKey = normalizeKey2(key);
+    if (FORBIDDEN_RAW_KEYS3.has(normalizedKey)) {
+      throw new Error(`Learning candidate contains forbidden raw field: ${key}`);
+    }
+    assertNoForbiddenContent2(child);
+  }
+}
+function sanitizeText3(value) {
+  return value.replace(SENSITIVE_TEXT_PATTERN5, "[redacted]").slice(0, 500);
+}
+function sanitizeNullableText(value) {
+  return value === null ? null : sanitizeText3(value);
+}
+function sanitizeId3(value) {
+  const sanitized = sanitizeText3(value).replace(/\[redacted\]/gi, "redacted").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100);
+  return sanitized || "learning-candidate";
+}
+function sanitizeNullableId(value) {
+  return value === null ? null : sanitizeId3(value);
+}
+function normalizeKey2(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// packages/core/src/pack/index.ts
+import { readFile as readFile9, readdir as readdir4, stat as stat6 } from "node:fs/promises";
+import { isAbsolute, join as join7, relative as relative2, sep } from "node:path";
+
+// packages/core/src/protected-zones/index.ts
+var SENSITIVE_DIRECTORY_SEGMENTS = new Set([
+  ".claude",
+  ".codex",
+  ".evodev",
+  "KNOWLEDGE",
+  "LEARNING",
+  "OBSERVABILITY",
+  "PROJECTS",
+  "STATE",
+  "USER",
+  "WORK",
+  "accepted-memory",
+  "evidence",
+  "hook-logs",
+  "knowledge",
+  "learning-candidates",
+  "logs",
+  "memory",
+  "pack-logs",
+  "private-project-context",
+  "raw-evidence",
+  "raw-output",
+  "raw-payload",
+  "raw-payloads",
+  "secrets",
+  "state",
+  "task-contract",
+  "task-contracts",
+  "workflow-logs"
+]);
+var SENSITIVE_FILE_NAMES = new Set(["AGENTS.md", "CLAUDE.md"]);
+var SENSITIVE_EXTENSIONS = [".key", ".pem", ".p12", ".pfx"];
+var SENSITIVE_NAME_PARTS = ["raw-command-output", "raw-hook-payload", "secret", "token"];
+var DEFAULT_PROTECTED_ZONE_RULES = [
+  {
+    id: "dotenv-file",
+    reason: "Environment files must not be included in packages or release artifacts.",
+    matches(path) {
+      const name = basename2(path);
+      return name === ".env" || name.startsWith(".env.");
+    }
+  },
+  {
+    id: "runtime-private-directory",
+    reason: "Runtime/private EvoDev directories must not be included in packages or release artifacts.",
+    matches(_path, segments) {
+      return segments.some((segment) => SENSITIVE_DIRECTORY_SEGMENTS.has(segment));
+    }
+  },
+  {
+    id: "project-agent-config",
+    reason: "Project-level Code Agent configuration files are outside the release/package boundary.",
+    matches(path) {
+      return SENSITIVE_FILE_NAMES.has(basename2(path));
+    }
+  },
+  {
+    id: "secret-key-material",
+    reason: "Key/certificate material must not be included in packages or release artifacts.",
+    matches(path) {
+      const lowerPath = path.toLowerCase();
+      return SENSITIVE_EXTENSIONS.some((extension) => lowerPath.endsWith(extension));
+    }
+  },
+  {
+    id: "sensitive-name",
+    reason: "Files or directories whose names suggest secrets, tokens, or raw payloads must not be included without explicit review.",
+    matches(path, segments) {
+      const lowerName = basename2(path).toLowerCase();
+      const lowerSegments = segments.map((segment) => segment.toLowerCase());
+      return SENSITIVE_NAME_PARTS.some((part) => lowerName.includes(part) || lowerSegments.some((segment) => segment.includes(part)));
+    }
+  }
+];
+function checkProtectedZonePaths(paths, rules = DEFAULT_PROTECTED_ZONE_RULES) {
+  const findings = [];
+  for (const path of paths) {
+    const normalizedPath = normalizePackagePath(path);
+    const segments = normalizedPath.split("/").filter((segment) => segment.length > 0);
+    for (const rule of rules) {
+      if (rule.matches(normalizedPath, segments)) {
+        findings.push({
+          path,
+          ruleId: rule.id,
+          severity: "blocker",
+          reason: rule.reason
+        });
+      }
+    }
+  }
+  return { ok: findings.length === 0, findings };
+}
+function normalizePackagePath(path) {
+  const normalized = path.replaceAll("\\", "/").replace(/^\.\//, "");
+  return normalized.startsWith("package/") ? normalized.slice("package/".length) : normalized;
+}
+function basename2(path) {
+  const normalized = normalizePackagePath(path);
+  return normalized.slice(normalized.lastIndexOf("/") + 1);
+}
+
+// packages/core/src/pack/index.ts
+var ASSET_KINDS = ["skills", "agents", "workflows", "hooks", "docs"];
+var MANIFEST_FILE_NAME = "PACK.json";
+var RISKY_PERMISSION_LABELS = {
+  writesUserConfig: "writes user-level EvoDev or Code Agent configuration",
+  writesProjectFiles: "writes project files",
+  usesHooks: "installs or enables hooks",
+  usesNetwork: "uses network or remote services",
+  publishes: "publishes packages or artifacts",
+  deletesFiles: "deletes files",
+  spawnsAgents: "spawns agents",
+  writesMemory: "writes memory or knowledge",
+  readsSourceContent: "reads source content",
+  readsProjectMetadata: "reads project metadata"
+};
+var FIRST_SLICE_DENIED_PERMISSIONS = [
+  "writesProjectFiles",
+  "usesHooks",
+  "usesNetwork",
+  "publishes",
+  "deletesFiles",
+  "writesMemory",
+  "readsSourceContent"
+];
+async function validatePack(packPath) {
+  if (isRemotePackInput(packPath)) {
+    throw new Error("Only local pack directories are supported in I6.");
+  }
+  const packRoot = await resolvePackRoot(packPath);
+  const manifestPath = join7(packRoot, MANIFEST_FILE_NAME);
+  const findings = [];
+  let manifest;
+  let assets = [];
+  let scannedPaths = [];
+  try {
+    manifest = parsePackManifest(JSON.parse(await readFile9(manifestPath, "utf8")));
+  } catch (error) {
+    findings.push({
+      severity: "error",
+      code: "manifest-invalid",
+      message: formatError(error),
+      path: MANIFEST_FILE_NAME
+    });
+  }
+  if (manifest !== undefined) {
+    assets = manifestAssetRefs(manifest, packRoot, findings);
+    await validateReferencedAssets(assets, findings);
+    validatePermissionBoundaries(manifest, findings);
+    validateGuideReferences(manifest, assets, findings);
+  }
+  try {
+    scannedPaths = await collectPackRelativePaths(packRoot);
+  } catch (error) {
+    findings.push({ severity: "error", code: "scan-failed", message: formatError(error) });
+  }
+  const protectedZoneFindings = checkProtectedZonePaths(scannedPaths).findings;
+  for (const finding of protectedZoneFindings) {
+    findings.push({
+      severity: "error",
+      code: `protected-zone:${finding.ruleId}`,
+      message: finding.reason,
+      path: finding.path
+    });
+  }
+  return {
+    ok: findings.every((finding) => finding.severity !== "error"),
+    packRoot,
+    manifestPath,
+    source: packRoot,
+    manifest,
+    assets,
+    scannedPaths,
+    protectedZoneFindings,
+    findings
+  };
+}
+async function planPackInstallDryRun(input) {
+  const packPath = typeof input === "string" ? input : input.packDir;
+  const homePrefix = typeof input === "string" ? "~" : input.homeDir ?? "~";
+  const displayEvodevRoot = `${homePrefix.replace(/\/$/, "")}/.evodev`;
+  const validation = await validatePack(packPath);
+  const manifest = validation.manifest;
+  const plannedWrites = [];
+  const warnings = [];
+  const blockers = validation.findings.filter((finding) => finding.severity === "error").map((finding) => `${finding.code}${finding.path ? ` ${finding.path}` : ""}: ${finding.message}`);
+  if (manifest === undefined) {
+    blockers.push("Cannot plan install because PACK.json is invalid or missing.");
+  } else {
+    const permissions2 = normalizePackPermissions(manifest.permissions);
+    if (!permissions2.writesUserConfig) {
+      warnings.push("Pack does not declare writesUserConfig; dry-run only reports source assets.");
+    }
+    for (const asset of validation.assets) {
+      plannedWrites.push({
+        action: "create",
+        sourcePath: asset.path,
+        targetPath: `${displayEvodevRoot}/PACKS/${manifest.id}/${asset.path}`,
+        reason: "dry-run planned pack asset write; no files are written"
+      });
+    }
+  }
+  const permissions = normalizePackPermissions(manifest?.permissions ?? {});
+  return {
+    validation,
+    plannedWrites,
+    plannedRegistryUpdates: manifest === undefined ? [] : [`dry-run metadata merge for registry.packs.${manifest.id}; no registry file is written`],
+    plannedSettingsUpdates: manifest === undefined ? [] : [`dry-run settings compatibility review for ${manifest.id}; no settings file is written`],
+    permissions,
+    riskyCapabilities: riskyCapabilities(permissions),
+    verificationPlan: manifest?.verify.requiredChecks ?? [],
+    uninstallPlan: manifest === undefined ? [] : [
+      "dry-run-first uninstall required",
+      "confirmation required before future uninstall",
+      "deleteUserContent=false; customizations and user content must be preserved"
+    ],
+    blockers,
+    warnings
+  };
+}
+function parsePackManifest(value) {
+  if (!isRecord5(value))
+    throw new Error("Pack manifest must be an object.");
+  const manifest = value;
+  validateManifestTopLevelFields(manifest);
+  const id = requireString(manifest, "id");
+  const version = requireString(manifest, "version");
+  const name = requireString(manifest, "name");
+  const description = requireString(manifest, "description");
+  const publisher = optionalString(manifest, "publisher");
+  const license = optionalString(manifest, "license");
+  const compatibility = requireRecord(manifest, "compatibility");
+  const assets = parseAssets(requireRecord(manifest, "assets"));
+  const permissions = parsePermissions(manifest.permissions);
+  const install = requireRecord(manifest, "install");
+  const verify = requireRecord(manifest, "verify");
+  const customizations = requireRecord(manifest, "customizations");
+  const observability = requireRecord(manifest, "observability");
+  const uninstall = requireRecord(manifest, "uninstall");
+  validateCompatibilityTargets(id, requireStringArray(compatibility, "targets"));
+  validateProtectedZoneDeclarations(manifest.protectedZones);
+  if (observability.metadataOnly !== true) {
+    throw new Error(`Pack manifest ${id} must declare observability.metadataOnly=true.`);
+  }
+  if (uninstall.deleteUserContent !== false) {
+    throw new Error(`Pack manifest ${id} must declare uninstall.deleteUserContent=false.`);
+  }
+  return {
+    id,
+    version,
+    name,
+    description,
+    publisher,
+    license,
+    compatibility: {
+      evodev: requireString(compatibility, "evodev"),
+      targets: requireStringArray(compatibility, "targets")
+    },
+    assets,
+    permissions,
+    install: {
+      guide: requireString(install, "guide"),
+      requiresConfirmation: requireBoolean(install, "requiresConfirmation"),
+      supportsDryRun: requireBoolean(install, "supportsDryRun"),
+      backupPolicy: requireString(install, "backupPolicy"),
+      mergePolicy: requireString(install, "mergePolicy")
+    },
+    verify: {
+      guide: requireString(verify, "guide"),
+      requiredChecks: requireStringArray(verify, "requiredChecks")
+    },
+    customizations: {
+      guide: requireString(customizations, "guide"),
+      userPath: requireString(customizations, "userPath"),
+      projectPath: requireString(customizations, "projectPath")
+    },
+    protectedZones: isRecord5(manifest.protectedZones) ? {
+      neverInclude: optionalStringArray(manifest.protectedZones, "neverInclude"),
+      neverWrite: optionalStringArray(manifest.protectedZones, "neverWrite")
+    } : undefined,
+    observability: {
+      metadataOnly: true,
+      logEvents: requireStringArray(observability, "logEvents")
+    },
+    uninstall: {
+      supported: requireBoolean(uninstall, "supported"),
+      deleteUserContent: false,
+      requiresDryRun: requireBoolean(uninstall, "requiresDryRun"),
+      requiresConfirmation: requireBoolean(uninstall, "requiresConfirmation")
+    }
+  };
+}
+function normalizePackPermissions(permissions) {
+  return {
+    writesUserConfig: permissions.writesUserConfig === true,
+    writesProjectFiles: permissions.writesProjectFiles === true,
+    usesHooks: permissions.usesHooks === true,
+    usesNetwork: permissions.usesNetwork === true,
+    publishes: permissions.publishes === true,
+    deletesFiles: permissions.deletesFiles === true,
+    spawnsAgents: permissions.spawnsAgents === true,
+    writesMemory: permissions.writesMemory === true,
+    readsSourceContent: permissions.readsSourceContent === true,
+    readsProjectMetadata: permissions.readsProjectMetadata === true
+  };
+}
+function formatPackValidation(result) {
+  const manifest = result.manifest;
+  return [
+    "EvoDev pack validate",
+    "",
+    `Pack root: ${result.packRoot}`,
+    `Status: ${result.ok ? "PASS" : "FAIL"}`,
+    manifest === undefined ? "Pack: unknown" : `Pack: ${manifest.id}@${manifest.version} (${manifest.name})`,
+    `Assets: ${result.assets.length}`,
+    `Scanned paths: ${result.scannedPaths.length}`,
+    `Protected-zone blockers: ${result.protectedZoneFindings.length}`,
+    "",
+    "Findings:",
+    ...result.findings.length === 0 ? ["  - none"] : result.findings.map((finding) => `  - ${finding.severity.toUpperCase()} ${finding.code}${finding.path ? ` ${finding.path}` : ""}: ${finding.message}`)
+  ].join(`
+`);
+}
+function formatPackInstallDryRun(plan) {
+  const manifest = plan.validation.manifest;
+  return [
+    "EvoDev pack install dry-run",
+    "",
+    manifest === undefined ? "Pack: unknown" : `Pack: ${manifest.id}@${manifest.version} (${manifest.name})`,
+    "Mode: dry-run (no writes)",
+    `Status: ${plan.blockers.length === 0 ? "PASS" : "FAIL"}`,
+    "",
+    `Source: ${plan.validation.source}`,
+    "",
+    "Asset inventory:",
+    ...formatAssetInventory(plan.validation.assets),
+    "Asset files:",
+    ...formatAssetFiles(plan.validation.assets),
+    "",
+    "Planned writes:",
+    ...plan.plannedWrites.length === 0 ? ["  - none"] : plan.plannedWrites.map((write) => `  - ${write.action}: ${write.sourcePath} -> ${write.targetPath} (${write.reason})`),
+    "",
+    "Planned registry/settings metadata:",
+    ...plan.plannedRegistryUpdates.length === 0 ? ["  - registry: none"] : plan.plannedRegistryUpdates.map((update) => `  - registry: ${update}`),
+    ...plan.plannedSettingsUpdates.length === 0 ? ["  - settings: none"] : plan.plannedSettingsUpdates.map((update) => `  - settings: ${update}`),
+    "",
+    "Permissions:",
+    ...Object.entries(plan.permissions).map(([key, value]) => `  - ${key}: ${value}`),
+    "",
+    "Risky capabilities:",
+    ...plan.riskyCapabilities.length === 0 ? ["  - none"] : plan.riskyCapabilities.map((capability) => `  - ${capability}`),
+    "",
+    "Protected-zone results:",
+    ...plan.validation.protectedZoneFindings.length === 0 ? ["  - PASS"] : plan.validation.protectedZoneFindings.map((finding) => `  - BLOCKER ${finding.ruleId} ${finding.path}: ${finding.reason}`),
+    "",
+    "Verification plan:",
+    ...plan.verificationPlan.length === 0 ? ["  - none"] : plan.verificationPlan.map((check) => `  - ${check}`),
+    "",
+    "Uninstall plan:",
+    ...plan.uninstallPlan.length === 0 ? ["  - none"] : plan.uninstallPlan.map((step) => `  - ${step}`),
+    "",
+    "Warnings:",
+    ...plan.warnings.length === 0 ? ["  - none"] : plan.warnings.map((warning) => `  - ${warning}`),
+    "",
+    "Blockers:",
+    ...plan.blockers.length === 0 ? ["  - none"] : plan.blockers.map((blocker) => `  - ${blocker}`)
+  ].join(`
+`);
+}
+async function resolvePackRoot(packPath) {
+  const pathStat = await stat6(packPath);
+  if (pathStat.isDirectory())
+    return packPath;
+  throw new Error(`Pack path must be a local directory: ${packPath}`);
+}
+function manifestAssetRefs(manifest, packRoot, findings) {
+  const refs = [];
+  for (const kind of ASSET_KINDS) {
+    for (const assetPath of manifest.assets[kind]) {
+      const pathFinding = validatePackRelativePath(assetPath, packRoot);
+      if (pathFinding !== undefined) {
+        findings.push({ ...pathFinding, path: assetPath });
+        continue;
+      }
+      refs.push({ kind, path: assetPath, absolutePath: join7(packRoot, assetPath) });
+    }
+  }
+  return refs;
+}
+async function validateReferencedAssets(assets, findings) {
+  for (const asset of assets) {
+    try {
+      const assetStat = await stat6(asset.absolutePath);
+      if (!assetStat.isFile()) {
+        findings.push({
+          severity: "error",
+          code: "asset-not-file",
+          message: "Referenced asset must be a file.",
+          path: asset.path
+        });
+      }
+    } catch (error) {
+      if (isEnoent(error)) {
+        findings.push({
+          severity: "error",
+          code: "asset-missing",
+          message: "Referenced asset file does not exist.",
+          path: asset.path
+        });
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+function validatePermissionBoundaries(manifest, findings) {
+  const permissions = normalizePackPermissions(manifest.permissions);
+  for (const permission of FIRST_SLICE_DENIED_PERMISSIONS) {
+    if (permissions[permission]) {
+      findings.push({
+        severity: "error",
+        code: "permission-denied-first-slice",
+        message: `${permission} is outside I6 local validate/install dry-run scope.`
+      });
+    }
+  }
+  if (manifest.assets.hooks.length > 0 && !permissions.usesHooks) {
+    findings.push({
+      severity: "error",
+      code: "permission-asset-mismatch",
+      message: "Pack declares hook assets but usesHooks permission is false."
+    });
+  }
+  if (!manifest.install.requiresConfirmation || !manifest.install.supportsDryRun) {
+    findings.push({
+      severity: "error",
+      code: "install-policy-invalid",
+      message: "Pack install must require confirmation and support dry-run."
+    });
+  }
+  if (!manifest.uninstall.requiresDryRun || !manifest.uninstall.requiresConfirmation) {
+    findings.push({
+      severity: "error",
+      code: "uninstall-policy-invalid",
+      message: "Pack uninstall must require dry-run and confirmation."
+    });
+  }
+}
+function validateGuideReferences(manifest, assets, findings) {
+  const docsAssetPaths = new Set(assets.filter((asset) => asset.kind === "docs").map((asset) => asset.path));
+  for (const guide of [
+    manifest.install.guide,
+    manifest.verify.guide,
+    manifest.customizations.guide
+  ]) {
+    if (!docsAssetPaths.has(guide)) {
+      findings.push({
+        severity: "error",
+        code: "guide-not-declared",
+        message: "Guide file must be listed in assets.docs.",
+        path: guide
+      });
+    }
+  }
+}
+async function collectPackRelativePaths(packRoot, dir = packRoot) {
+  const entries = await readdir4(dir, { withFileTypes: true });
+  const paths = [];
+  for (const entry of entries) {
+    const absolutePath = join7(dir, entry.name);
+    const relativePath = normalizeRelativePath(relative2(packRoot, absolutePath));
+    paths.push(relativePath);
+    if (entry.isDirectory()) {
+      paths.push(...await collectPackRelativePaths(packRoot, absolutePath));
+    }
+  }
+  return paths.sort();
+}
+function validatePackRelativePath(path, packRoot) {
+  if (path.length === 0) {
+    return { severity: "error", code: "path-empty", message: "Path must not be empty." };
+  }
+  if (path.includes("\x00")) {
+    return { severity: "error", code: "path-invalid", message: "Path must not contain NUL bytes." };
+  }
+  if (isAbsolute(path) || path.startsWith("~")) {
+    return {
+      severity: "error",
+      code: "path-absolute",
+      message: "Path must be relative to pack root."
+    };
+  }
+  const normalized = normalizeRelativePath(path);
+  if (normalized.split("/").includes("..")) {
+    return {
+      severity: "error",
+      code: "path-traversal",
+      message: "Path must not escape pack root."
+    };
+  }
+  const absolute = join7(packRoot, normalized);
+  const rel = relative2(packRoot, absolute);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    return {
+      severity: "error",
+      code: "path-traversal",
+      message: "Path must stay inside pack root."
+    };
+  }
+  return;
+}
+function riskyCapabilities(permissions) {
+  return Object.entries(permissions).filter(([, value]) => value).map(([permission]) => RISKY_PERMISSION_LABELS[permission]);
+}
+function formatAssetInventory(assets) {
+  if (assets.length === 0)
+    return ["  - none"];
+  const counts = new Map;
+  for (const kind of ASSET_KINDS)
+    counts.set(kind, 0);
+  for (const asset of assets)
+    counts.set(asset.kind, (counts.get(asset.kind) ?? 0) + 1);
+  return ASSET_KINDS.map((kind) => `  - ${kind}: ${counts.get(kind) ?? 0}`);
+}
+function formatAssetFiles(assets) {
+  if (assets.length === 0)
+    return ["  - none"];
+  return assets.map((asset) => `  - ${asset.kind}: ${asset.path}`);
+}
+function parseAssets(value) {
+  const knownKinds = new Set(ASSET_KINDS);
+  for (const key of Object.keys(value)) {
+    if (!knownKinds.has(key)) {
+      throw new Error(`Pack manifest contains unknown asset kind: ${key}`);
+    }
+  }
+  return {
+    skills: optionalStringArray(value, "skills") ?? [],
+    agents: optionalStringArray(value, "agents") ?? [],
+    workflows: optionalStringArray(value, "workflows") ?? [],
+    hooks: optionalStringArray(value, "hooks") ?? [],
+    docs: optionalStringArray(value, "docs") ?? []
+  };
+}
+function parsePermissions(value) {
+  if (value === undefined)
+    return {};
+  if (!isRecord5(value))
+    throw new Error("Pack manifest permissions must be an object.");
+  const permissions = {};
+  const knownKeys = new Set(Object.keys(RISKY_PERMISSION_LABELS));
+  for (const key of Object.keys(value)) {
+    if (!knownKeys.has(key))
+      throw new Error(`Pack manifest contains unknown permission: ${key}`);
+  }
+  for (const key of Object.keys(RISKY_PERMISSION_LABELS)) {
+    if (value[key] !== undefined)
+      permissions[key] = requireBoolean(value, key);
+  }
+  return permissions;
+}
+function optionalString(record, key) {
+  const value = record[key];
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Pack manifest field must be a non-empty string: ${key}`);
+  }
+  return value;
+}
+function requireString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Pack manifest missing string field: ${key}`);
+  }
+  return value;
+}
+function requireBoolean(record, key) {
+  const value = record[key];
+  if (typeof value !== "boolean")
+    throw new Error(`Pack manifest missing boolean field: ${key}`);
+  return value;
+}
+function requireRecord(record, key) {
+  const value = record[key];
+  if (!isRecord5(value))
+    throw new Error(`Pack manifest missing object field: ${key}`);
+  return value;
+}
+function requireStringArray(record, key) {
+  const value = record[key];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new Error(`Pack manifest missing string array field: ${key}`);
+  }
+  return value;
+}
+function optionalStringArray(record, key) {
+  const value = record[key];
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new Error(`Pack manifest field must be a string array: ${key}`);
+  }
+  return value;
+}
+function validateManifestTopLevelFields(manifest) {
+  const knownFields = new Set([
+    "id",
+    "version",
+    "name",
+    "description",
+    "publisher",
+    "license",
+    "compatibility",
+    "assets",
+    "permissions",
+    "install",
+    "verify",
+    "customizations",
+    "protectedZones",
+    "observability",
+    "uninstall"
+  ]);
+  for (const key of Object.keys(manifest)) {
+    if (!knownFields.has(key))
+      throw new Error(`Pack manifest contains unknown field: ${key}`);
+  }
+}
+function validateCompatibilityTargets(packId, targets) {
+  if (targets.length === 0)
+    throw new Error(`Pack manifest ${packId} must declare at least one target.`);
+  const supportedTargets = new Set(["claude"]);
+  for (const target of targets) {
+    if (!supportedTargets.has(target)) {
+      throw new Error(`Pack manifest ${packId} declares unsupported target: ${target}`);
+    }
+  }
+}
+function validateProtectedZoneDeclarations(value) {
+  if (value === undefined)
+    return;
+  if (!isRecord5(value))
+    throw new Error("Pack manifest protectedZones must be an object.");
+  const knownFields = new Set(["neverInclude", "neverWrite"]);
+  for (const key of Object.keys(value)) {
+    if (!knownFields.has(key))
+      throw new Error(`Pack manifest protectedZones contains unknown field: ${key}`);
+  }
+  optionalStringArray(value, "neverInclude");
+  optionalStringArray(value, "neverWrite");
+}
+function isRemotePackInput(packPath) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(packPath);
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeRelativePath(path) {
+  return path.split(sep).join("/").replace(/^\.\//, "");
+}
+function isEnoent(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+// packages/core/src/plugins/capabilities.ts
+import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname7, join as join8 } from "node:path";
+function createUnknownNegotiatedCapabilities(pluginId) {
+  return {
+    pluginId,
+    skills: "unsupported",
+    agents: "unsupported",
+    hooks: "unsupported",
+    canPlanWrites: false,
+    warnings: [],
+    blockers: [`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 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
+    ].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,
+      warnings,
+      blockers
+    };
+  }
+  return {
+    pluginId: input.pluginId,
+    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.skills.supported && input.declared.agents.supported,
+    warnings: input.enabled ? [] : [
+      `Plugin ${input.pluginId} has declared capabilities but is not enabled; writes are not authorized.`
+    ],
+    blockers: []
+  };
+}
+function resolveNonCodexCapabilityState(supported, enabled) {
+  if (!supported)
+    return "unsupported";
+  return enabled ? "enabled" : "declared";
+}
+async function createCodexCapabilityVerificationArtifact(input) {
+  const timestamp = input.createdAt ?? new Date().toISOString();
+  const detectionMessage = sanitizeText4(input.detection.message);
+  const diagnostics = [
+    "Codex remains no-write until concrete user-level paths and formats are verified."
+  ];
+  return {
+    version: 1,
+    pluginId: "codex",
+    status: "verified-readonly",
+    verifiedAt: timestamp,
+    createdAt: timestamp,
+    metadataOnly: true,
+    rawOutputStored: false,
+    sourceContentStored: false,
+    promptHistoryStored: false,
+    promptStored: false,
+    secretsStored: false,
+    externalUpload: false,
+    networkUsed: false,
+    toolSummary: { tool: "codex", detectionStatus: input.detection.status, version: null },
+    capabilities: { skills: "unverified", agents: "unverified", hooks: "unverified" },
+    writeBoundary: {
+      writesAllowed: false,
+      allowedPaths: [],
+      userLevelOnly: true,
+      noOverwrite: true,
+      projectWritesAllowed: false,
+      codeAgentWritesAllowed: false
+    },
+    privacy: {
+      classification: "local-private",
+      metadataOnly: true,
+      rawOutputStored: false,
+      sourceContentStored: false,
+      promptHistoryStored: false,
+      secretsStored: false,
+      externalUpload: false
+    },
+    blockers: ["Codex asset capabilities are unverified and unsupported for writes in I10."],
+    diagnostics,
+    evidenceRefs: [],
+    evidence: {
+      detectionStatus: input.detection.status,
+      detectionMessage,
+      writesAllowed: false,
+      notes: [
+        "Metadata-only readonly artifact; no Codex paths, formats, hooks, or writes verified."
+      ]
+    }
+  };
+}
+function resolveCodexCapabilityArtifactPath(homeDir) {
+  return join8(homeDir, ".evodev", "STATE", "plugins", "codex", "capability-verification.json");
+}
+async function writeCodexCapabilityVerificationArtifact(homeDir, artifact) {
+  validateCodexCapabilityVerificationArtifact(artifact);
+  const path = resolveCodexCapabilityArtifactPath(homeDir);
+  await mkdir7(dirname7(path), { recursive: true });
+  await writeFile7(path, `${JSON.stringify(artifact, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+  return path;
+}
+async function readCodexCapabilityVerificationArtifact(homeDir) {
+  try {
+    const artifact = JSON.parse(await readFile10(resolveCodexCapabilityArtifactPath(homeDir), "utf8"));
+    validateCodexCapabilityVerificationArtifact(artifact);
+    return artifact;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function validateCodexCapabilityVerificationArtifact(artifact) {
+  if (artifact.version !== 1 || artifact.pluginId !== "codex")
+    throw new Error("Invalid Codex artifact identity.");
+  if (artifact.metadataOnly !== true || artifact.rawOutputStored !== false || artifact.sourceContentStored !== false || artifact.promptStored !== false || artifact.promptHistoryStored !== false || artifact.secretsStored !== false || artifact.externalUpload !== false || artifact.networkUsed !== false || artifact.privacy?.metadataOnly !== true || artifact.privacy.rawOutputStored !== false || artifact.privacy.sourceContentStored !== false || artifact.privacy.promptHistoryStored !== false || artifact.privacy.secretsStored !== false || artifact.privacy.externalUpload !== false || artifact.writeBoundary?.writesAllowed !== false || artifact.writeBoundary.allowedPaths.length !== 0 || artifact.writeBoundary.userLevelOnly !== true || artifact.writeBoundary.noOverwrite !== true || artifact.writeBoundary.projectWritesAllowed !== false || artifact.writeBoundary.codeAgentWritesAllowed !== false) {
+    throw new Error("Codex artifact must be metadata-only and local-only.");
+  }
+  assertNoSensitiveContent(artifact);
+}
+function formatCodexCapabilityVerificationArtifact(artifact, path) {
+  return [
+    "EvoDev Codex capability verification",
+    "",
+    `Status: ${artifact.status}`,
+    `Artifact: ${path ?? "dry-run only"}`,
+    `Verified at: ${artifact.verifiedAt}`,
+    "Capabilities: skills=unverified agents=unverified hooks=unverified",
+    "Writes allowed: false",
+    "Allowed paths: none",
+    "User-level write paths verified: false",
+    "Project writes allowed: false",
+    "No-overwrite verified: false",
+    `External upload: ${artifact.externalUpload}`,
+    `Detection: ${artifact.evidence.detectionStatus}`,
+    ...artifact.evidence.notes.map((note) => `Note: ${note}`)
+  ].join(`
+`);
+}
+async function runPluginConformance(plugin) {
+  const findings = [];
+  try {
+    await plugin.detect();
+    await plugin.getCapabilities();
+  } catch (error) {
+    findings.push(`Plugin ${plugin.id} threw during detect/capabilities: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  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.");
+    }
+  }
+  return { ok: findings.length === 0, findings };
+}
+function sanitizeText4(value) {
+  return value.replace(/https?:\/\/\S+|\b(secret|token|password|private|internal|api[_-]?key)\b/gi, "[redacted]").slice(0, 300);
+}
+function assertNoSensitiveContent(value) {
+  if (typeof value === "string") {
+    if (value === "local-private")
+      return;
+    if (/https?:\/\/\S+|\b(secret|token|password|private|internal|api[_-]?key|raw output|raw source|raw prompt)\b/i.test(value)) {
+      throw new Error("Codex artifact contains sensitive content.");
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertNoSensitiveContent(item);
+    return;
+  }
+  if (typeof value !== "object" || value === null)
+    return;
+  for (const [key, child] of Object.entries(value)) {
+    if (/raw|prompt|source|secret|token|password|memorybody/i.test(key) && child !== false) {
+      throw new Error(`Codex artifact contains forbidden field: ${key}`);
+    }
+    assertNoSensitiveContent(child);
+  }
+}
+// packages/core/src/plugins/registry.ts
+class PluginRegistryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PluginRegistryError";
+  }
+}
+
+class PluginRegistry {
+  #plugins = new Map;
+  register(plugin) {
+    if (this.#plugins.has(plugin.id)) {
+      throw new PluginRegistryError(`Plugin already registered: ${plugin.id}`);
+    }
+    this.#plugins.set(plugin.id, plugin);
+  }
+  get(pluginId) {
+    return this.#plugins.get(pluginId);
+  }
+  require(pluginId) {
+    const plugin = this.get(pluginId);
+    if (plugin === undefined) {
+      throw new PluginRegistryError(`Plugin not registered: ${pluginId}`);
+    }
+    return plugin;
+  }
+  list() {
+    return [...this.#plugins.values()].sort((left, right) => left.id.localeCompare(right.id));
+  }
+  getEnabled(settings) {
+    return getEnabledPluginIds(settings).map((pluginId) => this.require(pluginId));
+  }
+}
+function createPluginRegistry(plugins = []) {
+  const registry = new PluginRegistry;
+  for (const plugin of plugins) {
+    registry.register(plugin);
+  }
+  return registry;
+}
+function getEnabledPluginIds(settings) {
+  return Object.entries(settings.plugins).filter(([, pluginSettings]) => pluginSettings.enabled).map(([pluginId]) => pluginId).sort((left, right) => left.localeCompare(right));
+}
+// packages/core/src/project/index.ts
+import { mkdir as mkdir8, readFile as readFile11, readdir as readdir5, stat as stat7, writeFile as writeFile8 } from "node:fs/promises";
+import { basename as basename3, join as join9, relative as relative3 } from "node:path";
+var PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS = [
+  ".evodev/project.json",
+  ".evodev/profile.md",
+  ".evodev/index.json",
+  ".evodev/commands.json",
+  ".evodev/privacy.json",
+  ".evodev/decisions/README.md"
+];
+var EXCLUDED_DIRECTORY_NAMES = new Set([
+  ".git",
+  ".claude",
+  ".codex",
+  "backups",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var EXCLUDED_FILE_PREFIXES = [".env"];
+var EXCLUDED_FILE_PARTS = [
+  "api-key",
+  "api_key",
+  "apikey",
+  "credential",
+  "credentials",
+  "internal",
+  "internal-link",
+  "password",
+  "passwords",
+  "passwd",
+  "private",
+  "private-url",
+  "secret",
+  "token"
+];
+var EXCLUDED_FILE_EXTENSIONS = [".key", ".pem", ".p12", ".pfx"];
+var DOC_ENTRYPOINTS = new Set(["README.md"]);
+var DEFAULT_EXCLUDED_GLOBS = [
+  ".git/**",
+  "node_modules/**",
+  "dist/**",
+  "build/**",
+  "coverage/**",
+  ".env*",
+  "**/*secret*",
+  "**/*token*",
+  "**/*password*",
+  "**/*passwd*",
+  "**/*api-key*",
+  "**/*api_key*",
+  "**/*apikey*",
+  "**/*credential*",
+  "**/*private*",
+  "**/*internal*",
+  "**/*.key",
+  "**/*.pem",
+  ".claude/**",
+  ".codex/**",
+  ".evodev/backups/**"
+];
+var PROTECTED_PATTERNS = [
+  "secret",
+  "token",
+  "password",
+  "passwd",
+  "api-key",
+  "credential",
+  "private",
+  "private-url",
+  "internal",
+  "internal-link"
+];
+async function createProjectContextPlan(projectDir) {
+  const projectDirStat = await stat7(projectDir);
+  if (!projectDirStat.isDirectory()) {
+    throw new Error(`Project dir is not a directory: ${projectDir}`);
+  }
+  const projectId = createProjectId(projectDir);
+  const privacy = createProjectPrivacy();
+  const files = await collectProjectFileMetadata(projectDir);
+  const commands = await collectProjectCommands(projectDir);
+  const docs = files.filter((file) => file.kind === "file" && DOC_ENTRYPOINTS.has(basename3(file.path))).map((file) => file.path).sort();
+  const index = {
+    version: 1,
+    mode: "metadata-only",
+    projectId,
+    generatedAt: null,
+    rootName: basename3(projectDir),
+    files,
+    docs: { entrypoints: docs },
+    commands: {
+      scripts: commands.scripts,
+      testCommandCandidates: commands.scripts.filter((script) => script.commandClass === "test").map((script) => script.name)
+    },
+    exclusions: privacy.excludedGlobs,
+    sourceContentIncluded: false
+  };
+  const planFiles = await Promise.all(PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS.map(async (relativePath) => {
+    const absolutePath = join9(projectDir, relativePath);
+    const exists = await pathExists6(absolutePath);
+    return {
+      relativePath,
+      absolutePath,
+      action: exists ? "error" : "create",
+      reason: exists ? "Target already exists; I1 does not overwrite." : "Allowed project context file."
+    };
+  }));
+  const errors = planFiles.filter((file) => file.action === "error").map((file) => `${file.relativePath}: ${file.reason}`);
+  return {
+    projectDir,
+    projectId,
+    files: planFiles,
+    index,
+    commands,
+    privacy,
+    warnings: commands.warnings,
+    errors
+  };
+}
+async function writeProjectContext(plan) {
+  if (plan.errors.length > 0) {
+    throw new Error(`Cannot write project context:
+${plan.errors.join(`
+`)}`);
+  }
+  const payloads = createProjectContextPayloads(plan);
+  const writtenFiles = [];
+  for (const relativePath of PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS) {
+    const content = payloads[relativePath];
+    const absolutePath = join9(plan.projectDir, relativePath);
+    await mkdir8(join9(absolutePath, ".."), { recursive: true });
+    await writeFile8(absolutePath, content, { encoding: "utf8", flag: "wx" });
+    writtenFiles.push(relativePath);
+  }
+  return { writtenFiles };
+}
+function formatProjectContextPlan(plan, mode) {
+  return [
+    "EvoDev project init",
+    "",
+    `Mode: ${mode}`,
+    `Project: ${plan.projectDir}`,
+    `Project id: ${plan.projectId}`,
+    "",
+    "Plan:",
+    ...plan.files.map((file) => `  - ${file.action}: ${file.relativePath} (${file.reason})`),
+    "",
+    "Metadata-only index summary:",
+    `  - files: ${plan.index.files.filter((file) => file.kind === "file").length}`,
+    `  - directories: ${plan.index.files.filter((file) => file.kind === "directory").length}`,
+    `  - docs: ${plan.index.docs.entrypoints.length}`,
+    `  - package scripts: ${plan.commands.scripts.length}`,
+    ...plan.warnings.map((warning) => `Warning: ${warning}`),
+    ...plan.errors.map((error) => `Error: ${error}`)
+  ].join(`
+`);
+}
+function createProjectContextPayloads(plan) {
+  const profile = {
+    version: 1,
+    projectId: plan.projectId,
+    displayName: basename3(plan.projectDir),
+    root: { pathPolicy: "local-only" },
+    privacy: {
+      classification: "local-private",
+      metadataOnly: true,
+      sourceContentIncluded: false,
+      rawCommandsIncluded: false
+    }
+  };
+  return {
+    ".evodev/project.json": `${JSON.stringify(profile, null, 2)}
+`,
+    ".evodev/profile.md": createProfileMarkdown(plan),
+    ".evodev/index.json": `${JSON.stringify(plan.index, null, 2)}
+`,
+    ".evodev/commands.json": `${JSON.stringify(plan.commands, null, 2)}
+`,
+    ".evodev/privacy.json": `${JSON.stringify(plan.privacy, null, 2)}
+`,
+    ".evodev/decisions/README.md": `# Project Decisions
+
+Record project decisions here.
+`
+  };
+}
+function createProfileMarkdown(plan) {
+  return [
+    `# ${basename3(plan.projectDir)} Project Context`,
+    "",
+    "This project context was generated as metadata-only local state.",
+    "",
+    `- Project id: ${plan.projectId}`,
+    "- Source content included: false",
+    "- Raw package script commands included: false",
+    "- External upload: false",
+    ""
+  ].join(`
+`);
+}
+async function collectProjectFileMetadata(projectDir) {
+  const files = [];
+  async function visit(dir) {
+    const entries = await readdir5(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = join9(dir, entry.name);
+      const relativePath = relative3(projectDir, absolutePath).replaceAll("\\", "/");
+      if (shouldExcludePath(relativePath, entry.isDirectory())) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        files.push({ path: relativePath, kind: "directory" });
+        await visit(absolutePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        const fileStat = await stat7(absolutePath);
+        files.push({ path: relativePath, kind: "file", sizeBytes: fileStat.size });
+      }
+    }
+  }
+  await visit(projectDir);
+  return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function collectProjectCommands(projectDir) {
+  const packageJsonPath = join9(projectDir, "package.json");
+  const warnings = [];
+  if (!await pathExists6(packageJsonPath)) {
+    return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile11(packageJsonPath, "utf8"));
+  } catch (error) {
+    warnings.push(`package.json scripts skipped: ${describeError(error)}`);
+    return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
+  }
+  const scripts = isRecord6(parsed) && isRecord6(parsed.scripts) ? parsed.scripts : {};
+  const summaries = [];
+  for (const [name, value] of Object.entries(scripts).sort(([left], [right]) => left.localeCompare(right))) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    const commandClass = classifyScript(name, value);
+    const sensitiveReason = detectSensitiveScript(`${name} ${value}`);
+    if (sensitiveReason !== null) {
+      const safeName = `redacted-${commandClass}-script`;
+      const warning = `Protected ${commandClass} script name/command omitted because it matched protected pattern: ${sensitiveReason}.`;
+      warnings.push(warning);
+      summaries.push({
+        name: safeName,
+        commandClass,
+        summary: `Protected ${commandClass} script name/command omitted.`,
+        rawCommandStored: false,
+        redacted: true,
+        warning
+      });
+      continue;
+    }
+    summaries.push({
+      name,
+      commandClass,
+      summary: `Safe ${commandClass} script command summary only.`,
+      rawCommandStored: false,
+      redacted: false
+    });
+  }
+  return {
+    version: 1,
+    metadataOnly: true,
+    rawCommandsIncluded: false,
+    scripts: summaries,
+    warnings
+  };
+}
+function classifyScript(name, command) {
+  const text = `${name} ${command}`.toLowerCase();
+  if (text.includes("typecheck") || text.includes("tsc"))
+    return "typecheck";
+  if (text.includes("lint") || text.includes("biome") || text.includes("eslint"))
+    return "lint";
+  if (text.includes("test"))
+    return "test";
+  if (text.includes("build"))
+    return "build";
+  if (text.includes("format") || text.includes("prettier"))
+    return "format";
+  if (text.includes("install"))
+    return "install";
+  if (text.includes("release") || text.includes("publish") || text.includes("pack"))
+    return "release";
+  return "other";
+}
+function detectSensitiveScript(command) {
+  const lower = command.toLowerCase();
+  if (/(^|[^a-z0-9])(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|private|internal|private-url|internal-link)([^a-z0-9]|$)/.test(lower))
+    return "protected-name-or-command";
+  if (/https?:\/\//i.test(command))
+    return "url";
+  if (/\b[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\b/i.test(command))
+    return "email-or-internal-id";
+  return null;
+}
+function createProjectPrivacy() {
+  return {
+    version: 1,
+    classification: "local-private",
+    metadataOnly: true,
+    sourceContentIndex: false,
+    promptHistoryIndex: false,
+    shellHistoryIndex: false,
+    rawCommandOutputIndex: false,
+    externalUpload: false,
+    excludedGlobs: DEFAULT_EXCLUDED_GLOBS,
+    protectedPatterns: PROTECTED_PATTERNS
+  };
+}
+function createProjectId(projectDir) {
+  return basename3(projectDir).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+}
+function shouldExcludePath(relativePath, isDirectory) {
+  const segments = relativePath.split("/");
+  const name = segments.at(-1) ?? relativePath;
+  const lowerName = name.toLowerCase();
+  if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(name))
+    return true;
+  if (segments.includes(".evodev") && !relativePath.startsWith(".evodev/decisions"))
+    return true;
+  if (EXCLUDED_FILE_PREFIXES.some((prefix) => name.startsWith(prefix)))
+    return true;
+  if (EXCLUDED_FILE_PARTS.some((part) => lowerName.includes(part)))
+    return true;
+  if (EXCLUDED_FILE_EXTENSIONS.some((extension) => lowerName.endsWith(extension)))
+    return true;
+  return false;
+}
+async function pathExists6(path) {
+  try {
+    await stat7(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+// packages/core/src/sync/orchestrator.ts
+import { join as join10 } from "node:path";
+async function runSync(options) {
+  const store = createCoreConfigStore(options.homeDir);
+  const settings = await store.readSettings();
+  const assets = await scanAssets(resolveAssetScannerPaths(options.assetsRootDir));
+  const plugins = getSyncTargetPlugins(settings, options.pluginRegistry, options.targetPlugins);
+  const plans = buildSyncPlans({
+    settings,
+    assets,
+    plugins,
+    dryRun: options.dryRun ?? false,
+    includeSkills: options.includeSkills,
+    includeAgents: options.includeAgents
+  });
+  const results = await executeSyncPlans(plans, plugins);
+  const registry = updateRegistryWithSyncResults(await readRegistryOrDefault(store), assets, results);
+  const syncState = updateSyncStateWithResults(await readSyncStateOrDefault(store), results, options.now?.() ?? new Date().toISOString());
+  if (!(options.dryRun ?? false) && shouldPersistSyncResults(results)) {
+    await store.writeRegistry(registry);
+    await store.writeSyncState(syncState);
+  }
+  return { plans, results, registry, syncState };
+}
+function buildSyncPlans(input) {
+  const shouldIncludeSkills = input.includeSkills ?? true;
+  const shouldIncludeAgents = input.includeAgents ?? true;
+  const skills = input.settings.assets.skills.enabled && shouldIncludeSkills ? input.assets.skills : [];
+  const agents = input.settings.assets.agents.enabled && shouldIncludeAgents ? input.assets.agents : [];
+  return input.plugins.map((plugin) => ({
+    targetPlugin: plugin.id,
+    skills: filterAssetsForTarget(skills, plugin.id),
+    agents: filterAssetsForTarget(agents, plugin.id),
+    dryRun: input.dryRun
+  }));
+}
+async function executeSyncPlans(plans, plugins) {
+  const pluginById = new Map(plugins.map((plugin) => [plugin.id, plugin]));
+  const results = [];
+  for (const plan of plans) {
+    const plugin = pluginById.get(plan.targetPlugin);
+    if (plugin === undefined) {
+      throw new Error(`Cannot execute sync plan for unregistered plugin: ${plan.targetPlugin}`);
+    }
+    const [skillsResult, agentsResult] = await Promise.all([
+      plugin.syncSkills({
+        targetPlugin: plan.targetPlugin,
+        skills: plan.skills,
+        dryRun: plan.dryRun
+      }),
+      plugin.syncAgents({
+        targetPlugin: plan.targetPlugin,
+        agents: plan.agents,
+        dryRun: plan.dryRun
+      })
+    ]);
+    results.push(mergeSyncResults(plan.targetPlugin, skillsResult, agentsResult));
+  }
+  return results;
+}
+function mergeSyncResults(targetPlugin, skillsResult, agentsResult) {
+  return {
+    targetPlugin,
+    syncedSkills: unique([...skillsResult.syncedSkills, ...agentsResult.syncedSkills]),
+    syncedAgents: unique([...skillsResult.syncedAgents, ...agentsResult.syncedAgents]),
+    skipped: unique([...skillsResult.skipped, ...agentsResult.skipped]),
+    warnings: [...skillsResult.warnings, ...agentsResult.warnings],
+    errors: [...skillsResult.errors, ...agentsResult.errors]
+  };
+}
+function updateRegistryWithSyncResults(registry, assets, results) {
+  const next = {
+    version: 1,
+    skills: { ...registry.skills },
+    agents: { ...registry.agents }
+  };
+  for (const result of results) {
+    for (const key of result.syncedSkills) {
+      const asset = assets.skills.find((candidate) => candidate.registryKey === key);
+      if (asset !== undefined) {
+        next.skills[key] = mergeRegisteredAsset(next.skills[key], asset.manifest.version, result.targetPlugin);
+      }
+    }
+    for (const key of result.syncedAgents) {
+      const asset = assets.agents.find((candidate) => candidate.registryKey === key);
+      if (asset !== undefined) {
+        next.agents[key] = mergeRegisteredAsset(next.agents[key], asset.manifest.version, result.targetPlugin);
+      }
+    }
+  }
+  return next;
+}
+function updateSyncStateWithResults(syncState, results, timestamp) {
+  const next = {
+    version: 1,
+    lastSyncAt: timestamp,
+    targets: { ...syncState.targets }
+  };
+  for (const result of results) {
+    next.targets[result.targetPlugin] = {
+      skills: result.syncedSkills.length,
+      agents: result.syncedAgents.length,
+      status: getSyncStatus(result)
+    };
+  }
+  return next;
+}
+function getSyncTargetPlugins(settings, pluginRegistry, targetPlugins) {
+  const enabledPluginIds = getEnabledPluginIds(settings);
+  const selectedPluginIds = targetPlugins === undefined ? enabledPluginIds : unique(targetPlugins).filter((pluginId) => enabledPluginIds.includes(pluginId));
+  return selectedPluginIds.map((pluginId) => pluginRegistry.require(pluginId));
+}
+function shouldPersistSyncResults(results) {
+  if (results.length === 0)
+    return false;
+  if (results.every((result) => result.errors.length === 0))
+    return true;
+  return results.some((result) => result.syncedSkills.length > 0 || result.syncedAgents.length > 0);
+}
+function getSyncStatus(result) {
+  if (result.errors.length === 0) {
+    return "success";
+  }
+  if (result.syncedSkills.length > 0 || result.syncedAgents.length > 0) {
+    return "partial";
+  }
+  return "failed";
+}
+function mergeRegisteredAsset(existing, version, targetPlugin) {
+  return {
+    version,
+    source: existing?.source ?? "builtin",
+    targets: unique([...existing?.targets ?? [], targetPlugin])
+  };
+}
+function filterAssetsForTarget(assets, targetPlugin) {
+  return assets.filter((asset) => asset.manifest.targets.includes(targetPlugin));
+}
+function resolveAssetScannerPaths(assetsRootDir) {
+  return {
+    skillsDir: join10(assetsRootDir, "skills"),
+    agentsDir: join10(assetsRootDir, "agents")
+  };
+}
+async function readRegistryOrDefault(store) {
+  try {
+    return await store.readRegistry();
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return createDefaultRegistry();
+    }
+    throw error;
+  }
+}
+async function readSyncStateOrDefault(store) {
+  try {
+    return await store.readSyncState();
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return createDefaultSyncState();
+    }
+    throw error;
+  }
+}
+function isNotFoundError2(error) {
+  return error instanceof Error && error.message.includes("ENOENT");
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+// packages/core/src/workflow/index.ts
+import { readFile as readFile12, readdir as readdir6 } from "node:fs/promises";
+import { join as join11 } from "node:path";
+async function scanWorkflowManifests(workflowsDir) {
+  const manifests = [];
+  const entries = await readdir6(workflowsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const manifestPath = join11(workflowsDir, entry.name, "WORKFLOW.json");
+    manifests.push(parseWorkflowManifest(JSON.parse(await readFile12(manifestPath, "utf8"))));
+  }
+  return manifests.sort((left, right) => left.id.localeCompare(right.id));
+}
+function parseWorkflowManifest(value) {
+  if (!isRecord7(value))
+    throw new Error("Workflow manifest must be an object.");
+  const manifest = value;
+  if (typeof manifest.id !== "string" || typeof manifest.version !== "string") {
+    throw new Error("Workflow manifest missing id/version.");
+  }
+  if (!Array.isArray(manifest.modes) || !Array.isArray(manifest.steps)) {
+    throw new Error(`Workflow manifest ${manifest.id} missing modes/steps.`);
+  }
+  if (manifest.privacy?.metadataOnly !== true || manifest.privacy.usesNetwork !== false || manifest.privacy.storesRawPrompts !== false || manifest.privacy.storesSourceContent !== false || manifest.privacy.storesRawCommandOutput !== false) {
+    throw new Error(`Workflow manifest ${manifest.id} violates privacy requirements.`);
+  }
+  return manifest;
+}
+function planWorkflow(input) {
+  const mode = input.contract?.route.mode ?? null;
+  const warnings = [];
+  const blockers = [];
+  if (mode !== null && !input.workflow.modes.includes(mode)) {
+    blockers.push(`Workflow ${input.workflow.id} does not support task mode ${mode}.`);
+  }
+  return {
+    workflow: input.workflow,
+    taskId: input.contract?.taskId,
+    mode,
+    steps: input.workflow.steps.map((step) => ({ ...step, plannedOnly: true })),
+    requiredEvidence: input.workflow.requiredEvidence,
+    warnings,
+    blockers
+  };
+}
+function formatWorkflowList(manifests) {
+  return [
+    "EvoDev workflows",
+    "",
+    ...manifests.map((workflow) => `- ${workflow.id} (${workflow.modes.join(", ")}): ${workflow.description}`)
+  ].join(`
+`);
+}
+function formatWorkflowPlan(plan) {
+  return [
+    "EvoDev workflow dry-run",
+    "",
+    `Workflow: ${plan.workflow.id}`,
+    `Task: ${plan.taskId ?? "none"}`,
+    `Mode: ${plan.mode ?? "not routed"}`,
+    "",
+    "Steps:",
+    ...plan.steps.map((step) => `  - ${step.id}: ${step.name} [${step.actor}] evidence=${step.evidence.join(",") || "none"}`),
+    "",
+    "Required evidence:",
+    ...plan.requiredEvidence.map((item) => `  - ${item}`),
+    ...plan.warnings.map((warning) => `Warning: ${warning}`),
+    ...plan.blockers.map((blocker) => `Blocker: ${blocker}`)
+  ].join(`
+`);
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  writeTaskContract,
+  writeProjectContext,
+  writeDaemonState,
+  writeCodexCapabilityVerificationArtifact,
+  verifyTaskContract,
+  validatePack,
+  validateObservabilityEvent,
+  validateLearningReviewDecisionRecord,
+  validateLearningCandidate,
+  validateDaemonBindHost,
+  validateCodexCapabilityVerificationArtifact,
+  validateAgentOutput,
+  scanWorkflowManifests,
+  scanSkillAssets,
+  scanAssets,
+  scanAgentAssets,
+  runSync,
+  runPluginConformance,
+  runDaemonForeground,
+  routeTaskContract,
+  resolveTaskContractOutputPath,
+  resolveObservabilityStorePaths,
+  resolveLearningDecisionPath,
+  resolveLearningCandidateQueuePath,
+  resolveHookRuntimeSessionPaths,
+  resolveEvoDevPaths,
+  resolveDaemonPaths,
+  resolveCodexCapabilityArtifactPath,
+  readTaskContract,
+  readLearningReviewDecisions,
+  readLearningCandidates,
+  readDaemonToken,
+  readDaemonLock,
+  readCodexCapabilityVerificationArtifact,
+  readAgentProfile,
+  planWorkflow,
+  planPackInstallDryRun,
+  pathExists5 as pathExists,
+  parseWorkflowManifest,
+  parseSyncState,
+  parseSkillManifest,
+  parseSettings,
+  parseRegistry,
+  parsePackManifest,
+  parseLearningReviewDecisionRecord,
+  parseLearningCandidate,
+  parseInstallState,
+  parseHookSettings,
+  parseAgentProfile,
+  parseAgentManifest,
+  normalizePackagePath,
+  normalizePackPermissions,
+  normalizeHookEvent,
+  negotiatePluginCapabilities,
+  mergeSettings,
+  mergeReviewFindings,
+  loadAgentContextDryRun,
+  listObservabilityEvents,
+  listLearningReviewDecisions,
+  listLearningCandidates,
+  lintLearningCandidates,
+  isCapabilityUsable,
+  initializeCoreConfig,
+  handleHookRuntime,
+  handleDaemonRequest,
+  getEnabledPluginIds,
+  formatWorkflowPlan,
+  formatWorkflowList,
+  formatTaskContract,
+  formatRetentionDryRun,
+  formatProjectContextPlan,
+  formatPackValidation,
+  formatPackInstallDryRun,
+  formatObservabilityEvents,
+  formatLearningReview,
+  formatLearningLint,
+  formatHookRuntimeOutput,
+  formatHookInstallDryRun,
+  formatHookEventDryRun,
+  formatCodexCapabilityVerificationArtifact,
+  formatAgentContextDryRun,
+  formatAgentComposeDryRun,
+  dryRunObservabilityRetentionCleanup,
+  createUnknownNegotiatedCapabilities,
+  createTaskContract,
+  createProjectContextPlan,
+  createPluginRegistry,
+  createObservabilityEvent,
+  createLearningReviewDecisionRecord,
+  createLearningCandidate,
+  createDefaultSyncState,
+  createDefaultSettings,
+  createDefaultRegistry,
+  createDefaultInstallState,
+  createDefaultHookSettings,
+  createDefaultAgentPermissions,
+  createDaemonStartPlan,
+  createCoreConfigStore,
+  createCodexCapabilityVerificationArtifact,
+  composeAgentDryRun,
+  cleanupDaemonState,
+  classifyCommandRisk,
+  checkProtectedZonePaths,
+  buildSyncPlans,
+  buildLearningReviewEntries,
+  assertNoUnverifiedWrites,
+  applyStrictestAgentPermissions,
+  appendObservabilityEvent,
+  appendLearningReviewDecision,
+  appendLearningCandidate,
+  PluginRegistryError,
+  PluginRegistry,
+  PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS,
+  EvoDevConfigError,
+  EvoDevAssetError,
+  DEFAULT_PROTECTED_ZONE_RULES,
+  CANONICAL_HOOK_EVENT_TYPES
+};