harnery 0.30.0 → 0.31.1

package/src/commands/checkpoint.ts

@@ -0,0 +1,196 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import { monorepoRoot, readHeartbeat, resolveOwner } from "../core/agents/index.ts";
+import {
+  type CheckpointReason,
+  checkpointContext,
+  readContextState,
+  readLatestCapsule,
+} from "../core/context/index.ts";
+import type { Adapter } from "../core/hooks/events/schema.ts";
+
+/**
+ * `harn checkpoint`: durable context continuity across compaction.
+ *
+ * A checkpoint captures enough of the current work that a fresh generation of
+ * the same session can resume it after the adapter compacts or restarts.
+ * `create` writes a capsule, `show` prints the latest one, `status` reports the
+ * phase, generation, and whatever context telemetry the adapter supplied.
+ */
+export function registerCheckpointCommand(
+  program: Command,
+  emit: EmitContext,
+  context?: HarneryProgramContext,
+): void {
+  const command = program
+    .command("checkpoint")
+    .description(
+      "Durable context-continuity capsules: create one, show the latest, or report continuity phase.",
+    )
+    .option("--json", "Structured JSON output");
+
+  command
+    .command("status")
+    .description("Show context-continuity phase, generation, and latest telemetry")
+    .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
+    .option("--instance <id>", "Agent instance id (defaults to the current owner)")
+    .option("--json", "Structured JSON output")
+    .action((opts: { session?: string; instance?: string; json?: boolean }) => {
+      try {
+        const json = opts.json || Boolean(command.opts().json);
+        const identity = resolveContinuityIdentity(context, opts);
+        const state = readContextState(identity.coordRoot, identity.sessionId);
+        if (json) {
+          emit.config({ format: "json" });
+          emit.data({ state, identity });
+          return;
+        }
+        if (!state) {
+          emit.text(`No context continuity state for session ${identity.sessionId}.\n`);
+          return;
+        }
+        const sample = state.latest_context;
+        const usage = sample
+          ? `${sample.used_tokens ?? "?"}/${sample.window_tokens ?? "?"} tokens${sample.used_percent === undefined ? "" : ` (${sample.used_percent}%)`}`
+          : "not reported by adapter";
+        emit.text(
+          `${[
+            `Session:    ${state.session_id}`,
+            `Phase:      ${state.phase}`,
+            `Generation: ${state.generation}`,
+            `Telemetry:  ${usage}`,
+            `Capsule:    ${state.latest_capsule ?? "none"}`,
+            state.degraded_reason ? `Degraded:   ${state.degraded_reason}` : "",
+          ]
+            .filter(Boolean)
+            .join("\n")}\n`,
+        );
+      } catch (err) {
+        emitCommandError(emit, "checkpoint_status_failed", err);
+      }
+    });
+
+  command
+    .command("create")
+    .description("Create a durable context-continuity capsule for the current work")
+    .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
+    .option("--instance <id>", "Agent instance id (defaults to the current owner)")
+    .option("--adapter <id>", "claude-code, codex, or cursor (inferred from heartbeat)")
+    .option("--reason <reason>", "manual, pressure, pre_compact, or session_end", "manual")
+    .option("--note <text>", "Short continuation note for the recovered agent")
+    .option("--json", "Structured JSON output")
+    .action(
+      (opts: {
+        session?: string;
+        instance?: string;
+        adapter?: string;
+        reason: string;
+        note?: string;
+        json?: boolean;
+      }) => {
+        try {
+          const json = opts.json || Boolean(command.opts().json);
+          const reason = parseCheckpointReason(opts.reason);
+          const identity = resolveContinuityIdentity(context, opts);
+          if (!identity.adapter) {
+            throw new Error("could not infer the adapter; pass --adapter claude-code|codex|cursor");
+          }
+          const result = checkpointContext(identity.coordRoot, {
+            sessionId: identity.sessionId,
+            instanceId: identity.instanceId,
+            adapter: identity.adapter,
+            cwd: context?.repoRoot ?? process.cwd(),
+            reason,
+            continuationNote: opts.note,
+          });
+          const output = {
+            capsule_id: result.capsule.capsule_id,
+            generation: result.capsule.generation,
+            path: result.state.latest_capsule,
+            phase: result.state.phase,
+            reused: result.reused,
+          };
+          if (json) {
+            emit.config({ format: "json" });
+            emit.data(output);
+            return;
+          }
+          emit.text(
+            `Checkpointed context generation ${output.generation}: ${output.path ?? result.path}\n`,
+          );
+        } catch (err) {
+          emitCommandError(emit, "checkpoint_create_failed", err);
+        }
+      },
+    );
+
+  command
+    .command("show")
+    .description("Show the latest durable context-continuity capsule")
+    .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
+    .option("--instance <id>", "Agent instance id (defaults to the current owner)")
+    .option("--json", "Structured JSON output")
+    .action((opts: { session?: string; instance?: string; json?: boolean }) => {
+      try {
+        const json = opts.json || Boolean(command.opts().json);
+        const identity = resolveContinuityIdentity(context, opts);
+        const capsule = readLatestCapsule(identity.coordRoot, identity.sessionId);
+        if (!capsule) {
+          throw new Error(`no context capsule exists for session ${identity.sessionId}`);
+        }
+        if (json) emit.config({ format: "json" });
+        emit.data(capsule);
+      } catch (err) {
+        emitCommandError(emit, "checkpoint_show_failed", err);
+      }
+    });
+}
+
+function resolveContinuityIdentity(
+  context: HarneryProgramContext | undefined,
+  opts: { session?: string; instance?: string; adapter?: string },
+): { coordRoot: string; instanceId: string; sessionId: string; adapter: Adapter | null } {
+  const coordRoot = context?.resolveCoordRoot?.() ?? context?.repoRoot ?? monorepoRoot();
+  if (!coordRoot) throw new Error("could not resolve a project containing .harnery/");
+  const instanceId = opts.instance ?? resolveOwner();
+  if (!instanceId) {
+    throw new Error("could not resolve the current agent; pass --instance and --session");
+  }
+  const heartbeat = readHeartbeat(instanceId);
+  const sessionId = opts.session ?? heartbeat?.session_id ?? instanceId;
+  const adapter = opts.adapter
+    ? parseAdapter(opts.adapter)
+    : adapterFromPlatform(heartbeat?.platform);
+  return { coordRoot, instanceId, sessionId, adapter };
+}
+
+function adapterFromPlatform(platform: string | undefined): Adapter | null {
+  if (platform === "claude_code" || platform === "claude-code") return "claude-code";
+  if (platform === "cursor") return "cursor";
+  if (platform === "codex") return "codex";
+  return null;
+}
+
+function parseAdapter(value: string): Adapter {
+  if (value === "claude-code" || value === "codex" || value === "cursor") return value;
+  throw new Error(`invalid adapter "${value}"; expected claude-code, codex, or cursor`);
+}
+
+function parseCheckpointReason(value: string): CheckpointReason {
+  if (
+    value === "manual" ||
+    value === "pressure" ||
+    value === "pre_compact" ||
+    value === "session_end"
+  ) {
+    return value;
+  }
+  throw new Error(
+    `invalid reason "${value}"; expected manual, pressure, pre_compact, or session_end`,
+  );
+}
+
+function emitCommandError(emit: EmitContext, code: string, err: unknown): void {
+  emit.error({ code, message: err instanceof Error ? err.message : String(err) });
+  emit.setExitCode(1);
+}

package/src/commands/context.ts

@@ -1,13 +1,5 @@
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
-import { monorepoRoot, readHeartbeat, resolveOwner } from "../core/agents/index.ts";
-import {
-  type CheckpointReason,
-  checkpointContext,
-  readContextState,
-  readLatestCapsule,
-} from "../core/context/index.ts";
-import type { Harness } from "../core/hooks/events/schema.ts";
 import {
   buildContext,
   type ContextReport,
@@ -17,18 +9,18 @@ import {
 } from "../lib/context/index.ts";
 
 /**
- * `harn context`: one-shot orientation snapshot.
+ * `harn agents context`: one-shot orientation snapshot.
  *
  * Aggregates self / time / repo / commits / submodules / peers (default) plus
  * opt-in services. Useful at session start, post-compaction, or before
  * dispatching subagents. Fail-open per section.
  */
 export function registerContextCommand(
-  program: Command,
+  parent: Command,
   emit: EmitContext,
   context?: HarneryProgramContext,
 ): void {
-  const command = program
+  parent
     .command("context")
     .description(
       `One-shot orientation snapshot: self, repo, submodules, peers, recent commits. Default sections: ${DEFAULT_SECTIONS.join(" / ")}. Opt-in: ${OPT_IN_SECTIONS.join(" / ")}.`,
@@ -76,171 +68,6 @@ export function registerContextCommand(
         }
       },
     );
-
-  command
-    .command("status")
-    .description("Show context-continuity phase, generation, and latest telemetry")
-    .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
-    .option("--instance <id>", "Agent instance id (defaults to the current owner)")
-    .option("--json", "Structured JSON output")
-    .action((opts: { session?: string; instance?: string; json?: boolean }) => {
-      try {
-        const json = opts.json || Boolean(command.opts().json);
-        const identity = resolveContinuityIdentity(context, opts);
-        const state = readContextState(identity.coordRoot, identity.sessionId);
-        if (json) {
-          emit.config({ format: "json" });
-          emit.data({ state, identity });
-          return;
-        }
-        if (!state) {
-          emit.text(`No context continuity state for session ${identity.sessionId}.\n`);
-          return;
-        }
-        const sample = state.latest_context;
-        const usage = sample
-          ? `${sample.used_tokens ?? "?"}/${sample.window_tokens ?? "?"} tokens${sample.used_percent === undefined ? "" : ` (${sample.used_percent}%)`}`
-          : "not reported by harness";
-        emit.text(
-          `${[
-            `Session:    ${state.session_id}`,
-            `Phase:      ${state.phase}`,
-            `Generation: ${state.generation}`,
-            `Telemetry:  ${usage}`,
-            `Capsule:    ${state.latest_capsule ?? "none"}`,
-            state.degraded_reason ? `Degraded:   ${state.degraded_reason}` : "",
-          ]
-            .filter(Boolean)
-            .join("\n")}\n`,
-        );
-      } catch (err) {
-        emitCommandError(emit, "context_status_failed", err);
-      }
-    });
-
-  command
-    .command("checkpoint")
-    .description("Create a durable context-continuity capsule for the current work")
-    .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
-    .option("--instance <id>", "Agent instance id (defaults to the current owner)")
-    .option("--harness <id>", "claude-code, codex, or cursor (inferred from heartbeat)")
-    .option("--reason <reason>", "manual, pressure, pre_compact, or session_end", "manual")
-    .option("--note <text>", "Short continuation note for the recovered agent")
-    .option("--json", "Structured JSON output")
-    .action(
-      (opts: {
-        session?: string;
-        instance?: string;
-        harness?: string;
-        reason: string;
-        note?: string;
-        json?: boolean;
-      }) => {
-        try {
-          const json = opts.json || Boolean(command.opts().json);
-          const reason = parseCheckpointReason(opts.reason);
-          const identity = resolveContinuityIdentity(context, opts);
-          if (!identity.harness) {
-            throw new Error("could not infer the harness; pass --harness claude-code|codex|cursor");
-          }
-          const result = checkpointContext(identity.coordRoot, {
-            sessionId: identity.sessionId,
-            instanceId: identity.instanceId,
-            harness: identity.harness,
-            cwd: context?.repoRoot ?? process.cwd(),
-            reason,
-            continuationNote: opts.note,
-          });
-          const output = {
-            capsule_id: result.capsule.capsule_id,
-            generation: result.capsule.generation,
-            path: result.state.latest_capsule,
-            phase: result.state.phase,
-            reused: result.reused,
-          };
-          if (json) {
-            emit.config({ format: "json" });
-            emit.data(output);
-            return;
-          }
-          emit.text(
-            `Checkpointed context generation ${output.generation}: ${output.path ?? result.path}\n`,
-          );
-        } catch (err) {
-          emitCommandError(emit, "context_checkpoint_failed", err);
-        }
-      },
-    );
-
-  command
-    .command("show")
-    .description("Show the latest durable context-continuity capsule")
-    .option("--session <id>", "Session id (defaults to the current agent heartbeat)")
-    .option("--instance <id>", "Agent instance id (defaults to the current owner)")
-    .option("--json", "Structured JSON output")
-    .action((opts: { session?: string; instance?: string; json?: boolean }) => {
-      try {
-        const json = opts.json || Boolean(command.opts().json);
-        const identity = resolveContinuityIdentity(context, opts);
-        const capsule = readLatestCapsule(identity.coordRoot, identity.sessionId);
-        if (!capsule) {
-          throw new Error(`no context capsule exists for session ${identity.sessionId}`);
-        }
-        if (json) emit.config({ format: "json" });
-        emit.data(capsule);
-      } catch (err) {
-        emitCommandError(emit, "context_show_failed", err);
-      }
-    });
-}
-
-function resolveContinuityIdentity(
-  context: HarneryProgramContext | undefined,
-  opts: { session?: string; instance?: string; harness?: string },
-): { coordRoot: string; instanceId: string; sessionId: string; harness: Harness | null } {
-  const coordRoot = context?.resolveCoordRoot?.() ?? context?.repoRoot ?? monorepoRoot();
-  if (!coordRoot) throw new Error("could not resolve a project containing .harnery/");
-  const instanceId = opts.instance ?? resolveOwner();
-  if (!instanceId) {
-    throw new Error("could not resolve the current agent; pass --instance and --session");
-  }
-  const heartbeat = readHeartbeat(instanceId);
-  const sessionId = opts.session ?? heartbeat?.session_id ?? instanceId;
-  const harness = opts.harness
-    ? parseHarness(opts.harness)
-    : harnessFromPlatform(heartbeat?.platform);
-  return { coordRoot, instanceId, sessionId, harness };
-}
-
-function harnessFromPlatform(platform: string | undefined): Harness | null {
-  if (platform === "claude_code" || platform === "claude-code") return "claude-code";
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  return null;
-}
-
-function parseHarness(value: string): Harness {
-  if (value === "claude-code" || value === "codex" || value === "cursor") return value;
-  throw new Error(`invalid harness "${value}"; expected claude-code, codex, or cursor`);
-}
-
-function parseCheckpointReason(value: string): CheckpointReason {
-  if (
-    value === "manual" ||
-    value === "pressure" ||
-    value === "pre_compact" ||
-    value === "session_end"
-  ) {
-    return value;
-  }
-  throw new Error(
-    `invalid reason "${value}"; expected manual, pressure, pre_compact, or session_end`,
-  );
-}
-
-function emitCommandError(emit: EmitContext, code: string, err: unknown): void {
-  emit.error({ code, message: err instanceof Error ? err.message : String(err) });
-  emit.setExitCode(1);
 }
 
 function collectSections(value: string, prev: SectionName[]): SectionName[] {

package/src/commands/decision.ts

@@ -4,7 +4,7 @@ import type { EmitContext } from "../commander.ts";
 import {
   emitCanonical,
   monorepoRoot,
-  normalizeHarness,
+  normalizeAdapter,
   readHeartbeat,
   resolveOwner,
 } from "../core/agents/index.ts";
@@ -108,23 +108,45 @@ export function registerDecisionCommand(program: Command, emitParam: EmitContext
     .option("--stakes <small|medium|high>", "Filter by stakes")
     .option("--open", "Only non-terminal decisions (the live queue)")
     .option("--archived", "Include archived (graduated/terminal) decisions")
+    .option(
+      "--waiting",
+      "Only what a human still has to rule on: tier 2, unresolved. Oldest-first within stakes.",
+    )
     .action((opts: ListOpts) => {
       const coordRoot = coordRootOrExit();
       const status = opts.status ? parseStatus(opts.status) : undefined;
       const tier = opts.tier !== undefined ? parseTier(opts.tier) : undefined;
       const stakes = opts.stakes ? parseStakes(opts.stakes) : undefined;
-      const rows = listDecisions(coordRoot, {
+      if (opts.waiting && tier !== undefined && tier !== 2) {
+        return fail(
+          "bad_request",
+          "--waiting is tier 2 by definition; drop --tier or pass --tier 2",
+        );
+      }
+      let rows = listDecisions(coordRoot, {
         status,
-        tier,
+        tier: opts.waiting ? 2 : tier,
         stakes,
-        openOnly: opts.open,
-        includeArchived: opts.archived,
+        // --waiting implies the live queue: an archived or resolved decision is
+        // not waiting on anyone.
+        openOnly: opts.open || opts.waiting,
+        includeArchived: opts.waiting ? false : opts.archived,
       }).map(summarize);
+      if (opts.waiting) {
+        rows = rows.filter((r) => !r.resolved).sort(byStakesThenAge);
+      }
       emit.data({
         rows,
         meta: {
           total: rows.length,
-          filter: { status, tier, stakes, open: !!opts.open, archived: !!opts.archived },
+          filter: {
+            status,
+            tier: opts.waiting ? 2 : tier,
+            stakes,
+            open: !!(opts.open || opts.waiting),
+            archived: opts.waiting ? false : !!opts.archived,
+            waiting: !!opts.waiting,
+          },
         },
       });
     });
@@ -351,6 +373,7 @@ interface ListOpts {
   stakes?: string;
   open?: boolean;
   archived?: boolean;
+  waiting?: boolean;
 }
 interface ResolveOpts {
   recommendation: string;
@@ -403,6 +426,17 @@ function collect(value: string, previous: string[]): string[] {
 }
 
 /** Compact row for list/search output — the full manifest is available via `show`. */
+const WAITING_STAKES_RANK: Record<string, number> = { high: 3, medium: 2, small: 1 };
+
+/** Highest stakes first, longest-open breaking ties. Stakes leads because it is
+ * the filer's own triage signal; age breaks ties so a question nobody has
+ * answered in three weeks does not sit behind an equally-weighted fresh one. */
+function byStakesThenAge(a: Record<string, unknown>, b: Record<string, unknown>): number {
+  const rank =
+    (WAITING_STAKES_RANK[String(b.stakes)] ?? 1) - (WAITING_STAKES_RANK[String(a.stakes)] ?? 1);
+  return rank !== 0 ? rank : String(a.filed_at ?? "").localeCompare(String(b.filed_at ?? ""));
+}
+
 function summarize(m: DecisionManifest): Record<string, unknown> {
   return {
     decision_id: m.decision_id,
@@ -432,7 +466,7 @@ function emitDecisionEvent(type: string, data: Record<string, unknown>): void {
     type,
     owner,
     session: hb?.session_id ?? owner,
-    harness: normalizeHarness(hb?.platform),
+    adapter: normalizeAdapter(hb?.platform),
     data,
   });
 }

package/src/commands/deinit.ts

@@ -2,11 +2,11 @@
  * `harn deinit`: reverse what `harn init` wired into a project.
  *
  * `init` makes two kinds of change outside the harnery package:
- *   1. Merges `agent-hook` entries into the harness settings file
+ *   1. Merges `agent-hook` entries into the adapter settings file
  *      (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`, or
  *      Codex `.codex/hooks.json`).
  *   2. Creates the `.harnery/` coord root (runtime state: events, councils,
- *      identities, scratch) and stamps the host bin name into
+ *      identities, journal) and stamps the host bin name into
  *      `.harnery/config.jsonc`.
  *
  * `deinit` undoes (1) by default: it removes only harnery's hook entries from
@@ -33,12 +33,12 @@ import { createInterface } from "node:readline";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
 import { DEFAULT_BIN_NAME } from "../core/config.ts";
-import { HARNESS_SPECS, type HarnessId } from "../core/hooks/harness/events.ts";
+import { ADAPTER_SPECS, type AdapterId } from "../core/hooks/adapter/events.ts";
 import { removeInstructions } from "../lib/instructions/apply.ts";
 import { type SettingsFile, unwireHooks } from "./init.ts";
 
 interface DeinitOpts {
-  harness: string;
+  adapter: string;
   dryRun?: boolean;
   projectRoot?: string;
   purgeState?: boolean;
@@ -54,20 +54,20 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
   program
     .command("deinit")
     .description(
-      "Reverse `harn init`: remove harnery's hook entries from the harness " +
+      "Reverse `harn init`: remove harnery's hook entries from the adapter " +
         "settings file (keeps any others). Pass --purge-state to also delete the " +
         ".harnery/ coord root (on a terminal it asks first). Idempotent; use " +
         "--dry-run to preview.",
     )
-    .option("--harness <id>", "claude-code | cursor | codex", "claude-code")
+    .option("--adapter <id>", "claude-code | cursor | codex", "claude-code")
     .option("--dry-run", "Show what would change without writing")
     .option("--project-root <path>", "Project root (default: git toplevel, else cwd)")
     .option("--purge-state", "Also delete the .harnery/ coord root (runtime state, destructive)")
     .action(async (opts: DeinitOpts) => {
-      const harness = opts.harness as HarnessId;
-      const spec = HARNESS_SPECS[harness];
+      const adapter = opts.adapter as AdapterId;
+      const spec = ADAPTER_SPECS[adapter];
       if (!spec) {
-        emit.text(`Unknown harness '${opts.harness}'. Expected: claude-code | cursor | codex.`);
+        emit.text(`Unknown adapter '${opts.adapter}'. Expected: claude-code | cursor | codex.`);
         emit.setExitCode(1);
         return;
       }
@@ -92,7 +92,7 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
         purgeState = await confirmDeleteState(coordDir);
       }
 
-      // ── 1. unwire harness hooks ────────────────────────────────────────────
+      // ── 1. unwire adapter hooks ────────────────────────────────────────────
       const settingsPath = resolve(projectRoot, spec.settingsFile);
       if (!existsSync(settingsPath)) {
         actions.push(`· ${rel(projectRoot, settingsPath)} doesn't exist; no hooks to remove`);
@@ -111,7 +111,7 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
         const { removed, remaining } = unwireHooks(settings);
         if (removed === 0) {
           actions.push(`· no harnery hooks found in ${rel(projectRoot, settingsPath)}`);
-        } else if (harnessOnly(settings)) {
+        } else if (adapterOnly(settings)) {
           // Nothing left but what init itself put there (no hooks, at most a
           // version key), so remove the file rather than leave an empty shell.
           if (dryRun) {
@@ -135,7 +135,7 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
       }
 
       // ── 1b. agent-facing instructions block + skills ───────────────────────
-      const removed = removeInstructions(projectRoot, { harness, dryRun });
+      const removed = removeInstructions(projectRoot, { adapter, dryRun });
       actions.push(...removed.actions, ...removed.warnings.map((w) => `! ${w}`));
 
       // ── 2. coord root (opt-in; destructive) ────────────────────────────────
@@ -143,7 +143,7 @@ export function registerDeinitCommand(program: Command, emit: EmitContext, binNa
         if (!coordExists) {
           actions.push("· .harnery/ doesn't exist; nothing to purge");
         } else if (dryRun) {
-          actions.push("+ would delete .harnery/ and all coord state (events, councils, scratch)");
+          actions.push("+ would delete .harnery/ and all coord state (events, councils, journal)");
         } else {
           rmSync(coordDir, { recursive: true, force: true });
           actions.push("+ deleted .harnery/ and all coord state");
@@ -191,7 +191,7 @@ export function engineRemovalHint(): string {
 function confirmDeleteState(coordDir: string): Promise<boolean> {
   process.stdout.write(
     "\nharnery saved this project's coordination history in .harnery/\n" +
-      "(its event log, councils, agent identities, and scratchpads):\n" +
+      "(its event log, councils, agent identities, and journals):\n" +
       `    ${coordDir}\n` +
       "Unwiring leaves that in place. Deleting it can't be undone.\n",
   );
@@ -210,7 +210,7 @@ function confirm(question: string): Promise<boolean> {
 }
 
 /** True when an unwired settings object holds nothing but (optionally) `version`. */
-function harnessOnly(settings: SettingsFile): boolean {
+function adapterOnly(settings: SettingsFile): boolean {
   const keys = Object.keys(settings);
   return keys.length === 0 || (keys.length === 1 && keys[0] === "version");
 }
@@ -224,7 +224,7 @@ function render(
   const head = dryRun ? "harn deinit (dry run): no changes written" : "harn deinit";
   const tail = dryRun
     ? "\nRe-run without --dry-run to apply."
-    : "\nDone. harnery hooks are unwired; restart your harness session to drop them.";
+    : "\nDone. harnery hooks are unwired; restart your adapter session to drop them.";
   const hintBlock = hint ? `\n\n${hint}` : "";
   return `${head}\n  root: ${projectRoot}\n${actions.map((a) => `  ${a}`).join("\n")}${tail}${hintBlock}`;
 }