hunter-harness 0.1.0 → 0.1.1

package/dist/bin.js

@@ -1244,9 +1244,8 @@ function decideUpdate(policy, dirty) {
 }
 
 // ../core/dist/project/initialize.js
-import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile3, stat as stat2 } from "node:fs/promises";
-import { basename, join as join4, resolve as resolve3 } from "node:path";
+import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { basename, join as join5, resolve as resolve3 } from "node:path";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 
 // ../core/dist/transaction/transaction.js
@@ -1473,6 +1472,61 @@ async function runTransaction(projectRoot, rawOperations, options = {}) {
   }
 }
 
+// ../core/dist/project/profile-bundle.js
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function isProfile(value) {
+  return value === "general" || value === "java";
+}
+function validateRelativeBundlePath(path) {
+  if (typeof path !== "string" || path.length === 0 || path.includes("\0") || path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:/.test(path) || path.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error("invalid Harness Bundle path");
+  }
+}
+async function loadProfileBundle(resourcesRoot, profile) {
+  const raw = JSON.parse(await readFile3(join4(resourcesRoot, "harness", "manifests", `${profile}.json`), "utf8"));
+  if (raw.schema_version !== 1 || raw.profile !== profile || typeof raw.bundle_version !== "string" || raw.generator !== "harness_deploy.py" || !Array.isArray(raw.files)) {
+    throw new Error(`invalid ${profile} Harness Bundle manifest`);
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const item of raw.files) {
+    validateRelativeBundlePath(item.path);
+    if (typeof item.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(item.sha256) || files.has(item.path)) {
+      throw new Error(`invalid ${profile} Harness Bundle manifest entry`);
+    }
+    const bytes = await readFile3(join4(resourcesRoot, "harness", profile, item.path));
+    if (createHash2("sha256").update(bytes).digest("hex") !== item.sha256) {
+      throw new Error(`Harness Bundle hash mismatch: ${item.path}`);
+    }
+    files.set(item.path, bytes);
+  }
+  return { manifest: raw, files };
+}
+async function managedBundleTargets(resourcesRoot, profile) {
+  const bundle = await loadProfileBundle(resourcesRoot, profile);
+  const targets = new Set(bundleTargetContents(bundle).keys());
+  if (profile === "java")
+    targets.add(".claude/rules/harness-profile-java.md");
+  return targets;
+}
+function bundleTargetContents(bundle) {
+  const contents = /* @__PURE__ */ new Map();
+  for (const [path, bytes] of bundle.files) {
+    const skillTarget = `.claude/skills/${path}`;
+    contents.set(skillTarget, bytes);
+    const agent = /^agents\/([^/]+\.md)$/.exec(path);
+    if (agent?.[1] !== void 0) {
+      const agentTarget = `.claude/agents/${agent[1]}`;
+      contents.set(agentTarget, bytes);
+    }
+  }
+  return contents;
+}
+function parseHarnessProfile(value) {
+  return isProfile(value) ? value : null;
+}
+
 // ../core/dist/project/uuid-v7.js
 import { randomBytes } from "node:crypto";
 function uuidV7(now = Date.now()) {
@@ -1498,7 +1552,7 @@ function uuidV7(now = Date.now()) {
 // ../core/dist/project/initialize.js
 async function readOptional(path) {
   try {
-    return await readFile3(path, "utf8");
+    return await readFile4(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return "";
@@ -1518,53 +1572,32 @@ async function exists2(path) {
   }
 }
 async function existingProjectConfig(root) {
-  const path = join4(root, ".harness", "project.yaml");
+  const path = join5(root, ".harness", "project.yaml");
   const content = await readOptional(path);
   return content === "" ? null : projectConfigSchema.parse(parseYaml2(content));
 }
 async function operationFor(root, path, content) {
-  return await exists2(join4(root, path)) ? { operation: "modify", path, content } : { operation: "add", path, content };
-}
-async function readProfileBundle(resourcesRoot, profile) {
-  const manifest = JSON.parse(await readFile3(join4(resourcesRoot, "harness", "manifests", `${profile}.json`), "utf8"));
-  if (manifest.schema_version !== 1 || manifest.profile !== profile) {
-    throw new Error(`invalid ${profile} Harness Bundle manifest`);
-  }
-  const files = /* @__PURE__ */ new Map();
-  for (const item of manifest.files) {
-    const bytes = await readFile3(join4(resourcesRoot, "harness", profile, item.path));
-    if (createHash2("sha256").update(bytes).digest("hex") !== item.sha256) {
-      throw new Error(`Harness Bundle hash mismatch: ${item.path}`);
-    }
-    files.set(item.path, bytes);
-  }
-  return { manifest, files };
-}
-function bundleTargets(bundleFiles) {
-  const targets = /* @__PURE__ */ new Map();
-  for (const [path, bytes] of bundleFiles) {
-    targets.set(`.claude/skills/${path}`, bytes);
-    const agent = /^agents\/([^/]+\.md)$/.exec(path);
-    if (agent?.[1] !== void 0)
-      targets.set(`.claude/agents/${agent[1]}`, bytes);
-  }
-  return targets;
+  return await exists2(join5(root, path)) ? { operation: "modify", path, content } : { operation: "add", path, content };
 }
 var INSTALLED_BUNDLE_PATH = ".harness/state/local/installed-harness-bundle.json";
-async function previousInstalledFiles(root) {
-  const content = await readOptional(join4(root, INSTALLED_BUNDLE_PATH));
+async function previousInstalledProfile(root) {
+  const content = await readOptional(join5(root, INSTALLED_BUNDLE_PATH));
   if (content === "")
-    return [];
-  const parsed = JSON.parse(content);
-  return parsed.schema_version === 1 && Array.isArray(parsed.files) ? parsed.files : [];
+    return null;
+  try {
+    const parsed = JSON.parse(content);
+    return parsed.schema_version === 1 ? parseHarnessProfile(parsed.profile) : null;
+  } catch {
+    return null;
+  }
 }
 async function initializeProject(options) {
   const root = resolve3(options.projectRoot);
   const config = initConfigSchema.parse(options.config);
   const existing = await existingProjectConfig(root);
   const profile = config.profile;
-  const bundle = await readProfileBundle(options.resourcesRoot, profile);
-  const bundleFiles = bundleTargets(bundle.files);
+  const bundle = await loadProfileBundle(options.resourcesRoot, profile);
+  const bundleFiles = bundleTargetContents(bundle);
   const bundleHash = sha256Bytes(canonicalJson(bundle.manifest.files));
   const projectConfig = projectConfigSchema.parse({
     harness: { name: "hunter-harness", schema_version: 1 },
@@ -1588,14 +1621,14 @@ async function initializeProject(options) {
     artifact_manifest_hash: null,
     files: {}
   });
-  const agentsContent = upsertManagedBlock(await readOptional(join4(root, "AGENTS.md")), [
+  const agentsContent = upsertManagedBlock(await readOptional(join5(root, "AGENTS.md")), [
     "# Hunter Harness",
     "",
     "Use .harness/context-index.json to route rules, Knowledge, and codebase maps.",
     "Treat .claude/skills/harness-* as editable adapter working copies.",
     "Do not modify .harness/state or .harness/cache directly."
   ].join("\n"));
-  const claudeContent = upsertManagedBlock(await readOptional(join4(root, "CLAUDE.md")), [
+  const claudeContent = upsertManagedBlock(await readOptional(join5(root, "CLAUDE.md")), [
     "@AGENTS.md",
     "",
     "# Hunter Harness",
@@ -1664,8 +1697,10 @@ async function initializeProject(options) {
     files: installedFileList.sort()
   };
   files.set(INSTALLED_BUNDLE_PATH, JSON.stringify(installedManifest, null, 2) + "\n");
-  const newManaged = new Set(installedManifest.files);
-  const deleteOperations = (await previousInstalledFiles(root)).filter((path) => !newManaged.has(path)).map((path) => ({ operation: "delete", path }));
+  const newManaged = await managedBundleTargets(options.resourcesRoot, profile);
+  const oldProfile = await previousInstalledProfile(root);
+  const oldManaged = oldProfile === null ? /* @__PURE__ */ new Set() : await managedBundleTargets(options.resourcesRoot, oldProfile);
+  const deleteOperations = [...oldManaged].filter((path) => !newManaged.has(path)).map((path) => ({ operation: "delete", path }));
   const paths = [...files.keys()].sort((left, right) => left.localeCompare(right));
   if (!options.dryRun) {
     const writeOperations = await Promise.all([...files.entries()].map(async ([path, content]) => operationFor(root, path, content)));
@@ -1977,28 +2012,28 @@ function generateProposalPreview(input, scanOptions = {}) {
 }
 
 // ../core/dist/push/push.js
-import { lstat as lstat2, readFile as readFile6, readdir, rm as rm4 } from "node:fs/promises";
-import { join as join7, relative, resolve as resolve4 } from "node:path";
+import { lstat as lstat2, readFile as readFile7, readdir, rm as rm4 } from "node:fs/promises";
+import { join as join8, relative, resolve as resolve4 } from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 
 // ../core/dist/state/baseline.js
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 async function readBaseline(projectRoot) {
-  const content = await readFile4(join5(stateLayout(projectRoot).baseline, "manifest.json"), "utf8");
+  const content = await readFile5(join6(stateLayout(projectRoot).baseline, "manifest.json"), "utf8");
   return baselineManifestSchema.parse(JSON.parse(content));
 }
 
 // ../core/dist/state/locks.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { readFile as readFile5, rename as rename3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 async function readLock(path) {
-  return JSON.parse(await readFile5(path, "utf8"));
+  return JSON.parse(await readFile6(path, "utf8"));
 }
 async function acquireProtocolLock(projectRoot, operation, options = {}) {
   const layout = await ensureStateLayout(projectRoot);
-  const lockPath = join6(layout.locks, "protocol.lock");
+  const lockPath = join7(layout.locks, "protocol.lock");
   const now = options.now ?? Date.now();
   const staleAfterMs = options.staleAfterMs ?? 15 * 60 * 1e3;
   const record = {
@@ -2061,22 +2096,6 @@ var MANAGED_FILES = [
   ".harness/project.yaml",
   ".harness/context-index.json"
 ];
-var INSTALLED_BUNDLE_PATH2 = ".harness/state/local/installed-harness-bundle.json";
-async function installedBundlePaths(root) {
-  try {
-    const content = await readFile6(join7(root, INSTALLED_BUNDLE_PATH2), "utf8");
-    const parsed = JSON.parse(content);
-    if (parsed.schema_version === 1 && Array.isArray(parsed.files)) {
-      return new Set(parsed.files);
-    }
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return /* @__PURE__ */ new Set();
-    }
-    throw error;
-  }
-  return /* @__PURE__ */ new Set();
-}
 async function exists3(path) {
   try {
     await lstat2(path);
@@ -2093,7 +2112,7 @@ async function walkFiles(root, current, output) {
     return;
   }
   for (const item of await readdir(current, { withFileTypes: true })) {
-    const path = join7(current, item.name);
+    const path = join8(current, item.name);
     if (item.isSymbolicLink()) {
       throw new PushWorkflowError("symlink is not pushable", 6, "UNSAFE_SYMLINK");
     }
@@ -2108,24 +2127,24 @@ async function managedFiles(projectRoot) {
   const root = resolve4(projectRoot);
   const paths = [];
   for (const path of MANAGED_FILES) {
-    if (await exists3(join7(root, path))) {
+    if (await exists3(join8(root, path))) {
       paths.push(path);
     }
   }
   for (const path of MANAGED_ROOTS) {
-    await walkFiles(root, join7(root, path), paths);
+    await walkFiles(root, join8(root, path), paths);
   }
-  const skillsRoot = join7(root, ".claude", "skills");
+  const skillsRoot = join8(root, ".claude", "skills");
   if (await exists3(skillsRoot)) {
     for (const item of await readdir(skillsRoot, { withFileTypes: true })) {
       if (item.isDirectory() && item.name.startsWith("harness-")) {
-        await walkFiles(root, join7(skillsRoot, item.name), paths);
+        await walkFiles(root, join8(skillsRoot, item.name), paths);
       }
     }
   }
   const result = {};
   for (const path of [...new Set(paths)].sort()) {
-    result[path] = await readFile6(join7(root, path), "utf8");
+    result[path] = await readFile7(join8(root, path), "utf8");
   }
   return result;
 }
@@ -2134,14 +2153,14 @@ function proposalBaseline(baseline) {
 }
 async function readProject(root) {
   try {
-    return projectConfigSchema.parse(parseYaml3(await readFile6(join7(root, ".harness", "project.yaml"), "utf8")));
+    return projectConfigSchema.parse(parseYaml3(await readFile7(join8(root, ".harness", "project.yaml"), "utf8")));
   } catch {
     throw new PushWorkflowError("project configuration is missing or invalid", 3, "PROJECT_CONFIG_INVALID");
   }
 }
 async function readOptionalJson(path) {
   try {
-    return JSON.parse(await readFile6(path, "utf8"));
+    return JSON.parse(await readFile7(path, "utf8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -2153,7 +2172,7 @@ async function clientIdFor(root, explicit) {
   if (explicit !== void 0) {
     return explicit;
   }
-  const path = join7(root, ".harness", "state", "local", "client.json");
+  const path = join8(root, ".harness", "state", "local", "client.json");
   const existing = await readOptionalJson(path);
   if (typeof existing?.client_id === "string" && /^cli_[A-Za-z0-9_-]+$/.test(existing.client_id)) {
     return existing.client_id;
@@ -2239,7 +2258,8 @@ async function pushProject(options) {
   const root = resolve4(options.projectRoot);
   let project = await readProject(root);
   let baseline = await readBaseline(root);
-  const installedPaths = await installedBundlePaths(root);
+  const profile = parseHarnessProfile(project.project.profiles[0]);
+  const installedPaths = profile === null ? /* @__PURE__ */ new Set() : await managedBundleTargets(options.resourcesRoot, profile);
   let preview = makePreview(baseline, await managedFiles(root), options.confirmedProjectLocal ?? [], installedPaths);
   if (preview.blocked) {
     throw new PushWorkflowError("sensitive information scan blocked the proposal", 6, "SENSITIVE_CONTENT_BLOCKED");
@@ -2271,7 +2291,7 @@ async function pushProject(options) {
   if (parsedServerUrl.protocol !== "https:") {
     throw new PushWorkflowError("server_url must use HTTPS", 3, "SERVER_URL_INVALID");
   }
-  const workflowPath = join7(root, ".harness", "state", "local", "push-workflow.json");
+  const workflowPath = join8(root, ".harness", "state", "local", "push-workflow.json");
   const priorWorkflow = await readOptionalJson(workflowPath);
   const provisionalRequestId = priorWorkflow?.local_project_key === project.project.local_project_key ? priorWorkflow.request_id : uuidV7();
   const lock = await acquireProtocolLock(root, "push", { requestId: provisionalRequestId });
@@ -2362,7 +2382,7 @@ async function pushProject(options) {
       }
     }
     const finalized = await client.finalizeProposal(session.session_id, { schema_version: 1, manifest_sha256: proposalManifestHash }, requestId, workflow.finalize_idempotency_key);
-    await atomicWriteJson(join7(root, ".harness", "state", "local", "push-results", finalized.proposal_id + ".json"), {
+    await atomicWriteJson(join8(root, ".harness", "state", "local", "push-results", finalized.proposal_id + ".json"), {
       schema_version: 1,
       request_id: requestId,
       project_id: projectId,
@@ -2431,10 +2451,10 @@ var AGENT_DESCRIPTORS = {
 var INSTALLABLE_AGENTS = Object.keys(AGENT_DESCRIPTORS).filter((agent) => AGENT_DESCRIPTORS[agent]?.installable === true);
 
 // ../core/dist/transaction/recovery.js
-import { readFile as readFile7, readdir as readdir2, rm as rm5, stat as stat3 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { readFile as readFile8, readdir as readdir2, rm as rm5, stat as stat3 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 async function recoverTransaction(projectRoot, transactionId) {
-  const journal = JSON.parse(await readFile7(join8(stateLayout(projectRoot).transactions, transactionId, "journal.json"), "utf8"));
+  const journal = JSON.parse(await readFile8(join9(stateLayout(projectRoot).transactions, transactionId, "journal.json"), "utf8"));
   if (journal.state === "committed") {
     return { transactionId, status: "committed" };
   }
@@ -2461,7 +2481,7 @@ async function listTransactions(projectRoot) {
   const transactions = [];
   for (const transactionId of names) {
     try {
-      const journal = JSON.parse(await readFile7(join8(root, transactionId, "journal.json"), "utf8"));
+      const journal = JSON.parse(await readFile8(join9(root, transactionId, "journal.json"), "utf8"));
       transactions.push({
         transactionId,
         kind: journal.kind,
@@ -2492,11 +2512,11 @@ async function rollbackLatestCommittedUpdate(projectRoot) {
   if (latest === void 0) {
     throw new Error("no committed update transaction is available for rollback");
   }
-  const transactionRoot = join8(stateLayout(projectRoot).transactions, latest.transactionId);
-  const journal = JSON.parse(await readFile7(join8(transactionRoot, "journal.json"), "utf8"));
-  const after = JSON.parse(await readFile7(join8(transactionRoot, "after", "manifest.json"), "utf8"));
+  const transactionRoot = join9(stateLayout(projectRoot).transactions, latest.transactionId);
+  const journal = JSON.parse(await readFile8(join9(transactionRoot, "journal.json"), "utf8"));
+  const after = JSON.parse(await readFile8(join9(transactionRoot, "after", "manifest.json"), "utf8"));
   for (const entry of after) {
-    const target = join8(projectRoot, entry.path);
+    const target = join9(projectRoot, entry.path);
     const exists5 = await pathExists(target);
     if (exists5 !== entry.exists || exists5 && await sha256File(target) !== entry.hash) {
       throw new Error("cannot rollback dirty path: " + entry.path);
@@ -2509,10 +2529,10 @@ async function rollbackLatestCommittedUpdate(projectRoot) {
       continue;
     }
     seen.add(snapshot.path);
-    const target = join8(projectRoot, snapshot.path);
+    const target = join9(projectRoot, snapshot.path);
     const exists5 = await pathExists(target);
     if (snapshot.existed && snapshot.snapshot_name !== null) {
-      const content = await readFile7(join8(transactionRoot, "before", snapshot.snapshot_name));
+      const content = await readFile8(join9(transactionRoot, "before", snapshot.snapshot_name));
       operations.push({
         operation: exists5 ? "modify" : "add",
         path: snapshot.path,
@@ -2541,7 +2561,7 @@ async function cleanupOldTransactions(projectRoot, now = /* @__PURE__ */ new Dat
     if (!removable) {
       continue;
     }
-    await rm5(join8(stateLayout(projectRoot).transactions, item.transactionId), {
+    await rm5(join9(stateLayout(projectRoot).transactions, item.transactionId), {
       recursive: true,
       force: true
     });
@@ -2573,8 +2593,8 @@ function managedBlockDirty(currentContent, managedBlockHash) {
 }
 
 // ../core/dist/update/update.js
-import { lstat as lstat3, readFile as readFile8, rm as rm6 } from "node:fs/promises";
-import { join as join9, resolve as resolve5 } from "node:path";
+import { lstat as lstat3, readFile as readFile9, rm as rm6 } from "node:fs/promises";
+import { join as join10, resolve as resolve5 } from "node:path";
 import { parse as parseYaml6 } from "yaml";
 var UpdateWorkflowError = class extends Error {
   exitCode;
@@ -2598,7 +2618,7 @@ async function pathExists2(path) {
   }
 }
 async function optionalContent(path) {
-  return await pathExists2(path) ? readFile8(path, "utf8") : null;
+  return await pathExists2(path) ? readFile9(path, "utf8") : null;
 }
 function manifestPayloadHash(manifest) {
   const payload = { ...manifest };
@@ -2616,10 +2636,10 @@ async function loadBlob(root, client, artifactId, operation, requestId, dryRun)
     return null;
   }
   const hash = operation.content_sha256;
-  const cacheRoot = join9(root, ".harness", "cache", "server-artifacts", artifactId);
-  const cachePath = join9(cacheRoot, "blobs", hash.replace(":", "_"));
+  const cacheRoot = join10(root, ".harness", "cache", "server-artifacts", artifactId);
+  const cachePath = join10(cacheRoot, "blobs", hash.replace(":", "_"));
   if (await pathExists2(cachePath) && await sha256File(cachePath) === hash) {
-    return readFile8(cachePath, "utf8");
+    return readFile9(cachePath, "utf8");
   }
   const bytes = await client.downloadArtifactBlob(artifactId, hash, requestId);
   if (bytes.byteLength !== operation.size_bytes || sha256Bytes(bytes) !== hash) {
@@ -2669,7 +2689,7 @@ async function updateProject(options) {
   const root = resolve5(options.projectRoot);
   let project;
   try {
-    project = projectConfigSchema.parse(parseYaml6(await readFile8(join9(root, ".harness", "project.yaml"), "utf8")));
+    project = projectConfigSchema.parse(parseYaml6(await readFile9(join10(root, ".harness", "project.yaml"), "utf8")));
   } catch {
     throw new UpdateWorkflowError("project configuration is invalid", 3, "PROJECT_CONFIG_INVALID");
   }
@@ -2754,8 +2774,8 @@ async function updateProject(options) {
         skipped.push({ path: target, operation: operation.operation, reason: "baseline-diverged" });
         continue;
       }
-      const sourceContent = await optionalContent(join9(root, source));
-      const targetContent = target === source ? sourceContent : await optionalContent(join9(root, target));
+      const sourceContent = await optionalContent(join10(root, source));
+      const targetContent = target === source ? sourceContent : await optionalContent(join10(root, target));
       const incoming = blobs.get(operation) ?? null;
       const incomingHash = contentHash(operation);
       let equivalent = incomingHash !== null && targetContent !== null && sha256Bytes(targetContent) === incomingHash;
@@ -2814,7 +2834,7 @@ async function updateProject(options) {
         dryRun: true
       };
     }
-    await atomicWriteJson(join9(root, ".harness", "cache", "server-artifacts", manifest.artifact_id, "manifest.json"), manifest);
+    await atomicWriteJson(join10(root, ".harness", "cache", "server-artifacts", manifest.artifact_id, "manifest.json"), manifest);
     const lock = await acquireProtocolLock(root, "update", { requestId });
     try {
       const nextBaseline = baselineManifestSchema.parse(structuredClone(baseline));
@@ -2895,8 +2915,8 @@ async function updateProject(options) {
 }
 
 // src/config/init-config.ts
-import { isAbsolute as isAbsolute2, join as join10 } from "node:path";
-import { readFile as readFile9 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join11 } from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
 var InitConfigurationError = class extends Error {
   exitCode;
   constructor(message, exitCode = 3, options) {
@@ -2914,9 +2934,9 @@ function normalizeProfile(value) {
 async function resolveInitConfig(cwd, flags, promptMissing) {
   let fileConfig = {};
   if (flags.config !== void 0) {
-    const path = isAbsolute2(flags.config) ? flags.config : join10(cwd, flags.config);
+    const path = isAbsolute2(flags.config) ? flags.config : join11(cwd, flags.config);
     try {
-      fileConfig = JSON.parse(await readFile9(path, "utf8"));
+      fileConfig = JSON.parse(await readFile10(path, "utf8"));
     } catch (error) {
       throw new InitConfigurationError(
         "unable to read init config: " + (error instanceof Error ? error.message : String(error)),
@@ -3027,6 +3047,7 @@ async function runPush(options, dependencies) {
   try {
     const result = await pushProject({
       projectRoot: dependencies.cwd,
+      resourcesRoot: dependencies.resourcesRoot,
       ...options.serverUrl === void 0 ? {} : { serverUrl: options.serverUrl },
       ...options.tokenEnv === void 0 ? {} : { tokenEnv: options.tokenEnv },
       env: dependencies.env,
@@ -3188,7 +3209,7 @@ async function runUpdate(options, dependencies) {
 
 // src/commands/recovery.ts
 import { stat as stat4 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 async function exists4(path) {
   try {
     await stat4(path);
@@ -3248,7 +3269,7 @@ async function runRecoveryMenuIfApplicable(options, dependencies) {
       return 5;
     }
   }
-  const initialized = await exists4(join11(dependencies.cwd, ".harness", "project.yaml"));
+  const initialized = await exists4(join12(dependencies.cwd, ".harness", "project.yaml"));
   if (!initialized || options.nonInteractive === true || explicitConfigure(options)) {
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hunter-harness",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Local-first, server-governed agent harness",
   "license": "MIT",
   "type": "module",
@@ -8,7 +8,7 @@
     "node": ">=24.0.0"
   },
   "bin": {
-    "hunter-harness": "./dist/bin.js"
+    "hunter-harness": "dist/bin.js"
   },
   "files": [
     "dist/bin.js",

package/resources/harness/general/.harness-build.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
   "overlay": "none",
-  "coreHash": "63af4c482d21b6be"
+  "coreHash": "76dd32302df53f0b"
 }