hunter-harness 0.2.29 → 0.2.30

package/dist/bin.js

@@ -2290,6 +2290,10 @@ async function readReceipt(root) {
   }
   return { schema_version: 1, source_hashes: {}, targets: {} };
 }
+async function readManagedProjectRuleProjectionPaths(projectRoot) {
+  const receipt = await readReceipt(resolve3(projectRoot));
+  return new Set(Object.keys(receipt.targets).filter((target) => AGENT_RULE_ROOTS.some((ruleRoot) => target.startsWith(`${ruleRoot}/`))));
+}
 async function markdownFiles(root) {
   try {
     return (await readdir2(root, { withFileTypes: true })).filter((entry) => entry.isFile() && [".md", ".mdc"].includes(extname(entry.name).toLowerCase())).map((entry) => entry.name).filter((name) => !MANAGED_NAMES.has(name)).sort();
@@ -4591,7 +4595,8 @@ function planArtifactRebase(input) {
       plan.alreadyApplied.push({ path: target, operation });
       continue;
     }
-    const staticDecision = decideUpdate(policy, false);
+    const projectionManaged = input.protocolOnlyPaths?.has(source) === true || input.protocolOnlyPaths?.has(target) === true;
+    const staticDecision = projectionManaged ? { apply: false, reason: "protocol-only" } : decideUpdate(policy, false);
     if (!staticDecision.apply) {
       const acknowledgeReason = staticDecision.reason === "protocol-only" ? "protocol-only" : "policy-never";
       const entry2 = acknowledgedEntry(operation, context, input.projectVersion, acknowledgeReason);
@@ -4802,7 +4807,7 @@ function applyBaselineUpdates(baseline, plan) {
   }
   return next;
 }
-async function planSingleArtifact(root, baseline, manifest, client, requestId, dryRun, conflictStrategy, resolveOverrides) {
+async function planSingleArtifact(root, baseline, manifest, client, requestId, dryRun, conflictStrategy, resolveOverrides, protocolOnlyPaths) {
   if (manifest.project_version === null) {
     throw new Error("artifact manifest missing project_version");
   }
@@ -4812,7 +4817,8 @@ async function planSingleArtifact(root, baseline, manifest, client, requestId, d
     projectVersion: manifest.project_version,
     contexts,
     conflictStrategy,
-    ...resolveOverrides === void 0 ? {} : { resolveOverrides }
+    ...resolveOverrides === void 0 ? {} : { resolveOverrides },
+    ...protocolOnlyPaths === void 0 ? {} : { protocolOnlyPaths }
   });
 }
 async function saveConflictReport(root, requestId, manifest, plan) {
@@ -4876,7 +4882,7 @@ async function synchronizeArtifacts(options, initialBaseline) {
     if (manifest.artifact_id !== discovery.artifact_id || manifest.project_id !== projectId || manifest.project_version === null || manifestPayloadHash(manifest) !== manifest.manifest_sha256) {
       throw new Error("ARTIFACT_HASH_MISMATCH");
     }
-    let plan = await planSingleArtifact(root, baseline, manifest, options.client, options.requestId, options.dryRun, conflictStrategy, options.resolveOverrides);
+    let plan = await planSingleArtifact(root, baseline, manifest, options.client, options.requestId, options.dryRun, conflictStrategy, options.resolveOverrides, options.protocolOnlyPaths);
     if (plan.conflicts.length > 0 && options.confirmConflictStrategy !== void 0) {
       const confirmed = await options.confirmConflictStrategy(plan.conflicts);
       if (confirmed === false) {
@@ -4890,7 +4896,7 @@ async function synchronizeArtifacts(options, initialBaseline) {
         aggregate.artifactId = manifest.artifact_id;
         return aggregate;
       }
-      plan = await planSingleArtifact(root, baseline, manifest, options.client, options.requestId, options.dryRun, confirmed, options.resolveOverrides);
+      plan = await planSingleArtifact(root, baseline, manifest, options.client, options.requestId, options.dryRun, confirmed, options.resolveOverrides, options.protocolOnlyPaths);
     }
     const paths = pathsFromPlan(plan);
     aggregate.applied.push(...paths.applied);
@@ -5958,6 +5964,7 @@ async function updateProject(options) {
   }
   const requestId = uuidV7();
   const baseline = await readBaseline(root);
+  const protocolOnlyPaths = await readManagedProjectRuleProjectionPaths(root);
   let parsedServerUrl;
   try {
     parsedServerUrl = new URL(serverUrl);
@@ -5979,6 +5986,7 @@ async function updateProject(options) {
       client,
       requestId,
       dryRun: options.dryRun,
+      protocolOnlyPaths,
       ...options.conflictStrategy === void 0 ? {} : { conflictStrategy: options.conflictStrategy },
       ...options.resolveOverrides === void 0 ? {} : { resolveOverrides: options.resolveOverrides },
       ...options.confirmConflictStrategy === void 0 ? {} : { confirmConflictStrategy: options.confirmConflictStrategy },
@@ -5989,7 +5997,13 @@ async function updateProject(options) {
         const parsed = harnessAgentSchema.safeParse(agent);
         return parsed.success ? [parsed.data] : [];
       });
-      await synchronizeProjectRules(root, agents, project.adapter_options?.codebuddy?.surface ?? "both");
+      const projections = await synchronizeProjectRules(root, agents, project.adapter_options?.codebuddy?.surface ?? "both");
+      for (const path of projections.conflicts) {
+        result.conflicts.push({ path, operation: "modify", reason: "local-dirty" });
+        if (!result.skipped.some((item2) => item2.path === path)) {
+          result.skipped.push({ path, operation: "modify", reason: "local-dirty" });
+        }
+      }
     }
     return result;
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hunter-harness",
-  "version": "0.2.29",
+  "version": "0.2.30",
   "description": "Local-first, server-governed agent harness",
   "license": "MIT",
   "type": "module",