hunter-harness 0.2.18 → 0.2.20

package/dist/bin.js

@@ -164,7 +164,15 @@ var requestMetadataSchema = z2.object({
 }).strict();
 
 // ../contracts/dist/registry.js
-var registryAgentSchema = z3.enum(["claude-code", "codex", "cursor", "generic", "mcp"]);
+var skillTargetAgentSchema = z3.enum(["claude-code", "codex", "cursor", "codebuddy"]);
+var registryAgentSchema = z3.enum([
+  "claude-code",
+  "codex",
+  "cursor",
+  "codebuddy",
+  "generic",
+  "mcp"
+]);
 var registrySkillStatusSchema = z3.enum([
   "draft",
   "pending_review",
@@ -180,6 +188,7 @@ var registrySkillProposalStatusSchema = z3.enum([
 var registrySemverSchema = z3.string().regex(/^\d+\.\d+\.\d+$/);
 var registrySlugSchema = z3.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
 var checkStatusSchema = z3.enum(["green", "yellow", "red"]);
+var skillVariantStatusSchema = z3.enum(["ready", "degraded", "unsupported"]);
 var sourceFileSchema = z3.object({
   path: z3.string(),
   content: z3.string()
@@ -204,6 +213,39 @@ var skillUsageExampleSchema = z3.object({
   result: z3.string(),
   files: z3.array(z3.string()).default([])
 }).strict();
+var sensitiveFindingViewSchema = z3.object({
+  rule_id: z3.string().min(1),
+  severity: z3.enum(["high", "medium", "low"]),
+  path: z3.string().min(1),
+  line: z3.number().int().positive(),
+  column: z3.number().int().positive(),
+  fingerprint: sha256Schema,
+  redacted_preview: z3.string(),
+  overridable: z3.boolean()
+}).strict();
+var sensitiveReviewSubmissionSchema = z3.object({
+  scanner_version: z3.string().min(1),
+  finding_fingerprints: z3.array(sha256Schema).min(1),
+  reason: z3.string().trim().min(3).max(500)
+}).strict();
+var sensitiveReviewEvidenceSchema = sensitiveReviewSubmissionSchema.extend({
+  actor: z3.string().min(1),
+  accepted_at: z3.iso.datetime()
+}).strict();
+var skillVariantSchema = z3.object({
+  agent: skillTargetAgentSchema,
+  status: skillVariantStatusSchema,
+  buildHash: sha256Schema.nullable(),
+  adapterVersion: z3.string().min(1),
+  components: z3.array(z3.string().min(1))
+}).strict();
+var skillReleaseSchema = z3.object({
+  version: registrySemverSchema,
+  packageName: z3.string().min(1),
+  packageDigest: z3.string().min(1),
+  variants: z3.partialRecord(skillTargetAgentSchema, skillVariantSchema),
+  created_at: z3.iso.datetime()
+}).strict();
 var agentSkillConfigSchema = z3.object({
   agent: registryAgentSchema,
   enabled: z3.boolean(),
@@ -250,6 +292,24 @@ var publishSkillRequestSchema = z3.object({
   version: registrySemverSchema,
   releaseNote: z3.string().optional()
 }).strict();
+var publishUnifiedSkillRequestSchema = z3.object({
+  version: registrySemverSchema,
+  sourceAgent: skillTargetAgentSchema,
+  draftRevision: z3.number().int().positive(),
+  releaseNote: z3.string().trim().min(1).max(2e3).optional()
+}).strict();
+var publishSkillResponseSchema = z3.object({
+  release: z3.object({
+    slug: registrySlugSchema,
+    version: registrySemverSchema
+  }).strict(),
+  npmRelease: z3.object({
+    status: z3.enum(["published", "idempotent"]),
+    packageName: z3.string().min(1),
+    version: registrySemverSchema,
+    tarballHash: z3.string().min(1)
+  }).strict()
+}).strict();
 var setDefaultAgentRequestSchema = z3.object({
   defaultAgent: registryAgentSchema,
   revision: z3.number().int().positive()
@@ -931,94 +991,148 @@ var semanticSearchHitSchema = z12.object({
   project_id: z12.string()
 }).strict();
 
-// ../contracts/dist/workflow-family.js
+// ../contracts/dist/skill-package.js
 import { z as z13 } from "zod";
-var workflowBundleManifestSchema = z13.object({
-  schema_version: z13.literal(1),
+var skillComponentRoleSchema = z13.enum(["skill", "subagent"]);
+var skillBundlePathSchema = z13.string().min(1).refine((value) => {
+  if (value === ".")
+    return true;
+  return !value.includes("\0") && !value.includes("\\") && !value.startsWith("/") && !/^[A-Za-z]:/.test(value) && value.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}, "path must be a normalized relative POSIX path");
+var skillBundleComponentSchema = z13.object({
+  role: skillComponentRoleSchema,
+  source: skillBundlePathSchema,
+  name: registrySlugSchema.optional(),
+  variants: z13.partialRecord(skillTargetAgentSchema, skillBundlePathSchema).optional()
+}).strict().superRefine((component, context) => {
+  if (component.role === "skill" && component.variants !== void 0) {
+    context.addIssue({ code: "custom", message: "skill components cannot define agent variants" });
+  }
+  if (component.role === "subagent" && (component.name === void 0 || component.variants === void 0 || Object.keys(component.variants).length === 0)) {
+    context.addIssue({ code: "custom", message: "subagent components require a name and variants" });
+  }
+}).superRefine((component, context) => {
+  if (component.role === "subagent" && component.source !== ".") {
+    context.addIssue({ code: "custom", message: "subagent source must be '.'; variants select native files" });
+  }
+});
+var authorSkillBundleManifestSchema = z13.object({
+  apiVersion: z13.literal("hunter-harness/v1"),
+  kind: z13.literal("SkillBundle"),
+  components: z13.array(skillBundleComponentSchema).min(1)
+}).strict().superRefine((manifest, context) => {
+  if (!manifest.components.some((component) => component.role === "skill")) {
+    context.addIssue({ code: "custom", message: "bundle requires a skill component" });
+  }
+});
+var skillPackageFileSchema = z13.object({
+  path: skillBundlePathSchema,
+  sha256: sha256Schema,
+  size: z13.number().int().nonnegative()
+}).strict();
+var skillPackageVariantSchema = z13.object({
+  status: skillVariantStatusSchema,
+  adapterVersion: z13.string().min(1),
+  buildHash: sha256Schema.nullable(),
+  components: z13.array(z13.string().min(1))
+}).strict();
+var skillPackageManifestV3Schema = z13.object({
+  schema_version: z13.literal(3),
+  slug: registrySlugSchema,
+  version: registrySemverSchema,
+  files: z13.array(skillPackageFileSchema),
+  components: z13.array(skillBundleComponentSchema).min(1),
+  variants: z13.record(skillTargetAgentSchema, skillPackageVariantSchema)
+}).strict();
+
+// ../contracts/dist/workflow-family.js
+import { z as z14 } from "zod";
+var workflowBundleManifestSchema = z14.object({
+  schema_version: z14.literal(1),
   profile: registrySlugSchema,
-  files: z13.array(z13.object({
-    path: z13.string().min(1),
+  files: z14.array(z14.object({
+    path: z14.string().min(1),
     sha256: sha256Schema
   }).strict()).min(1)
 }).strict();
-var workflowFamilyBundleArtifactSchema = z13.object({
-  artifact_id: z13.string().regex(/^wfb_/),
+var workflowFamilyBundleArtifactSchema = z14.object({
+  artifact_id: z14.string().regex(/^wfb_/),
   family_slug: registrySlugSchema,
   profile: registrySlugSchema,
   version: registrySemverSchema,
   content_sha256: sha256Schema,
-  size_bytes: z13.number().int().nonnegative(),
+  size_bytes: z14.number().int().nonnegative(),
   bundle_manifest: workflowBundleManifestSchema,
-  created_at: z13.iso.datetime()
+  created_at: z14.iso.datetime()
 }).strict();
-var workflowFamilyVersionProfileSchema = z13.object({
+var workflowFamilyVersionProfileSchema = z14.object({
   profile: registrySlugSchema,
   bundle_manifest: workflowBundleManifestSchema,
-  artifact_id: z13.string().regex(/^wfb_/),
-  sourceFiles: z13.array(sourceFileSchema).default([])
+  artifact_id: z14.string().regex(/^wfb_/),
+  sourceFiles: z14.array(sourceFileSchema).default([])
 }).strict();
-var workflowFamilyVersionSchema = z13.object({
+var workflowFamilyVersionSchema = z14.object({
   family_slug: registrySlugSchema,
   version: registrySemverSchema,
-  profiles: z13.array(workflowFamilyVersionProfileSchema).min(1),
-  artifacts: z13.array(workflowFamilyBundleArtifactSchema),
-  changeNote: z13.string().nullable(),
-  created_at: z13.iso.datetime()
+  profiles: z14.array(workflowFamilyVersionProfileSchema).min(1),
+  artifacts: z14.array(workflowFamilyBundleArtifactSchema),
+  changeNote: z14.string().nullable(),
+  created_at: z14.iso.datetime()
 }).strict();
-var workflowFamilyDraftProfileSchema = z13.object({
+var workflowFamilyDraftProfileSchema = z14.object({
   profile: registrySlugSchema,
-  sourceFiles: z13.array(sourceFileSchema),
+  sourceFiles: z14.array(sourceFileSchema),
   bundle_manifest: workflowBundleManifestSchema
 }).strict();
-var workflowFamilyDraftStateSchema = z13.object({
+var workflowFamilyDraftStateSchema = z14.object({
   family_slug: registrySlugSchema,
-  profiles: z13.array(workflowFamilyDraftProfileSchema),
-  required_profiles: z13.array(registrySlugSchema),
+  profiles: z14.array(workflowFamilyDraftProfileSchema),
+  required_profiles: z14.array(registrySlugSchema),
   draftVersion: registrySemverSchema.nullable(),
   checks: skillCheckResultSchema.nullable(),
-  releaseNote: z13.string().nullable(),
-  revision: z13.number().int(),
-  created_at: z13.string(),
-  updated_at: z13.string()
+  releaseNote: z14.string().nullable(),
+  revision: z14.number().int(),
+  created_at: z14.string(),
+  updated_at: z14.string()
 }).strict();
-var workflowFamilySchema = z13.object({
-  family_id: z13.string().regex(/^wff_/),
+var workflowFamilySchema = z14.object({
+  family_id: z14.string().regex(/^wff_/),
   slug: registrySlugSchema,
-  displayName: z13.string().min(1).max(120),
-  description: z13.string().min(1).max(1e3),
-  tags: z13.array(registrySlugSchema).default([]),
+  displayName: z14.string().min(1).max(120),
+  description: z14.string().min(1).max(1e3),
+  tags: z14.array(registrySlugSchema).default([]),
   latest_version: registrySemverSchema.nullable(),
-  required_profiles: z13.array(registrySlugSchema).min(1),
-  revision: z13.number().int().positive(),
-  npmReleases: z13.array(npmReleaseRecordSchema).optional().default([]),
-  created_at: z13.iso.datetime(),
-  updated_at: z13.iso.datetime()
+  required_profiles: z14.array(registrySlugSchema).min(1),
+  revision: z14.number().int().positive(),
+  npmReleases: z14.array(npmReleaseRecordSchema).optional().default([]),
+  created_at: z14.iso.datetime(),
+  updated_at: z14.iso.datetime()
 }).strict();
-var workflowFamilyMutationSchema = z13.object({
+var workflowFamilyMutationSchema = z14.object({
   slug: registrySlugSchema,
-  displayName: z13.string().min(1).max(120),
-  description: z13.string().min(1).max(1e3),
-  tags: z13.array(registrySlugSchema).default([]),
-  required_profiles: z13.array(registrySlugSchema).min(1)
+  displayName: z14.string().min(1).max(120),
+  description: z14.string().min(1).max(1e3),
+  tags: z14.array(registrySlugSchema).default([]),
+  required_profiles: z14.array(registrySlugSchema).min(1)
 }).strict();
-var publishWorkflowFamilyRequestSchema = z13.object({
+var publishWorkflowFamilyRequestSchema = z14.object({
   version: registrySemverSchema,
-  releaseNote: z13.string().optional()
+  releaseNote: z14.string().optional()
 }).strict();
-var registryProjectWorkflowBindingSchema = z13.object({
-  project_id: z13.string().regex(/^prj_/),
+var registryProjectWorkflowBindingSchema = z14.object({
+  project_id: z14.string().regex(/^prj_/),
   family_slug: registrySlugSchema,
   profile: registrySlugSchema,
   version: registrySemverSchema.nullable().optional(),
-  revision: z13.number().int().positive(),
-  updated_at: z13.iso.datetime()
+  revision: z14.number().int().positive(),
+  updated_at: z14.iso.datetime()
 }).strict();
-var bindProjectWorkflowFamilyRequestSchema = z13.object({
-  schema_version: z13.literal(1),
+var bindProjectWorkflowFamilyRequestSchema = z14.object({
+  schema_version: z14.literal(1),
   family_slug: registrySlugSchema,
   profile: registrySlugSchema,
   version: registrySemverSchema.nullable().optional(),
-  revision: z13.number().int().nullable()
+  revision: z14.number().int().nullable()
 }).strict();
 
 // ../core/dist/fs/hash.js
@@ -1030,6 +1144,10 @@ function sha256Bytes(content) {
 async function sha256File(path) {
   return sha256Bytes(await readFile(path));
 }
+function aggregateInstalledContentHash(files) {
+  const lines = [...files].sort((a, b) => a.relpath.localeCompare(b.relpath)).map((entry) => `${entry.relpath}:${entry.sha256}`);
+  return createHash("sha256").update(lines.join("\n"), "utf8").digest("hex");
+}
 
 // ../core/dist/fs/path-safety.js
 import { lstat } from "node:fs/promises";
@@ -1613,7 +1731,7 @@ function decideUpdate(policy, dirty) {
 
 // ../core/dist/project/initialize.js
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile4, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { basename, join as join5, resolve as resolve3 } from "node:path";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 
@@ -2311,6 +2429,27 @@ function uuidV7(now = Date.now()) {
 }
 
 // ../core/dist/project/initialize.js
+var CONTEXT_INDEX_PATH = ".harness/context-index.json";
+async function fileHex(path) {
+  try {
+    const data = await readFile4(path);
+    return createHash4("sha256").update(data).digest("hex");
+  } catch {
+    return null;
+  }
+}
+async function readExistingSkillBundles(root) {
+  const text = await readOptional(join5(root, CONTEXT_INDEX_PATH));
+  if (text === "")
+    return /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(text);
+    const bundles = parsed.skill_bundles ?? {};
+    return new Map(Object.entries(bundles));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
 var TargetCollisionError = class extends Error {
   code = "TARGET_COLLISION";
   exitCode = 7;
@@ -2405,6 +2544,7 @@ async function initializeProject(options) {
   const manifests = [];
   const adaptersIndex = {};
   const skillBundles = {};
+  const existingContextBundles = await readExistingSkillBundles(root);
   let primaryBundleHash = "";
   let primaryRegistryVersion = "";
   for (const agent of enabledAgents) {
@@ -2424,7 +2564,8 @@ async function initializeProject(options) {
     });
     skillBundles[agent] = {
       registry_version: bundle.manifest.bundle_version,
-      bundle_hash: bundleHash
+      bundle_hash: bundleHash,
+      ...existingContextBundles.get(agent) ?? {}
     };
     adaptersIndex[agent] = adapter.contextIndex(adapterContext);
     for (const target of targets) {
@@ -2541,6 +2682,7 @@ async function initializeProject(options) {
   if (!options.dryRun) {
     const writeOperations = await Promise.all([...files.entries()].map(async ([path, content]) => operationFor(root, path, content)));
     await runTransaction(root, writeOperations, { kind: "init" });
+    await enrichContextIndexWithVerification(root, enabledAgents, profile, options.resourcesRoot, adapterContext);
   }
   return {
     projectConfig,
@@ -2549,6 +2691,52 @@ async function initializeProject(options) {
     registryVersion: primaryRegistryVersion
   };
 }
+async function enrichContextIndexWithVerification(root, agents, profile, resourcesRoot, adapterContext) {
+  const contextPath = join5(root, CONTEXT_INDEX_PATH);
+  const existing = await readOptional(join5(contextPath));
+  if (existing === "")
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(existing);
+  } catch {
+    return;
+  }
+  const bundles = parsed.skill_bundles ?? {};
+  for (const agent of agents) {
+    const entry = bundles[agent];
+    if (!entry)
+      continue;
+    let loadedBundle;
+    try {
+      loadedBundle = await loadAgentBundle(resourcesRoot, profile, agent);
+    } catch {
+      continue;
+    }
+    const targets = managedTargetsFor(getAdapter(agent), loadedBundle, adapterContext);
+    const mismatches = [];
+    const entries = [];
+    for (const target of targets) {
+      const rel = target.target_path.replace(/\\/g, "/");
+      const actual = await fileHex(join5(root, target.target_path));
+      entries.push({ relpath: rel, sha256: actual ?? "" });
+      if (actual === null) {
+        mismatches.push({ relpath: rel, expected: target.sha256, actual: "<missing>" });
+      } else if (actual !== target.sha256) {
+        mismatches.push({ relpath: rel, expected: target.sha256, actual });
+      }
+    }
+    entry.installedContentHash = aggregateInstalledContentHash(entries);
+    const newStatus = mismatches.length === 0 ? "verified" : "degraded";
+    if (newStatus === "verified" && typeof entry.verifiedAt === "string" && entry.verifiedAt !== "") {
+    } else {
+      entry.verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    entry.verificationStatus = newStatus;
+    entry.mismatchDetails = mismatches;
+  }
+  await writeFile3(contextPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+}
 
 // ../core/dist/project/refresh.js
 import { createHash as createHash5 } from "node:crypto";
@@ -2556,8 +2744,8 @@ import { readFile as readFile5, readdir as readdir3, rmdir } from "node:fs/promi
 import { dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 var INSTALLED_STATE_PATH = ".harness/state/local/installed-harness-bundle.json";
-var CONTEXT_INDEX_PATH = ".harness/context-index.json";
-async function fileHex(path) {
+var CONTEXT_INDEX_PATH2 = ".harness/context-index.json";
+async function fileHex2(path) {
   try {
     return createHash5("sha256").update(await readFile5(path)).digest("hex");
   } catch (error) {
@@ -2658,7 +2846,7 @@ async function readInstalledAgentConfiguration(projectRoot) {
   };
 }
 async function readContextIndexBundleHash(root) {
-  const content = await readOptionalText(join6(root, CONTEXT_INDEX_PATH));
+  const content = await readOptionalText(join6(root, CONTEXT_INDEX_PATH2));
   if (content === "")
     return null;
   try {
@@ -2713,8 +2901,20 @@ function conflict(target, reason, oldSha, incomingSha) {
 function sortByTarget(items) {
   return [...items].sort((left, right) => left.target_path.localeCompare(right.target_path));
 }
-async function reconcileContextIndex(root, agents, profiles, manifests, codebuddySurface2) {
-  const existing = await readOptionalText(join6(root, CONTEXT_INDEX_PATH));
+async function reconcileContextIndex(root, agents, profiles, manifests, codebuddySurface2, verifications) {
+  const existing = await readOptionalText(join6(root, CONTEXT_INDEX_PATH2));
+  let codebase = {
+    map: ".harness/codebase/map",
+    status: "missing"
+  };
+  try {
+    const parsed = JSON.parse(existing);
+    const current = parsed.codebase;
+    if (typeof current?.map === "string" && (current.status === "missing" || current.status === "stale" || current.status === "fresh")) {
+      codebase = { map: current.map, status: current.status };
+    }
+  } catch {
+  }
   const record = {
     schema_version: 2,
     project: {
@@ -2728,18 +2928,28 @@ async function reconcileContextIndex(root, agents, profiles, manifests, codebudd
       ]))
     },
     knowledge: { index: ".harness/knowledge/index.json" },
-    codebase: { map: ".harness/codebase/map", status: "missing" },
-    skill_bundles: Object.fromEntries(manifests.map((manifest) => [
-      manifest.adapter,
-      { registry_version: manifest.bundle_version, bundle_hash: manifest.bundle_manifest_hash }
-    ]))
+    codebase,
+    skill_bundles: Object.fromEntries(manifests.map((manifest) => {
+      const ver = verifications.get(manifest.adapter);
+      return [
+        manifest.adapter,
+        {
+          registry_version: manifest.bundle_version,
+          bundle_hash: manifest.bundle_manifest_hash,
+          installedContentHash: ver?.installedContentHash ?? null,
+          verifiedAt: ver?.verifiedAt ?? null,
+          verificationStatus: ver?.verificationStatus ?? "unknown",
+          mismatchDetails: ver?.mismatchDetails ?? []
+        }
+      ];
+    }))
   };
   const next = JSON.stringify(record, null, 2) + "\n";
   if (existing === next)
     return null;
   return {
     operation: existing === "" ? "add" : "modify",
-    path: CONTEXT_INDEX_PATH,
+    path: CONTEXT_INDEX_PATH2,
     content: next
   };
 }
@@ -2903,7 +3113,7 @@ async function refreshProject(options) {
   const newStateFiles = installed.files.filter((entry) => entry.owner === "shared" || !selectedSet.has(entry.owner));
   for (const target of newManaged) {
     const incoming = target.sha256;
-    const current = await fileHex(join6(root, target.target_path));
+    const current = await fileHex2(join6(root, target.target_path));
     if (current === null) {
       applied.push(item(target, "add", "MISSING_TARGET", null, incoming));
       ops.push({ operation: "add", path: target.target_path, content: target.bytes });
@@ -2931,7 +3141,7 @@ async function refreshProject(options) {
     }
   }
   for (const target of oldOnly) {
-    const current = await fileHex(join6(root, target.target_path));
+    const current = await fileHex2(join6(root, target.target_path));
     if (current === null) {
       continue;
     }
@@ -2957,7 +3167,48 @@ async function refreshProject(options) {
   const projectOperation = await projectTransitionOperation(root, agents, profiles, codebuddySurface2);
   if (projectOperation !== null)
     ops.push(projectOperation);
-  const contextOperation = await reconcileContextIndex(root, agents, profiles, manifests, codebuddySurface2);
+  const verifications = /* @__PURE__ */ new Map();
+  for (const agent of selectedAgents) {
+    const agentProfile = profiles.get(agent) ?? profile;
+    let bundleForVerify;
+    try {
+      bundleForVerify = await loadAgentBundle(options.resourcesRoot, agentProfile, agent);
+    } catch {
+      continue;
+    }
+    const verifyTargets = managedTargetsFor(getAdapter(agent), bundleForVerify, {
+      profile: agentProfile,
+      codebuddySurface: codebuddySurface2
+    });
+    const verifyMismatches = [];
+    const verifyEntries = [];
+    for (const target of verifyTargets) {
+      const rel = target.target_path.replace(/\\/g, "/");
+      const actual = await fileHex2(join6(root, target.target_path));
+      verifyEntries.push({ relpath: rel, sha256: actual ?? "" });
+      if (actual === null) {
+        verifyMismatches.push({ relpath: rel, expected: target.sha256, actual: "<missing>" });
+      } else if (actual !== target.sha256) {
+        verifyMismatches.push({ relpath: rel, expected: target.sha256, actual });
+      }
+    }
+    verifications.set(agent, {
+      adapter: agent,
+      bundleVersion: bundleForVerify.manifest.bundle_version,
+      installedBundleVersion: null,
+      manifestHash: null,
+      installedManifestHash: null,
+      coreHash: null,
+      installedCoreHash: null,
+      adapterHash: null,
+      installedAdapterHash: null,
+      installedContentHash: aggregateInstalledContentHash(verifyEntries),
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      verificationStatus: verifyMismatches.length === 0 ? "verified" : "degraded",
+      mismatchDetails: verifyMismatches
+    });
+  }
+  const contextOperation = await reconcileContextIndex(root, agents, profiles, manifests, codebuddySurface2, verifications);
   if (contextOperation !== null)
     ops.push(contextOperation);
   const managedBlocks = [
@@ -3028,6 +3279,14 @@ async function refreshProject(options) {
 function freshnessEntry(agent, profile, status, identity) {
   return { agent, profile, status, identity, driftedFiles: [], missingFiles: [] };
 }
+function emptyVerification() {
+  return {
+    installedContentHash: null,
+    verifiedAt: null,
+    verificationStatus: "unknown",
+    mismatchDetails: []
+  };
+}
 var BUILD_MARKER_BUNDLE_PATH = ".harness-build.json";
 function buildMarkerCoreHash(text) {
   if (text === null || text === "")
@@ -3057,7 +3316,8 @@ async function collectFreshness(options) {
       coreHash: null,
       installedCoreHash: null,
       adapterHash: null,
-      installedAdapterHash: null
+      installedAdapterHash: null,
+      ...emptyVerification()
     };
     let officialHash = null;
     let officialVersion = null;
@@ -3084,13 +3344,29 @@ async function collectFreshness(options) {
     identity.adapterHash = sha256Bytes(canonicalJson(targets.map((target) => ({ path: target.target_path.replace(/\\/g, "/"), sha256: target.sha256 })).sort((a, b) => a.path.localeCompare(b.path))));
     const installedProjection = await Promise.all(targets.map(async (target) => ({
       path: target.target_path.replace(/\\/g, "/"),
-      sha256: await fileHex(join6(root, target.target_path))
+      sha256: await fileHex2(join6(root, target.target_path))
     })));
     identity.installedAdapterHash = sha256Bytes(canonicalJson(installedProjection.sort((a, b) => a.path.localeCompare(b.path))));
     const markerTarget = targets.find((target) => target.target_path.replace(/\\/g, "/").endsWith(`/${BUILD_MARKER_BUNDLE_PATH}`) || target.target_path === BUILD_MARKER_BUNDLE_PATH);
     if (markerTarget !== void 0) {
       identity.installedCoreHash = buildMarkerCoreHash(await readOptionalText(join6(root, markerTarget.target_path)));
     }
+    const mismatchDetails = [];
+    const contentEntries = [];
+    for (const target of targets) {
+      const rel = target.target_path.replace(/\\/g, "/");
+      const actual = await fileHex2(join6(root, target.target_path));
+      contentEntries.push({ relpath: rel, sha256: actual ?? "" });
+      if (actual === null) {
+        mismatchDetails.push({ relpath: rel, expected: target.sha256, actual: "<missing>" });
+      } else if (actual !== target.sha256) {
+        mismatchDetails.push({ relpath: rel, expected: target.sha256, actual });
+      }
+    }
+    identity.installedContentHash = aggregateInstalledContentHash(contentEntries);
+    identity.verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    identity.verificationStatus = mismatchDetails.length === 0 ? "verified" : "degraded";
+    identity.mismatchDetails = mismatchDetails;
     if (requestedProfile !== installedProfile) {
       agents.push(freshnessEntry(agent, installedProfile, "PROFILE_MISMATCH", identity));
       continue;
@@ -3102,7 +3378,7 @@ async function collectFreshness(options) {
     const drifted = [];
     const missing = [];
     for (const target of targets) {
-      const current = await fileHex(join6(root, target.target_path));
+      const current = await fileHex2(join6(root, target.target_path));
       if (current === null) {
         missing.push(target.target_path);
       } else if (current !== target.sha256) {
@@ -3292,7 +3568,7 @@ function highEntropyCandidates(content) {
 }
 
 // ../core/dist/security/scanner.js
-var SENSITIVE_SCANNER_VERSION = "1.0.0";
+var SENSITIVE_SCANNER_VERSION = "1.1.0";
 var RULES = [
   {
     id: "HH_PRIVATE_KEY",
@@ -3347,6 +3623,9 @@ function rawFindings(content) {
   for (const rule of RULES) {
     for (const match of content.matchAll(rule.pattern)) {
       const value = match[rule.valueGroup ?? 0] ?? match[0];
+      if (rule.id === "HH_PASSWORD_VALUE" && isObviousPlaceholder(value)) {
+        continue;
+      }
       const relative3 = match[0].indexOf(value);
       findings.push({
         ruleId: rule.id,
@@ -3357,6 +3636,8 @@ function rawFindings(content) {
     }
   }
   for (const candidate of highEntropyCandidates(content)) {
+    if (!hasSensitiveLexicalContext(content, candidate.offset))
+      continue;
     findings.push({
       ruleId: "HH_HIGH_ENTROPY",
       severity: "high",
@@ -3366,6 +3647,17 @@ function rawFindings(content) {
   }
   return findings;
 }
+function isObviousPlaceholder(value) {
+  const trimmed = value.trim();
+  return /^\$\([^)]+\)$/.test(trimmed) || /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(trimmed) || /^\{\{[^{}]+\}\}$/.test(trimmed) || /^<[^<>]+>$/.test(trimmed) || /^(?:example|placeholder|your[-_][a-z0-9_-]+)$/i.test(trimmed);
+}
+function hasSensitiveLexicalContext(content, offset) {
+  const lineStart = content.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+  const nextLineBreak = content.indexOf("\n", offset);
+  const lineEnd = nextLineBreak === -1 ? content.length : nextLineBreak;
+  const line = content.slice(lineStart, lineEnd);
+  return /(?:secret|token|password|passwd|pwd|api[_-]?key|credential|authorization|bearer)\s*[:=]\s*["']?[A-Za-z0-9._~+/-]{8,}/i.test(line);
+}
 function scanSensitiveFiles(files, options = {}) {
   const findings = [];
   const evidence = [];
@@ -3424,6 +3716,8 @@ function scanSensitiveFiles(files, options = {}) {
   return {
     scanner_version: SENSITIVE_SCANNER_VERSION,
     blocked: findings.some((finding) => finding.disposition === "blocked"),
+    hard_blocked: findings.some((finding) => finding.disposition === "blocked" && finding.severity === "high"),
+    review_required: findings.some((finding) => finding.disposition === "blocked" && finding.severity !== "high"),
     findings,
     override_evidence: Object.freeze(evidence)
   };
@@ -3448,7 +3742,7 @@ function generateProposalPreview(input, scanOptions = {}) {
 }
 
 // ../core/dist/push/credentials.js
-import { readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 import { parse as parseYaml4, stringify as stringifyYaml3 } from "yaml";
 var CREDENTIALS_LOCAL_RELATIVE = ".harness/credentials.local.yaml";
@@ -3530,7 +3824,7 @@ async function readLocalCredentials(projectRoot) {
 }
 async function writeLocalCredentials(projectRoot, credentials) {
   const normalized = validateLocalCredentials(credentials);
-  await writeFile3(join7(projectRoot, CREDENTIALS_LOCAL_RELATIVE), stringifyYaml3(normalized, { sortMapEntries: true }) + "\n", "utf8");
+  await writeFile4(join7(projectRoot, CREDENTIALS_LOCAL_RELATIVE), stringifyYaml3(normalized, { sortMapEntries: true }) + "\n", "utf8");
 }
 async function ensureCredentialsGitignore(projectRoot) {
   const gitignorePath = join7(projectRoot, ".gitignore");
@@ -3559,7 +3853,7 @@ async function ensureCredentialsGitignore(projectRoot) {
     return;
   }
   const suffix = content.length === 0 || content.endsWith("\n") ? "" : "\n";
-  await writeFile3(gitignorePath, content + suffix + missing.join("\n") + "\n", "utf8");
+  await writeFile4(gitignorePath, content + suffix + missing.join("\n") + "\n", "utf8");
 }
 function resolvePushAuth(input) {
   const tokenEnv = input.tokenEnv ?? input.projectTokenEnv;
@@ -3601,7 +3895,7 @@ async function readBaseline(projectRoot) {
 
 // ../core/dist/state/locks.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { readFile as readFile8, rename as rename3, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { readFile as readFile8, rename as rename3, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
 import { join as join9 } from "node:path";
 async function readLock(path) {
   return JSON.parse(await readFile8(path, "utf8"));
@@ -3621,7 +3915,7 @@ async function acquireProtocolLock(projectRoot, operation, options = {}) {
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      await writeFile4(lockPath, JSON.stringify(record, null, 2), { flag: "wx" });
+      await writeFile5(lockPath, JSON.stringify(record, null, 2), { flag: "wx" });
       return {
         path: lockPath,
         operation,
@@ -4986,46 +5280,52 @@ async function cleanupProject(options) {
 
 // ../core/dist/skill/frontmatter.js
 import { parse as parseYaml6 } from "yaml";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // ../core/dist/skill/fixer.js
 import { parse as parseYaml7, stringify as stringifyYaml5 } from "yaml";
 
-// ../core/dist/skill/agents.js
-var AGENT_DESCRIPTORS = {
-  "claude-code": {
+// ../core/dist/skill/agent-surfaces.js
+var SURFACES = Object.freeze({
+  "claude-code": Object.freeze({
     agent: "claude-code",
-    installable: true,
-    installTarget: (slug) => `.claude/skills/${slug}/`,
-    installMode: "folder"
-  },
-  codex: {
+    skillRoots: Object.freeze({ project: ".claude/skills", user: ".claude/skills" }),
+    subagentRoots: Object.freeze({ project: ".claude/agents", user: ".claude/agents" }),
+    subagentFormat: "markdown",
+    subagentExtension: ".md",
+    nativeSkillAliases: Object.freeze([])
+  }),
+  codex: Object.freeze({
     agent: "codex",
-    installable: true,
-    installTarget: () => "AGENTS.md",
-    installMode: "managed_block",
-    blockId: (slug) => `harness-skill-${slug}`
-  },
-  cursor: {
+    skillRoots: Object.freeze({ project: ".agents/skills", user: ".agents/skills" }),
+    subagentRoots: Object.freeze({ project: ".codex/agents", user: ".codex/agents" }),
+    subagentFormat: "toml",
+    subagentExtension: ".toml",
+    nativeSkillAliases: Object.freeze([])
+  }),
+  cursor: Object.freeze({
     agent: "cursor",
-    installable: true,
-    installTarget: (slug) => `.cursor/rules/${slug}.mdc`,
-    installMode: "file"
-  },
-  generic: {
-    agent: "generic",
-    installable: true,
-    installTarget: (slug) => `.agent-skills/${slug}.md`,
-    installMode: "file"
-  },
-  mcp: {
-    agent: "mcp",
-    installable: false,
-    installTarget: () => "",
-    installMode: "file"
-  }
-};
-var INSTALLABLE_AGENTS = Object.keys(AGENT_DESCRIPTORS).filter((agent) => AGENT_DESCRIPTORS[agent]?.installable === true);
+    skillRoots: Object.freeze({ project: ".cursor/skills", user: ".cursor/skills" }),
+    subagentRoots: Object.freeze({ project: ".cursor/agents", user: ".cursor/agents" }),
+    subagentFormat: "markdown",
+    subagentExtension: ".md",
+    nativeSkillAliases: Object.freeze([".agents/skills"])
+  }),
+  codebuddy: Object.freeze({
+    agent: "codebuddy",
+    skillRoots: Object.freeze({ project: ".codebuddy/skills", user: ".codebuddy/skills" }),
+    subagentRoots: Object.freeze({ project: ".codebuddy/agents", user: ".codebuddy/agents" }),
+    subagentFormat: "markdown",
+    subagentExtension: ".md",
+    nativeSkillAliases: Object.freeze([])
+  })
+});
+var SKILL_TARGET_AGENTS = Object.freeze([
+  "claude-code",
+  "codex",
+  "cursor",
+  "codebuddy"
+]);
 
 // ../core/dist/transaction/recovery.js
 import { readFile as readFile12, readdir as readdir6, rm as rm7, stat as stat3 } from "node:fs/promises";
@@ -5408,7 +5708,7 @@ function serializeCliResult(result) {
 }
 
 // src/config/codebuddy-setup.ts
-import { mkdir as mkdir4, readFile as readFile15, readdir as readdir7, stat as stat4, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile15, readdir as readdir7, stat as stat4, writeFile as writeFile6 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname4, extname, join as join16 } from "node:path";
 var MANAGED_RULE_NAMES = /* @__PURE__ */ new Set([
   "harness-general.md",
@@ -5482,7 +5782,7 @@ async function applyCodeBuddySetup(options) {
           continue;
         }
         await mkdir4(dirname4(target), { recursive: true });
-        await writeFile5(target, content, { encoding: "utf8", flag: "wx" });
+        await writeFile6(target, content, { encoding: "utf8", flag: "wx" });
         result.copied.push(target);
       }
     }
@@ -5503,7 +5803,7 @@ async function applyCodeBuddySetup(options) {
             codegraph: { command: "codegraph", args: ["serve", "--mcp"] }
           }
         };
-        await writeFile5(path, JSON.stringify(next, null, 2) + "\n", "utf8");
+        await writeFile6(path, JSON.stringify(next, null, 2) + "\n", "utf8");
         result.mcpUpdated = true;
       }
     }

package/package.json

@@ -1,36 +1,36 @@
-{
-  "name": "hunter-harness",
-  "version": "0.2.18",
-  "description": "Local-first, server-governed agent harness",
-  "license": "MIT",
-  "type": "module",
-  "engines": {
-    "node": ">=22.12.0"
-  },
-  "bin": {
-    "hunter-harness": "dist/bin.js"
-  },
-  "files": [
-    "dist/bin.js"
-  ],
-  "scripts": {
-    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && npm run bundle",
-    "bundle": "node ../../scripts/bundle-cli.mjs",
-    "typecheck": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json --noEmit",
-    "prepack": "npm run build"
-  },
-  "dependencies": {
-    "commander": "15.0.0",
-    "yaml": "2.9.0",
-    "zod": "4.4.3"
-  },
-  "optionalDependencies": {
-    "pacote": "21.4.0"
-  },
-  "devDependencies": {
-    "@hunter-harness/contracts": "*",
-    "@hunter-harness/core": "*",
-    "@types/pacote": "^11.1.8",
-    "esbuild": "^0.25.12"
-  }
-}
+{
+  "name": "hunter-harness",
+  "version": "0.2.20",
+  "description": "Local-first, server-governed agent harness",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "bin": {
+    "hunter-harness": "dist/bin.js"
+  },
+  "files": [
+    "dist/bin.js"
+  ],
+  "scripts": {
+    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && npm run bundle",
+    "bundle": "node ../../scripts/bundle-cli.mjs",
+    "typecheck": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "commander": "15.0.0",
+    "yaml": "2.9.0",
+    "zod": "4.4.3"
+  },
+  "optionalDependencies": {
+    "pacote": "21.4.0"
+  },
+  "devDependencies": {
+    "@hunter-harness/contracts": "*",
+    "@hunter-harness/core": "*",
+    "@types/pacote": "^11.1.8",
+    "esbuild": "^0.25.12"
+  }
+}