harnery 0.30.0 → 0.31.0

package/src/commands/init.ts

@@ -5,11 +5,11 @@
  * if skipped):
  *   1. Create the `.harnery/` coord root; without it `findCoordRoot` returns
  *      null and every hook no-ops forever.
- *   2. Register the agent-hook entries in the harness settings file.
+ *   2. Register the agent-hook entries in the adapter settings file.
  *
- * Wires whichever harness `--harness` names (Claude Code `.claude/settings.json`,
- * Cursor `.cursor/hooks.json`, or Codex `.codex/hooks.json`): the per-harness
- * file path, event list, and hook-entry shape all come from HARNESS_SPECS.
+ * Wires whichever adapter `--adapter` names (Claude Code `.claude/settings.json`,
+ * Cursor `.cursor/hooks.json`, or Codex `.codex/hooks.json`): the per-adapter
+ * file path, event list, and hook-entry shape all come from ADAPTER_SPECS.
  *
  * `harn init` does both, non-destructively: it merges hook entries into an
  * existing settings file (preserving any other hooks) and skips entries that are
@@ -23,25 +23,30 @@ import { fileURLToPath } from "node:url";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
 import { DEFAULT_BIN_NAME, pinnedBinName, stripJsonComments } from "../core/config.ts";
-import { HARNESS_SPECS, type HarnessId, type HarnessSpec } from "../core/hooks/harness/events.ts";
+import { ADAPTER_SPECS, type AdapterId, type AdapterSpec } from "../core/hooks/adapter/events.ts";
 import {
   commandWiresSubcommand,
   groupCommands,
   type HookGroup,
   makeEntry,
   type SettingsFile,
-} from "../core/hooks/harness/wiring.ts";
-import { applyInstructions, checkInstructions } from "../lib/instructions/apply.ts";
+} from "../core/hooks/adapter/wiring.ts";
+import {
+  type ApplyResult,
+  applyInstructions,
+  checkInstructions,
+} from "../lib/instructions/apply.ts";
+import { HostAddendumError } from "../lib/instructions/host-addendum.ts";
 
 // Re-exported for back-compat: callers (deinit, tests) import these names
-// from init.ts. The definitions now live in core/hooks/harness/wiring.ts.
+// from init.ts. The definitions now live in core/hooks/adapter/wiring.ts.
 export type { HookGroup, SettingsFile };
 
 // This file is src/commands/init.ts → harnery package root is two levels up.
 const HARNERY_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 interface InitOpts {
-  harness: string;
+  adapter: string;
   dryRun?: boolean;
   check?: boolean;
   projectRoot?: string;
@@ -51,20 +56,20 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
   program
     .command("init")
     .description(
-      "Bootstrap harnery in this project: create .harnery/, wire the harness " +
+      "Bootstrap harnery in this project: create .harnery/, wire the adapter " +
         "hooks, and inject the agent-facing instructions block + skills " +
         "(idempotent; safe to re-run). Use --dry-run to preview, --check to " +
         "report drift without writing (exit 0 fresh / 2 drift / 1 error).",
     )
-    .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("--check", "Report instructions/skills drift without writing; exit 0/2/1")
     .option("--project-root <path>", "Project root (default: git toplevel, else cwd)")
     .action((opts: InitOpts) => {
-      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;
       }
@@ -79,7 +84,7 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
 
       // ── --check: read-only drift report on the block + skills ──────────────
       if (opts.check === true) {
-        const { status, issues } = checkInstructions(projectRoot, { binName: bin, harness });
+        const { status, issues } = checkInstructions(projectRoot, { binName: bin, adapter });
         const head =
           status === "fresh"
             ? "harn init --check: instructions + skills are current"
@@ -122,7 +127,7 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
 
       // ── 1c. workflow billing default ───────────────────────────────────────
       // Every init'd project gets `workflow.subscriptionOnly: true`: workflow
-      // children ride the logged-in (subscription) harness auth, and the pin
+      // children ride the logged-in (subscription) adapter auth, and the pin
       // makes per-token API billing structurally impossible unless the project
       // deliberately flips it. A committed `workflow` key of any shape is a
       // deliberate choice and is never touched.
@@ -131,7 +136,7 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
         if (stamp) actions.push(stamp);
       }
 
-      // ── 2. harness hooks ───────────────────────────────────────────────────
+      // ── 2. adapter hooks ───────────────────────────────────────────────────
       const settingsPath = resolve(projectRoot, spec.settingsFile);
       const agentHook = relative(projectRoot, resolve(HARNERY_ROOT, "bin", "agent-hook"));
 
@@ -150,11 +155,11 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
       } else {
         settings = {};
       }
-      const { wired, already, removed, upgraded } = wireHooks(settings, spec, agentHook, harness);
+      const { wired, already, removed, upgraded } = wireHooks(settings, spec, agentHook, adapter);
 
       if (wired === 0 && removed === 0 && upgraded === 0) {
         actions.push(
-          `· all ${spec.events.length} ${harness} hooks already wired in ${rel(projectRoot, settingsPath)}`,
+          `· all ${spec.events.length} ${adapter} hooks already wired in ${rel(projectRoot, settingsPath)}`,
         );
       } else if (dryRun) {
         actions.push(
@@ -171,7 +176,18 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
       }
 
       // ── 3. agent-facing instructions block + skills ────────────────────────
-      const applied = applyInstructions(projectRoot, { binName: bin, harness, dryRun });
+      // A misconfigured host addendum aborts here rather than half-writing: the
+      // apply step validates the configured source before it touches a file, so
+      // a bad path leaves the repo exactly as it found it.
+      let applied: ApplyResult;
+      try {
+        applied = applyInstructions(projectRoot, { binName: bin, adapter, dryRun });
+      } catch (err) {
+        if (!(err instanceof HostAddendumError)) throw err;
+        emit.text(`${bin} init: ${err.message}`);
+        emit.setExitCode(1);
+        return;
+      }
       actions.push(...applied.actions);
 
       emit.text(render(projectRoot, dryRun, actions, applied.warnings));
@@ -179,12 +195,12 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
 }
 
 /**
- * Merge agent-hook entries into a harness settings object in place, idempotently.
+ * Merge agent-hook entries into a adapter settings object in place, idempotently.
  * Preserves every existing hook; rewrites events already wired to
  * `agent-hook <subcommand>` when their command string is stale (e.g. an older
- * harnery wired a bare relative path). Honors the harness's entry shape
+ * harnery wired a bare relative path). Honors the adapter's entry shape
  * (Claude/Codex nest under an inner `hooks` array; Cursor uses a flat
- * `{ command }`) and ensures the root `version` key when the harness requires
+ * `{ command }`) and ensures the root `version` key when the adapter requires
  * one. Pure (no fs/git) so it's unit-testable.
  *
  * The trailing space in the match (`agent-hook ${subcommand} `) is load-bearing:
@@ -192,9 +208,9 @@ export function registerInitCommand(program: Command, emit: EmitContext, binName
  */
 export function wireHooks(
   settings: SettingsFile,
-  spec: HarnessSpec,
+  spec: AdapterSpec,
   agentHookPath: string,
-  harness: HarnessId,
+  adapter: AdapterId,
 ): { wired: number; already: number; removed: number; upgraded: number } {
   if (spec.rootVersion !== undefined && settings.version === undefined) {
     settings.version = spec.rootVersion;
@@ -215,7 +231,7 @@ export function wireHooks(
     else settings.hooks[settingsKey] = kept;
   }
   for (const { settingsKey, subcommand } of spec.events) {
-    const command = hookCommand(spec, agentHookPath, subcommand, harness);
+    const command = hookCommand(spec, agentHookPath, subcommand, adapter);
     const groups = settings.hooks[settingsKey] ?? [];
     let present = false;
     for (const group of groups) {
@@ -235,23 +251,23 @@ export function wireHooks(
 }
 
 /**
- * The canonical hook command for one event. When the harness exports a
+ * The canonical hook command for one event. When the adapter exports a
  * project-dir env var to hook processes (Claude Code's CLAUDE_PROJECT_DIR),
  * anchor the agent-hook path on it: hook processes inherit the session
  * shell's cwd, which follows `cd` away from the project root — a bare
  * relative path silently fails to spawn from there (no events, no image
- * capture, no guards). `:-.` keeps the command working on harness versions
+ * capture, no guards). `:-.` keeps the command working on adapter versions
  * that don't set the var. Only the env expansion is quoted so the
  * `agent-hook <subcommand> ` wiring match stays byte-identical.
  */
 function hookCommand(
-  spec: HarnessSpec,
+  spec: AdapterSpec,
   agentHookPath: string,
   subcommand: string,
-  harness: HarnessId,
+  adapter: AdapterId,
 ): string {
   const anchor = spec.projectDirEnv ? `"\${${spec.projectDirEnv}:-.}"/` : "";
-  return `bash ${anchor}${agentHookPath} ${subcommand} --harness ${harness}`;
+  return `bash ${anchor}${agentHookPath} ${subcommand} --adapter ${adapter}`;
 }
 
 /**
@@ -295,8 +311,8 @@ function rewriteStaleCommands(
  * contains `agent-hook ` (the trailing space matches `agent-hook <subcommand>`),
  * so any non-harnery hook the consumer added is preserved. Emptied
  * `hooks[settingsKey]` arrays are dropped; an emptied `hooks` object is dropped
- * entirely. Harness-agnostic (scans every key) so it removes entries left by any
- * harness. Pure (no fs) so it's unit-testable. Returns the count removed and the
+ * entirely. Adapter-agnostic (scans every key) so it removes entries left by any
+ * adapter. Pure (no fs) so it's unit-testable. Returns the count removed and the
  * count of non-harnery hooks left behind.
  */
 export function unwireHooks(settings: SettingsFile): { removed: number; remaining: number } {
@@ -384,7 +400,7 @@ export function stampBinName(configPath: string, binName: string, dryRun: boolea
 
 /** The commented workflow-billing default block init stamps into config.jsonc. */
 const WORKFLOW_DEFAULT_BLOCK =
-  `  // Workflow children ride the logged-in (subscription) harness auth; this pin\n` +
+  `  // Workflow children ride the logged-in (subscription) adapter auth; this pin\n` +
   `  // scrubs API-key vars from child envs so runs can never bill per-token rates.\n` +
   `  // Key-only hosts (CI): set false, or HARNERY_WORKFLOW_SUBSCRIPTION_ONLY=0.\n` +
   `  "workflow": { "subscriptionOnly": true }`;

package/src/commands/{scratch.ts → journal.ts}

@@ -2,38 +2,38 @@ import { existsSync, readdirSync, readFileSync, statSync, unlinkSync, watch } fr
 import { resolve as resolvePath } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
-import { emitCanonical, normalizeHarness, readHeartbeat } from "../core/agents/index.ts";
+import { emitCanonical, normalizeAdapter, readHeartbeat } from "../core/agents/index.ts";
 import { resolveBinName } from "../core/config.ts";
 import {
   appendEntry,
-  archiveScratch,
+  archiveJournal,
   currentOwnerOrThrow,
-  lintScratch,
+  JOURNAL_CATEGORIES,
+  type JournalCategory,
+  type JournalDoc,
+  journalDir,
+  journalPath,
+  lintJournal,
   listArchives,
-  loadScratch,
-  parseScratch,
+  loadJournal,
+  parseJournal,
   pruneArchives,
   resolveOwnerByName,
-  SCRATCH_CATEGORIES,
-  type ScratchCategory,
-  type ScratchDoc,
-  scratchDir,
-  scratchPath,
-  sweepOrphanScratchpads,
-} from "../core/scratch/index.ts";
+  sweepOrphanJournals,
+} from "../core/journal/index.ts";
 
 /**
- * `harn scratch`: per-agent markdown journal at `.harnery/scratch/<instance_id>.md`.
+ * `harn journal`: per-agent markdown journal at `.harnery/journal/<instance_id>.md`.
  * Used both for self-notes (surviving compaction) and peer coordination (other
  * agents pull-read it on demand). SessionEnd hook archives; SessionStart
  * janitor surfaces the most-recent archive as a recovery cue.
  */
 let emit: EmitContext;
 
-export function registerScratchCommand(program: Command, emitParam: EmitContext): void {
+export function registerJournalCommand(program: Command, emitParam: EmitContext): void {
   emit = emitParam;
   const root = program
-    .command("scratch")
+    .command("journal")
     .description(
       "Per-agent markdown journal: append-only timestamped entries. " +
         "Survives in-session compaction, archived at session end, pruned after 7 days.",
@@ -42,12 +42,12 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── add ───────────────────────────────────────────────────────────────
   root
     .command("add <category> <text...>")
-    .description(`Append an entry to my scratchpad. Category: ${SCRATCH_CATEGORIES.join(" | ")}`)
+    .description(`Append an entry to my journal. Category: ${JOURNAL_CATEGORIES.join(" | ")}`)
     .action((category: string, text: string[]) => {
       const cat = validateCategory(category);
       const body = text.join(" ");
       if (!body.trim()) {
-        emit.error({ code: "empty_body", message: "scratch add: body is empty" });
+        emit.error({ code: "empty_body", message: "journal add: body is empty" });
         process.exit(1);
       }
       try {
@@ -55,10 +55,10 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
         const doc = appendEntry(owner, cat, body);
         const hb = readHeartbeat(owner);
         emitCanonical({
-          type: "state.scratch_append",
+          type: "state.journal_append",
           owner,
           session: hb?.session_id ?? owner,
-          harness: normalizeHarness(hb?.platform),
+          adapter: normalizeAdapter(hb?.platform),
           data: {
             category: cat,
             body_summary: body.length > 1000 ? `${body.slice(0, 997)}...` : body,
@@ -81,8 +81,8 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── read ──────────────────────────────────────────────────────────────
   root
     .command("read")
-    .description("Render a scratchpad to stdout. No --name: my own. With --name: a peer's.")
-    .option("--name <name>", "Read the named peer's scratchpad (case-insensitive)")
+    .description("Render a journal to stdout. No --name: my own. With --name: a peer's.")
+    .option("--name <name>", "Read the named peer's journal (case-insensitive)")
     .option("--owner <id>", "Read by instance_id directly")
     .option("--archive <basename>", "Read an archive file (e.g. <owner>-<ts>.md)")
     .option("--limit <n>", "Cap entries rendered (newest first)", "50")
@@ -98,8 +98,8 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── list ──────────────────────────────────────────────────────────────
   root
     .command("list")
-    .description("Summarize all active scratchpads + archive count")
-    .option("--archives", "List archive files instead of active scratchpads")
+    .description("Summarize all active journals + archive count")
+    .option("--archives", "List archive files instead of active journals")
     .action((opts: { archives?: boolean }) => {
       try {
         if (opts.archives) {
@@ -120,7 +120,7 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
           emit.data({ rows: items });
           return;
         }
-        const dir = scratchDir();
+        const dir = journalDir();
         const rows: Array<{
           instance_id: string;
           name: string;
@@ -132,7 +132,7 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
         for (const f of readdirSync(dir)) {
           if (!f.endsWith(".md")) continue;
           const instanceId = f.replace(/\.md$/, "");
-          const doc = loadScratch(instanceId);
+          const doc = loadJournal(instanceId);
           if (!doc) continue;
           rows.push({
             instance_id: instanceId,
@@ -154,27 +154,27 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── tail ──────────────────────────────────────────────────────────────
   root
     .command("tail")
-    .description("Follow my scratchpad (or a peer's) for new entries.")
-    .option("--name <name>", "Tail the named peer's scratchpad")
+    .description("Follow my journal (or a peer's) for new entries.")
+    .option("--name <name>", "Tail the named peer's journal")
     .option("--owner <id>", "Tail by instance_id directly")
     .action(async (opts: { name?: string; owner?: string }) => {
       try {
         const owner = resolveTargetOwner(opts);
-        const path = scratchPath(owner);
+        const path = journalPath(owner);
         if (!existsSync(path)) {
-          emit.error({ code: "no_scratchpad", message: `no scratchpad at ${path} yet` });
+          emit.error({ code: "no_journal", message: `no journal at ${path} yet` });
           process.exit(1);
         }
         process.stderr.write(`tailing ${path}\n`); // lint-ok-emission: tail banner, immediate stderr flush before streaming
         let lastSize = statSync(path).size;
         // Print initial render
-        process.stdout.write(`${renderScratch(loadScratch(owner)!, 10)}\n`); // lint-ok-emission: streaming tail body
+        process.stdout.write(`${renderJournal(loadJournal(owner)!, 10)}\n`); // lint-ok-emission: streaming tail body
         const w = watch(path, { persistent: true }, () => {
           try {
             const curr = statSync(path).size;
             if (curr === lastSize) return;
             lastSize = curr;
-            const doc = loadScratch(owner);
+            const doc = loadJournal(owner);
             if (!doc) return;
             const newest = doc.entries[0];
             if (!newest) return;
@@ -201,7 +201,7 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── clear ─────────────────────────────────────────────────────────────
   root
     .command("clear")
-    .description("Delete my scratchpad (rare; mainly for testing)")
+    .description("Delete my journal (rare; mainly for testing)")
     .option("--yes", "Confirm deletion")
     .action((opts: { yes?: boolean }) => {
       if (!opts.yes) {
@@ -210,7 +210,7 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
       }
       try {
         const owner = currentOwnerOrThrow();
-        const path = scratchPath(owner);
+        const path = journalPath(owner);
         if (existsSync(path)) {
           unlinkSync(path);
           emit.data({ cleared: true, path });
@@ -226,9 +226,9 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── lint ──────────────────────────────────────────────────────────────
   root
     .command("lint")
-    .description("Validate scratchpad format + size")
-    .option("--all", "Lint every scratchpad in .harnery/scratch/")
-    .option("--owner <id>", "Lint a specific owner's scratchpad")
+    .description("Validate journal format + size")
+    .option("--all", "Lint every journal in .harnery/journal/")
+    .option("--owner <id>", "Lint a specific owner's journal")
     .action((opts: { all?: boolean; owner?: string }) => {
       try {
         runLint(opts);
@@ -241,12 +241,12 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   // ── archive (manual / hook helper) ────────────────────────────────────
   root
     .command("archive")
-    .description("Archive my scratchpad now (idempotent; fired by SessionEnd hook)")
-    .option("--owner <id>", "Archive a specific owner's scratchpad")
+    .description("Archive my journal now (idempotent; fired by SessionEnd hook)")
+    .option("--owner <id>", "Archive a specific owner's journal")
     .action((opts: { owner?: string }) => {
       try {
         const owner = opts.owner ?? currentOwnerOrThrow();
-        const dest = archiveScratch(owner);
+        const dest = archiveJournal(owner);
         emit.data({ instance_id: owner, archived: !!dest, path: dest });
       } catch (err) {
         emit.error({ code: "archive_failed", message: (err as Error).message });
@@ -279,9 +279,9 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
         const bodyOneLine = last.body.replace(/\s+/g, " ").trim();
         const bodyTrunc = bodyOneLine.length > 100 ? `${bodyOneLine.slice(0, 99)}…` : bodyOneLine;
         const cue =
-          `Recent scratchpad archive (${ageStr} ago): agent-${doc.header.name}: ` +
+          `Recent journal archive (${ageStr} ago): agent-${doc.header.name}: ` +
           `last entry [${last.category}] "${bodyTrunc}". ` +
-          `Read full: \`${resolveBinName()} scratch read --archive ${newest.basename}\`.`;
+          `Read full: \`${resolveBinName()} journal read --archive ${newest.basename}\`.`;
         process.stdout.write(`${cue}\n`); // lint-ok-emission: bash hook reads stdout to compose SessionStart additionalContext
       } catch (_err) {
         // Recovery cue is best-effort; never fail the SessionStart hook.
@@ -292,14 +292,14 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
   root
     .command("janitor")
     .description(
-      "Prune old archives + sweep orphan scratchpads (heartbeat gone). Fired by SessionStart hook.",
+      "Prune old archives + sweep orphan journals (heartbeat gone). Fired by SessionStart hook.",
     )
     .option("--days <n>", "Archive retention in days", "7")
     .option("--quiet", "Suppress stdout output")
     .action((opts: { days: string; quiet?: boolean }) => {
       try {
         const days = Number.parseInt(opts.days, 10);
-        const swept = sweepOrphanScratchpads();
+        const swept = sweepOrphanJournals();
         const pruned = pruneArchives(days);
         if (!opts.quiet) {
           emit.data({
@@ -320,7 +320,7 @@ export function registerScratchCommand(program: Command, emitParam: EmitContext)
 function runRead(opts: { name?: string; owner?: string; archive?: string; limit: string }): void {
   const limit = Number.parseInt(opts.limit, 10);
   if (opts.archive) {
-    const dir = scratchDir();
+    const dir = journalDir();
     const path = resolvePath(dir, "archived", opts.archive);
     if (!existsSync(path)) {
       emit.error({ code: "no_archive", message: `archive not found: ${opts.archive}` });
@@ -332,32 +332,32 @@ function runRead(opts: { name?: string; owner?: string; archive?: string; limit:
   }
 
   const owner = resolveTargetOwner(opts);
-  const doc = loadScratch(owner);
+  const doc = loadJournal(owner);
   if (!doc) {
     emit.error({
-      code: "no_scratchpad",
-      message: `no scratchpad for owner=${owner.slice(0, 8)}… (file not created yet)`,
+      code: "no_journal",
+      message: `no journal for owner=${owner.slice(0, 8)}… (file not created yet)`,
     });
     process.exit(1);
   }
 
   const hb = readHeartbeat(owner);
   const staleBanner = renderStaleBannerIfNeeded(hb?.last_heartbeat);
-  process.stdout.write(`${staleBanner + renderScratch(doc, limit)}\n`); // lint-ok-emission: pretty render, multi-line markdown for direct TTY/pipe consumption
+  process.stdout.write(`${staleBanner + renderJournal(doc, limit)}\n`); // lint-ok-emission: pretty render, multi-line markdown for direct TTY/pipe consumption
 }
 
 function runLint(opts: { all?: boolean; owner?: string }): void {
-  const dir = scratchDir();
+  const dir = journalDir();
   const files: string[] = [];
   if (opts.owner) {
-    files.push(scratchPath(opts.owner));
+    files.push(journalPath(opts.owner));
   } else if (opts.all) {
     for (const f of readdirSync(dir)) {
       if (f.endsWith(".md")) files.push(resolvePath(dir, f));
     }
   } else {
     const owner = currentOwnerOrThrow();
-    files.push(scratchPath(owner));
+    files.push(journalPath(owner));
   }
   let totalIssues = 0;
   const reports: Array<{ path: string; issues: { line: number; message: string }[] }> = [];
@@ -367,7 +367,7 @@ function runLint(opts: { all?: boolean; owner?: string }): void {
       continue;
     }
     const content = readFileSync(path, "utf8");
-    const issues = lintScratch(content);
+    const issues = lintJournal(content);
     if (issues.length > 0) totalIssues += issues.length;
     reports.push({ path, issues });
   }
@@ -377,15 +377,15 @@ function runLint(opts: { all?: boolean; owner?: string }): void {
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
-function validateCategory(c: string): ScratchCategory {
-  if (!(SCRATCH_CATEGORIES as readonly string[]).includes(c)) {
+function validateCategory(c: string): JournalCategory {
+  if (!(JOURNAL_CATEGORIES as readonly string[]).includes(c)) {
     emit.error({
       code: "bad_category",
-      message: `category must be one of: ${SCRATCH_CATEGORIES.join(", ")}`,
+      message: `category must be one of: ${JOURNAL_CATEGORIES.join(", ")}`,
     });
     process.exit(1);
   }
-  return c as ScratchCategory;
+  return c as JournalCategory;
 }
 
 function resolveTargetOwner(opts: { name?: string; owner?: string }): string {
@@ -404,9 +404,9 @@ function resolveTargetOwner(opts: { name?: string; owner?: string }): string {
   return currentOwnerOrThrow();
 }
 
-function renderScratch(doc: ScratchDoc, limit: number): string {
+function renderJournal(doc: JournalDoc, limit: number): string {
   const lines: string[] = [];
-  lines.push(`# Scratchpad: agent-${doc.header.name}`);
+  lines.push(`# Journal: agent-${doc.header.name}`);
   if (doc.header.session_id) lines.push(`session_id: ${doc.header.session_id}`);
   if (doc.header.machine) lines.push(`machine: ${doc.header.machine}`);
   if (doc.header.started) lines.push(`started: ${doc.header.started}`);
@@ -434,11 +434,11 @@ function renderStaleBannerIfNeeded(lastHeartbeat: string | undefined): string {
   return `[STALE: heartbeat ${m}m old, agent may be dead]\n\n`;
 }
 
-function parseSafe(path: string): ScratchDoc | null {
+function parseSafe(path: string): JournalDoc | null {
   try {
     if (!existsSync(path)) return null;
     const content = readFileSync(path, "utf8");
-    return parseScratch(path, content);
+    return parseJournal(path, content);
   } catch {
     return null;
   }

package/src/commands/policy.ts

@@ -41,7 +41,7 @@ export function renderPolicy(policy: Readonly<NormalizedPolicy>, digest: string)
     `unknown cost: ${policy.unknown_cost}`,
     `network: ${policy.network}`,
     `external actions: ${policy.external_actions}`,
-    `harnesses: ${policy.allowed_harnesses?.join(", ") ?? "any"}`,
+    `adapters: ${policy.allowed_adapters?.join(", ") ?? "any"}`,
     `models: ${policy.allowed_models?.join(", ") ?? "any"}`,
     `paths: ${policy.allowed_paths?.join(", ") ?? "any"}`,
     `isolation: ${policy.allowed_isolation?.join(", ") ?? "any"}`,

package/src/commands/presence.ts

@@ -3,7 +3,7 @@ import type { EmitContext } from "../commander.ts";
 import { monorepoRoot } from "../core/agents/coord-client.ts";
 import {
   emitCanonical,
-  normalizeHarness,
+  normalizeAdapter,
   readHeartbeat,
   resolveOwner,
 } from "../core/agents/index.ts";
@@ -252,7 +252,7 @@ function emitPresenceChange(
     type: "state.presence_change",
     owner,
     session: hb?.session_id ?? owner,
-    harness: normalizeHarness(hb?.platform),
+    adapter: normalizeAdapter(hb?.platform),
     data: { from, to, source },
   });
 }

package/src/commands/sync.ts

@@ -3,7 +3,7 @@
  * via rclone (typically a Google Drive remote, but any rclone remote works).
  *
  * Scope: a deliberately small set of file types: durable identities,
- * archived scratchpads, council manifests. The high-churn machine-local
+ * archived journals, council manifests. The high-churn machine-local
  * stuff (events.ndjson, .pid-map/, active/, .last-intent.*) stays put.
  *
  * Subcommands:
@@ -29,7 +29,7 @@ import { syncJsoncConfig } from "../core/config.ts";
 
 // What we sync. Anything matching one of these (relative to .harnery/) is
 // considered part of the sync set. Everything else stays local-only.
-const SYNC_PATHS = ["identities/", "scratch/archived/", "councils/"];
+const SYNC_PATHS = ["identities/", "journal/archived/", "councils/"];
 
 interface SyncConfig {
   remote: string;
@@ -145,7 +145,7 @@ export function registerSyncCommand(program: Command, emit: EmitContext): void {
     .command("sync")
     .description(
       "Cross-machine sync of curated .harnery/ subset (identities, archived " +
-        "scratchpads, council manifests) via rclone. Google Drive is the " +
+        "journals, council manifests) via rclone. Google Drive is the " +
         "expected remote; any rclone backend works.",
     );