harnery 0.31.6 → 0.33.0

package/src/core/governor/planning.ts

@@ -47,7 +47,9 @@ const MAX_RECORD_BYTES = 256 * 1024;
 const MAX_EVENTS_BYTES = 512 * 1024;
 const MAX_REASON = 2_000;
 const PROPOSAL_ROOT_RULE =
-  "proposal.root names one newly proposed work key using a root-capable template; it does not preserve or repeat active_root, which is context only";
+  "proposal.root is inferred by Harnery as the single final outcome that no other proposed item depends on; it must use a root-capable template and depend transitively on every other proposed item; it never preserves or repeats active_root, which is context only";
+const PLANNER_ROOT_RULE =
+  "Dependencies point from later work to earlier prerequisites. Do not return proposal.root. Harnery infers it as the single final outcome that no other proposed item depends on; make that outcome use a root-capable template and depend transitively on every other proposed item.";
 
 export interface RunGovernorPlannerInput {
   coordRoot: string;
@@ -729,7 +731,7 @@ function plannerScript(
       : "Return decision=apply with a replacement immutable root graph, or decision=attention when human judgment is required.",
     "Never claim mission completion unless the frozen mission acceptance is met. Never request a workflow outside the frozen template catalog.",
     "Dependencies may name an active work ID or an earlier key in your proposed work array.",
-    `Every proposed item must be reachable from root. ${PROPOSAL_ROOT_RULE}.`,
+    PLANNER_ROOT_RULE,
     "Work keys are lowercase identifiers no longer than 32 characters. Keep titles within 200 characters, objectives within 4000 characters, and each acceptance criterion within 500 characters.",
     `Plan id: ${planId}`,
     `Planning trigger: ${trigger}`,
@@ -1331,12 +1333,6 @@ function planProposalSchema(
   const applyProperties: Record<string, StageSchema> = {
     decision: { type: "string", enum: ["apply"] },
     rationale,
-    root: {
-      type: "string",
-      minLength: 1,
-      maxLength: 32,
-      pattern: "^[a-z][a-z0-9-]{0,31}$",
-    },
     work: {
       type: "array",
       minItems: 1,
@@ -1344,7 +1340,7 @@ function planProposalSchema(
       items: workItem,
     },
   };
-  const applyRequired = ["decision", "rationale", "root", "work"];
+  const applyRequired = ["decision", "rationale", "work"];
   if (record.intent.mission) {
     applyProperties.milestone = milestone;
     applyRequired.push("milestone");
@@ -1390,10 +1386,10 @@ function normalizeProposal(
   const proposedAt = preservedProposedAt ?? new Date().toISOString();
   const decision = enumValue(value.decision, ["apply", "complete", "attention"], "plan decision");
   const rationale = bounded(value.rationale, "plan rationale", MAX_REASON);
-  const root = typeof value.root === "string" ? value.root.trim() : "";
+  const terminalRoot = typeof value.root === "string" ? value.root.trim() : "";
   if (!Array.isArray(value.work)) throw new Error("plan work must be an array");
   if (decision === "attention" || decision === "complete") {
-    if (root || value.work.length > 0 || value.milestone !== undefined) {
+    if (terminalRoot || value.work.length > 0 || value.milestone !== undefined) {
       throw new Error(`${decision} plan must not contain work or milestone data`);
     }
     if (decision === "complete" && (!record.intent.mission || trigger !== "milestone")) {
@@ -1473,7 +1469,16 @@ function normalizeProposal(
       template,
     };
   });
-  if (!seen.has(root)) throw new Error(`plan root ${root || "(empty)"} is not a proposed key`);
+  const dependedOn = new Set(
+    work.flatMap((item) => item.dependencies.filter((dependency) => seen.has(dependency))),
+  );
+  const terminalOutcomes = work.filter((item) => !dependedOn.has(item.key));
+  if (terminalOutcomes.length !== 1) {
+    throw new Error(
+      `plan must have exactly one final outcome; found ${terminalOutcomes.map((item) => item.key).join(", ")}`,
+    );
+  }
+  const root = terminalOutcomes[0]!.key;
   const rootSpec = work.find((item) => item.key === root);
   if (!rootSpec || !policy.templates[rootSpec.template]?.root) {
     throw new Error(`plan root ${root} must use a root-capable template`);

package/src/core/hooks/adapter/detect.ts

@@ -4,32 +4,23 @@ import type { Adapter } from "../events/schema.ts";
 /**
  * Resolve the adapter firing the hook. The dispatcher binary is always
  * invoked with `--adapter <name>` per the current wiring in each adapter's
- * settings file. `--harness` remains an accepted alias because settings files
- * written by older releases survive a package upgrade until the consumer
- * re-runs `harn init`. Returns null when neither flag is present; caller falls
- * through to the env-based fallback or skips emission.
+ * settings file. Returns null when the flag is absent; caller falls through to
+ * the environment fallback or skips emission.
  */
 export function detectAdapter(argv: readonly string[]): Adapter | null {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]!;
-    if (a === "--adapter" || a === "--harness") {
+    if (a === "--adapter") {
       return validate(argv[i + 1]);
     }
     if (a.startsWith("--adapter=")) {
       return validate(a.slice("--adapter=".length));
     }
-    if (a.startsWith("--harness=")) {
-      return validate(a.slice("--harness=".length));
-    }
   }
-  return validate(coordEnv("AGENT_COORD_ADAPTER") ?? coordEnv("AGENT_COORD_HARNESS"));
+  return validate(coordEnv("AGENT_COORD_ADAPTER"));
 }
 
 function validate(v: string | undefined): Adapter | null {
   if (v === "claude-code" || v === "cursor" || v === "codex") return v;
-  // Legacy: some adapters use `claude_code` (underscore). Map
-  // it through so the env-based fallback works for callers that haven't
-  // updated yet.
-  if (v === "claude_code") return "claude-code";
   return null;
 }

package/src/core/hooks/adapter/events.ts

@@ -87,6 +87,7 @@ export const CURSOR_EVENTS: HookEvent[] = [
 export const CODEX_EVENTS: HookEvent[] = [
   { settingsKey: "SessionStart", subcommand: "session-start" },
   { settingsKey: "PreToolUse", subcommand: "pre-tool-use" },
+  { settingsKey: "PermissionRequest", subcommand: "permission-request" },
   { settingsKey: "PostToolUse", subcommand: "post-tool-use" },
   { settingsKey: "UserPromptSubmit", subcommand: "user-prompt-submit" },
   { settingsKey: "SubagentStart", subcommand: "sub-agent-start" },

package/src/core/hooks/adapter/output.ts

@@ -19,7 +19,7 @@
  */
 
 import { STOP_REMEDIATION_MARKER } from "../../agents/rules/stop-hook.ts";
-import { resolveBinName } from "../../config.ts";
+import { endOfTurnStatusCommand, resolveBinName } from "../../config.ts";
 import type { Adapter } from "../events/schema.ts";
 
 export type SystemEvent = "SessionStart" | "UserPromptSubmit" | "SubagentStart";
@@ -60,7 +60,11 @@ export function emitDeny(adapter: Adapter, reason: string): void {
  *   We exit 0 so Cursor treats the run as a success and honors the output.
  *   (Confirmed against cursor.com/docs/agent/hooks.)
  */
-export function emitStopBlock(adapter: Adapter, verdict: { reason?: string; rule: string }): 0 | 2 {
+export function emitStopBlock(
+  adapter: Adapter,
+  verdict: { reason?: string; rule: string },
+  coordRoot?: string,
+): 0 | 2 {
   if (adapter === "codex") return 0;
 
   const reason = verdict.reason ?? "End-of-turn coordination ritual incomplete.";
@@ -70,11 +74,12 @@ export function emitStopBlock(adapter: Adapter, verdict: { reason?: string; rule
     // see in chat that the message came from Harnery rather than from them.
     // Both commands are named because one message that repairs the whole ritual
     // ends the chain in a single followup; the failing rule is context.
-    const bin = resolveBinName();
+    const bin = resolveBinName(coordRoot);
+    const statusCommand = endOfTurnStatusCommand(coordRoot);
     const message = [
       `${STOP_REMEDIATION_MARKER} rule=${verdict.rule}]`,
       reason,
-      `Repair the ritual in this turn: run \`${bin} agents set-task "<short focus>"\` and then \`${bin} agents status\` as your last tool call.`,
+      `Repair the ritual in this turn: run \`${bin} agents set-task "<short focus>"\` and then \`${statusCommand}\` as your last tool call.`,
     ].join("\n");
     process.stdout.write(`${JSON.stringify({ followup_message: message })}\n`);
     return 0;

package/src/core/hooks/adapter/parse.ts

@@ -178,6 +178,8 @@ export function normalizeEventName(
     case "pre-tool-use":
     case "before-shell-execution":
       return { event_type: "tool.pre_use", intra_turn: true };
+    case "permission-request":
+      return { event_type: "interaction.input_requested", intra_turn: true };
     case "post-tool-use":
       return { event_type: "tool.post_use", intra_turn: true };
     case "post-tool-use-failure":
@@ -199,6 +201,7 @@ export type NormalizedEventType =
   | "subagent.start"
   | "subagent.stop"
   | "tool.pre_use"
+  | "interaction.input_requested"
   | "tool.post_use"
   | "tool.post_use_failure"
   | "context.compaction.started"

package/src/core/hooks/adapter/wiring.ts

@@ -200,6 +200,49 @@ export function loadAdapterWiring(projectRoot: string): AdapterWiringStatus[] {
   return out;
 }
 
+export interface AdapterWiringSummary {
+  /** Adapters carrying at least one harnery hook. */
+  wired: AdapterId[];
+  /**
+   * Adapters carrying none: no settings file at all, or a settings file with
+   * none of ours in it. An unparseable file lands in neither list, since
+   * `loadAdapterWiring` already reports that as drift.
+   */
+  unwired: AdapterId[];
+}
+
+/**
+ * Classify every known adapter as wired or unwired, without judging whether an
+ * unwired one is a problem.
+ *
+ * `loadAdapterWiring` stays deliberately silent about an adapter with zero
+ * harnery hooks, because a bare settings file is not an opt-out signal and
+ * nagging about it would false-warn every session. That silence is right in
+ * isolation and wrong once you also know the adapter's CLI is installed: then
+ * an agent can start a session here and register nothing. Splitting the fact
+ * from the judgement lets a caller holding both (doctor) tell "not used here"
+ * from "never wired" without changing what counts as drift.
+ */
+export function summarizeAdapterWiring(projectRoot: string): AdapterWiringSummary {
+  const wired: AdapterId[] = [];
+  const unwired: AdapterId[] = [];
+  for (const [id, spec] of Object.entries(ADAPTER_SPECS) as [AdapterId, AdapterSpec][]) {
+    const settingsPath = resolve(projectRoot, spec.settingsFile);
+    if (!existsSync(settingsPath)) {
+      unwired.push(id);
+      continue;
+    }
+    let settings: SettingsFile;
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8")) as SettingsFile;
+    } catch {
+      continue; // unparseable → already surfaced by loadAdapterWiring
+    }
+    (diffWiring(settings, spec).present.length > 0 ? wired : unwired).push(id);
+  }
+  return { wired, unwired };
+}
+
 /**
  * Resolve the harnery package version for context in nudges/checks. Walks up
  * from this module to the package root (works under Bun from `src/` and Node