@gethmy/harness 1.1.1 → 1.2.1

package/dist/cli.js

@@ -36,6 +36,14 @@ var init_branchRef = __esm(() => {
 // ../harmony-shared/dist/cardLinks.js
 var init_cardLinks = () => {};
 // ../harmony-shared/dist/classification.js
+function tierFromScore(score) {
+  const s = Math.max(0, Math.min(10, Math.round(score)));
+  if (s <= 2)
+    return "simple";
+  if (s <= 6)
+    return "advanced";
+  return "research";
+}
 function escalateTier(tier) {
   const i = MODEL_TIERS.indexOf(tier);
   return MODEL_TIERS[Math.min(i + 1, MODEL_TIERS.length - 1)];
@@ -73,6 +81,31 @@ var init_constants = __esm(() => {
     QUERY_GC_TIME: 1000 * 60 * 60 * 24
   };
 });
+// ../harmony-shared/dist/fanoutSource.js
+var FANOUT_KEY_MARKER = "harmony:fanout-item", FANOUT_KEY_RE;
+var init_fanoutSource = __esm(() => {
+  FANOUT_KEY_RE = new RegExp(`^\\[${FANOUT_KEY_MARKER}\\]:\\s*#(\\S+)\\s*$`, "m");
+});
+// ../harmony-shared/dist/gateConfigError.js
+function gateConfigErrorReason(evaluation) {
+  if (!evaluation || evaluation.passed)
+    return null;
+  const structured = evaluation.structured;
+  if (!structured || typeof structured !== "object")
+    return null;
+  if (!Object.hasOwn(structured, GATE_CONFIG_ERROR_KEY))
+    return null;
+  if (structured[GATE_CONFIG_ERROR_KEY] !== true) {
+    return null;
+  }
+  const reason = structured.reason;
+  return typeof reason === "string" && reason.trim().length > 0 ? reason.trim() : "the gate cannot be measured as configured";
+}
+var GATE_CONFIG_ERROR_KEY = "configError", GATE_CONFIG_ERROR_MARK;
+var init_gateConfigError = __esm(() => {
+  GATE_CONFIG_ERROR_MARK = Object.freeze({ [GATE_CONFIG_ERROR_KEY]: true });
+});
+
 // ../harmony-shared/dist/gateEvaluate.js
 function isGateKind(value) {
   return typeof value === "string" && GATE_KINDS.includes(value);
@@ -468,6 +501,8 @@ var init_dist = __esm(() => {
   init_columnSort();
   init_commentSerializer();
   init_constants();
+  init_fanoutSource();
+  init_gateConfigError();
   init_gateEvaluate();
   init_logger();
   init_playbookAutoBind();
@@ -579,17 +614,18 @@ var RETIRED_MODEL = /^claude-[23][.-]/i;
 function clampWithdrawn(model) {
   return RETIRED_MODEL.test(model) ? MAX_IMPLEMENT_MODEL : model;
 }
-function chooseImplementModel(claude, card, attempts) {
+function chooseImplementModel(claude, card, attempts, sized) {
   if (card.model_override) {
+    const pinned = isModelTier(card.model_override) ? claude.tiers?.[card.model_override] || claude.model : card.model_override;
     return {
-      model: clampWithdrawn(card.model_override),
+      model: clampWithdrawn(pinned),
       escalated: false,
       source: "override"
     };
   }
-  if (isModelTier(card.model_tier)) {
+  if (sized && isModelTier(sized.tier)) {
     const retry = attempts >= claude.escalateAfterAttempts;
-    const tier = retry ? escalateTier(card.model_tier) : card.model_tier;
+    const tier = retry ? escalateTier(sized.tier) : sized.tier;
     const mapped = claude.tiers?.[tier];
     return {
       model: clampWithdrawn(mapped && mapped.length > 0 ? mapped : claude.model),
@@ -821,13 +857,15 @@ class SdkAgentRunner {
     };
     const allowed = this.cfg.allowedTools ?? SDK_ALLOWED_TOOLS;
     const builtinTools = allowed.filter((t) => !t.startsWith("mcp__") && !t.includes("*"));
+    const gateEach = this.cfg.gateEveryToolCall === true;
     const options = {
       cwd: input.cwd,
       model: input.model ?? this.cfg.model,
-      allowedTools: allowed,
+      ...gateEach ? {} : { allowedTools: allowed },
       ...this.cfg.disallowedTools && this.cfg.disallowedTools.length > 0 ? { disallowedTools: this.cfg.disallowedTools } : {},
+      ...this.cfg.canUseTool ? { canUseTool: this.cfg.canUseTool } : {},
       tools: builtinTools,
-      permissionMode: "dontAsk",
+      permissionMode: gateEach ? "default" : "dontAsk",
       maxTurns: this.cfg.maxTurns,
       abortController: this.abort,
       ...resumeSessionId ? { resume: resumeSessionId } : {},
@@ -1250,22 +1288,7 @@ init_dist();
 var DEFAULT_METRIC_TIMEOUT_MS = 300000;
 
 // src/gate-config-error.ts
-var GATE_CONFIG_ERROR_KEY = "configError";
-var GATE_CONFIG_ERROR_MARK = Object.freeze({ [GATE_CONFIG_ERROR_KEY]: true });
-function gateConfigErrorReason(evaluation) {
-  if (!evaluation || evaluation.passed)
-    return null;
-  const structured = evaluation.structured;
-  if (!structured || typeof structured !== "object")
-    return null;
-  if (!Object.hasOwn(structured, GATE_CONFIG_ERROR_KEY))
-    return null;
-  if (structured[GATE_CONFIG_ERROR_KEY] !== true) {
-    return null;
-  }
-  const reason = structured.reason;
-  return typeof reason === "string" && reason.trim().length > 0 ? reason.trim() : "the gate cannot be measured as configured";
-}
+init_dist();
 
 // src/command-metric.ts
 init_log();
@@ -1523,6 +1546,7 @@ init_log();
 
 // src/oracle-collector.ts
 init_log();
+import { createHash } from "node:crypto";
 var TAG4 = "oracle-collector";
 
 class OracleCollector {
@@ -1545,6 +1569,10 @@ class OracleCollector {
     return await this.runHeld(oracle);
   }
   async runHeld(oracle) {
+    const identity = {
+      oracleId: oracle.id ?? null,
+      contentHash: createHash("sha256").update(oracle.content).digest("hex")
+    };
     await this.deps.place(this.deps.repoPath, oracle);
     try {
       const { exitCode, output } = await this.deps.run(this.deps.repoPath, oracle);
@@ -1561,6 +1589,7 @@ ${output}`;
           oracle: {
             exitCode,
             path: oracle.path,
+            ...identity,
             output: "withheld — oracle_passed is a secrecy gate; see the motor's local log"
           }
         }
@@ -1570,7 +1599,10 @@ ${output}`;
       log.warn(TAG4, `Oracle run threw: ${message} — blocked`);
       return {
         result: "blocked",
-        structured: { oracle: { path: oracle.path }, error: message }
+        structured: {
+          oracle: { path: oracle.path, ...identity },
+          error: message
+        }
       };
     } finally {
       await this.removeBestEffort(oracle);
@@ -2495,6 +2527,7 @@ class HarmonyClient {
     }
     const body = await response.json();
     return {
+      id: body.id ?? null,
       path: body.path,
       content: body.content,
       runnerHint: body.runnerHint ?? null
@@ -2516,6 +2549,60 @@ async function detail(response) {
 // src/cli.ts
 init_log();
 
+// src/motor-stream.ts
+var RELAYED_KINDS = new Set([
+  "run_started",
+  "assistant_text",
+  "tool_started",
+  "tool_ended",
+  "cost_updated",
+  "error",
+  "run_finished"
+]);
+var MOTOR_TOOL_INPUT_VALUE_MAX = 400;
+var MOTOR_TOOL_INPUT_KEY_MAX = 24;
+function boundToolInput(input) {
+  if (typeof input === "string") {
+    return input.slice(0, MOTOR_TOOL_INPUT_VALUE_MAX);
+  }
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    return typeof input === "number" || typeof input === "boolean" ? input : undefined;
+  }
+  const bounded = {};
+  let kept = 0;
+  for (const [key, value] of Object.entries(input)) {
+    if (kept >= MOTOR_TOOL_INPUT_KEY_MAX)
+      break;
+    const boundedKey = key.slice(0, MOTOR_TOOL_INPUT_VALUE_MAX);
+    if (typeof value === "string") {
+      bounded[boundedKey] = value.slice(0, MOTOR_TOOL_INPUT_VALUE_MAX);
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      bounded[boundedKey] = value;
+    } else {
+      continue;
+    }
+    kept++;
+  }
+  return bounded;
+}
+function relayAgentEvent(draft) {
+  if (!RELAYED_KINDS.has(draft.kind))
+    return null;
+  if (draft.kind === "tool_started") {
+    return {
+      type: "agent_event",
+      event: {
+        ...draft,
+        payload: {
+          ...draft.payload,
+          input: boundToolInput(draft.payload.input)
+        }
+      }
+    };
+  }
+  return { type: "agent_event", event: draft };
+}
+
 // src/oracle.ts
 import { lstat, mkdir, realpath, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
@@ -2670,6 +2757,10 @@ function mayHoldCredentials(role) {
 function credentialReadDeny() {
   return `Read(/${getConfigDir()}/**)`;
 }
+function credentialAccessDeny() {
+  const dir = `/${getConfigDir()}/**`;
+  return [`Read(${dir})`, `Grep(${dir})`, `Glob(${dir})`];
+}
 function buildRoleLaunch(args) {
   const role = normalizeStageRole(args.role);
   const keep = mayHoldCredentials(role);
@@ -2780,7 +2871,9 @@ function oracleWriteAddendum(input) {
     }, null, 2),
     "```",
     "",
-    "Constraints: `path` is repo-relative ([A-Za-z0-9._-] per segment, no `..`, no dot-prefixed segment, no absolute path); `content` <= 100 KB; `runnerHint` is `bun` or `vitest`. Do NOT commit the oracle file — the motor places and removes it at the gated stage."
+    "Constraints: `path` is repo-relative ([A-Za-z0-9._-] per segment, no `..`, no dot-prefixed segment, no absolute path); `content` <= 100 KB; `runnerHint` is `bun` or `vitest`. Do NOT commit the oracle file — the motor places and removes it at the gated stage.",
+    "",
+    'If the POST answers 409, an oracle for that stage is already held — another author wrote it, and replacing it changes the contract the implementer is graded against. Only if replacing it is genuinely this stage\'s instruction (e.g. a deliberate re-author), re-send the same body plus `"replace": true`; the replacement is recorded on the card, naming both authors. Otherwise stop and report the conflict instead of replacing.'
   ].join(`
 `);
 }
@@ -2791,7 +2884,7 @@ function buildStagePrompt(args) {
     `## Playbook stage: ${stageName}`,
     `You are running the "${stageName}" stage for Harmony card ${args.cardId}.`,
     entryAction ? `Stage skill / entry action: \`${entryAction}\`. Follow that skill's method for this stage.` : "Read the card with the Harmony MCP tools (`harmony_get_card`) and do this stage's work for it.",
-    "Do only this stage's work, then stop. Do not move the card, do not advance the stage, and do not end your agent session — the driver that invoked this stage owns all three.",
+    "Do only this stage's work, then stop. Do not move the card, do not advance the stage, and do not end your agent session — the driver that invoked this stage owns all three. Those tools are disabled for this run, so attempting them only wastes turns.",
     STAGE_SCOPE_LINE
   ];
   if (args.stage?.role === "author" && args.oracleTargetStageId && args.sessionId) {
@@ -2843,24 +2936,46 @@ function buildStageRunnerConfig(args) {
     prompt: launch.prompt,
     cwd: launch.repoPath,
     config: {
-      disallowedTools: launch.disallowedTools,
+      disallowedTools: [...launch.disallowedTools, ...STAGE_DAEMON_OWNED_TOOLS],
       stripEnvKeys: envKeysDroppedByLaunch(args.parentEnv, launch)
     }
   };
 }
+var DEFAULT_STAGE_TIMEOUT_MS = 2700000;
+var MAX_TIMER_MS = 2147483647;
+function stageTimeoutMs(env) {
+  const raw = env.HARMONY_HARNESS_STAGE_TIMEOUT_MS;
+  if (raw === undefined || raw.trim() === "")
+    return DEFAULT_STAGE_TIMEOUT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed))
+    return DEFAULT_STAGE_TIMEOUT_MS;
+  return Math.min(parsed, MAX_TIMER_MS);
+}
+function describeShutdown(signal, hasRunner) {
+  return {
+    message: hasRunner ? `the harness motor received ${signal} and stopped its stage subagent` : `the harness motor received ${signal} with no stage subagent in flight`,
+    stopSubagent: hasRunner
+  };
+}
 
 // src/stage-run.ts
 async function runStage(request, deps) {
-  const events = [
-    { type: "stage_entered", stageId: request.stageId }
-  ];
+  const events = [];
+  const emit2 = (event) => {
+    events.push(event);
+    try {
+      deps.emit?.(event);
+    } catch {}
+  };
+  emit2({ type: "stage_entered", stageId: request.stageId });
   const gate = await deps.resolveGate(request);
   await deps.runRole(request);
   if (!gate) {
     return { stageId: request.stageId, gateKind: null, evidence: null, events };
   }
   const evidence = await deps.collect(request, gate);
-  events.push({
+  emit2({
     type: "gate_evaluated",
     stageId: request.stageId,
     gateKind: gate.kind,
@@ -2872,7 +2987,27 @@ async function runStage(request, deps) {
 // src/cli.ts
 var TAG11 = "cli";
 var GATE_VERIFICATION_TIMEOUT_MS = 600000;
-async function runRole(request, prompt) {
+var SHUTDOWN_HARD_EXIT_MS = 15000;
+var activeRunner = null;
+var shuttingDown = false;
+async function shutdown(signal) {
+  if (shuttingDown)
+    return;
+  shuttingDown = true;
+  const runner = activeRunner;
+  const plan = describeShutdown(signal, runner !== null);
+  process.stderr.write(`${JSON.stringify({ type: "error", message: plan.message })}
+`);
+  const hardExit = setTimeout(() => process.exit(1), SHUTDOWN_HARD_EXIT_MS);
+  hardExit.unref?.();
+  if (plan.stopSubagent) {
+    try {
+      await runner?.stop("shutdown");
+    } catch {}
+  }
+  process.exit(1);
+}
+async function runRole(request, prompt, emit2) {
   const launch = buildStageRunnerConfig({
     role: request.role,
     prompt,
@@ -2880,21 +3015,50 @@ async function runRole(request, prompt) {
     parentEnv: process.env
   });
   const runner = new SdkAgentRunner(launch.config);
+  activeRunner = runner;
   log.info(TAG11, `Running stage ${request.stageId} as role ${launch.role ?? "(none — fail-closed)"}`);
-  for await (const event of runner.start({
-    sessionId: request.sessionId,
-    cardId: request.cardId,
-    workspaceId: request.workspaceId,
-    prompt: launch.prompt,
-    cwd: launch.cwd
-  })) {
-    if (event.kind === "error") {
-      log.warn(TAG11, `subagent error: ${event.payload.message}`);
-    } else {
-      log.debug(TAG11, `subagent ${event.kind}`);
+  const timeoutMs = stageTimeoutMs(process.env);
+  let timedOut = false;
+  const clock = timeoutMs > 0 ? setTimeout(() => {
+    timedOut = true;
+    log.warn(TAG11, `stage ${request.stageId} exceeded ${timeoutMs}ms — stopping the subagent`);
+    runner.stop("timeout");
+  }, timeoutMs) : null;
+  clock?.unref?.();
+  try {
+    for await (const event of runner.start({
+      sessionId: request.sessionId,
+      cardId: request.cardId,
+      workspaceId: request.workspaceId,
+      prompt: launch.prompt,
+      cwd: launch.cwd
+    })) {
+      const relayed = relayAgentEvent(event);
+      if (relayed)
+        emit2(relayed);
+      if (event.kind === "error") {
+        log.warn(TAG11, `subagent error: ${event.payload.message}`);
+      } else {
+        log.event(TAG11, `subagent ${event.kind}`);
+      }
     }
+  } finally {
+    if (clock)
+      clearTimeout(clock);
+    activeRunner = null;
+  }
+  if (timedOut) {
+    throw new Error(`stage ${request.stageId} exceeded its ${timeoutMs}ms wall-clock bound and its subagent was stopped`);
   }
 }
+function emitLine(line) {
+  try {
+    process.stdout.write(`${JSON.stringify(line)}
+`);
+  } catch {}
+}
+process.stdout.on("error", () => {});
+process.stderr.on("error", () => {});
 async function main() {
   const parsed = parseStageRunArgs(process.argv.slice(2));
   if (!parsed.ok) {
@@ -2937,8 +3101,9 @@ ${STAGE_RUN_USAGE}
     role: pinned.stage.role ?? null
   };
   const result = await runStage(request, {
+    emit: emitLine,
     resolveGate: async () => pinned.gate,
-    runRole: (req) => runRole(req, prompt),
+    runRole: (req) => runRole(req, prompt, emitLine),
     collect: async (req, gate) => {
       const registry = buildGateCollectorRegistry({
         build: {
@@ -2967,10 +3132,6 @@ ${STAGE_RUN_USAGE}
       });
     }
   });
-  for (const event of result.events) {
-    process.stdout.write(`${JSON.stringify(event)}
-`);
-  }
   if (result.evidence && pinned.gate) {
     const context = {
       cardId,
@@ -2980,11 +3141,18 @@ ${STAGE_RUN_USAGE}
     };
     const evaluation = gateEvaluate(pinned.gate, result.evidence);
     await client.recordStageGateEvidence(toStageGateEvidenceInsert(context, result.evidence));
-    process.stdout.write(`${JSON.stringify({ type: "gate_verdict", passed: evaluation.passed, findings: evaluation.findings })}
-`);
+    emitLine({
+      type: "gate_verdict",
+      passed: evaluation.passed,
+      findings: evaluation.findings
+    });
   }
-  process.stdout.write(`${JSON.stringify({ type: "result", ...result })}
-`);
+  emitLine({ type: "result", ...result });
+}
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    shutdown(signal);
+  });
 }
 main().catch((err) => {
   const message = err instanceof Error ? err.message : String(err);