harnery 0.32.0 → 0.34.0

package/src/lib/instructions/apply.ts

@@ -14,8 +14,9 @@
  *     so a fresh consumer gets a CLAUDE.md whose managed region imports
  *     `@AGENTS.md`. A CLAUDE.md that already imports AGENTS.md or already carries
  *     the block (a host that generates CLAUDE.md from AGENTS.md) is left alone.
- *   - `.claude/skills/<skill>/SKILL.md` — claude-code only; fully-owned files,
- *     honoring `skills.exclude` in `.harnery/config.jsonc`.
+ *   - `<adapter-skill-dir>/<skill>/SKILL.md` — fully-owned files, honoring
+ *     `skills.exclude` in `.harnery/config.jsonc`. Claude Code uses
+ *     `.claude/skills/`; Cursor and Codex use `.agents/skills/`.
  */
 
 import {
@@ -49,7 +50,15 @@ import {
 
 const AGENTS_FILE = "AGENTS.md";
 const CLAUDE_FILE = "CLAUDE.md";
-const CLAUDE_SKILLS_DIR = join(".claude", "skills");
+const ADAPTER_SKILLS_DIR: Readonly<Record<string, string>> = {
+  "claude-code": join(".claude", "skills"),
+  cursor: join(".agents", "skills"),
+  codex: join(".agents", "skills"),
+};
+
+function adapterSkillsDir(adapter: string): string | null {
+  return ADAPTER_SKILLS_DIR[adapter] ?? null;
+}
 
 /** CLAUDE.md import-shim body: points Claude Code (which reads CLAUDE.md, not AGENTS.md) at AGENTS.md. */
 function importBody(): string {
@@ -79,16 +88,17 @@ export function readSkillsExclude(projectRoot: string): Set<string> {
 
 /**
  * Which shipped skills exist for this project, so the block references only the
- * ones actually present: claude-code writes skills (unless excluded); cursor and
- * codex get the block but no skill files, so both read false there. Kept in one
- * place so `applyInstructions` and `checkInstructions` render byte-identical blocks.
+ * ones actually present for every supported adapter, unless excluded. Kept in
+ * one place so `applyInstructions` and `checkInstructions` render byte-identical
+ * blocks.
  */
 function blockSkills(projectRoot: string, adapter: string): BlockSkills {
-  const claudeCode = adapter === "claude-code";
+  const supported = adapterSkillsDir(adapter) !== null;
   const exclude = readSkillsExclude(projectRoot);
   return {
-    decide: claudeCode && !exclude.has("harn-decide"),
-    council: claudeCode && !exclude.has("harn-council"),
+    decide: supported && !exclude.has("harn-decide"),
+    council: supported && !exclude.has("harn-council"),
+    end: supported && !exclude.has("harn-end"),
   };
 }
 
@@ -105,13 +115,14 @@ export interface ApplyResult {
 
 /**
  * Inject / refresh the instructions block, the CLAUDE.md import shim (claude-code),
- * and the shipped skills (claude-code). Idempotent: a re-run on current content
+ * and the adapter-native shipped skills. Idempotent: a re-run on current content
  * writes nothing. `dryRun` reports without touching the fs.
  */
 export function applyInstructions(projectRoot: string, opts: ApplyOpts): ApplyResult {
   const actions: string[] = [];
   const warnings: string[] = [];
   const claudeCode = opts.adapter === "claude-code";
+  const skillsDir = adapterSkillsDir(opts.adapter);
   // dry-run narrates the future ("would create"); a real run narrates the past.
   const verbed = (base: string, past: string) => (opts.dryRun ? `would ${base}` : past);
 
@@ -191,15 +202,15 @@ export function applyInstructions(projectRoot: string, opts: ApplyOpts): ApplyRe
     }
   }
 
-  // ── shipped skills (claude-code only) ───────────────────────────────────
-  if (claudeCode) {
+  // ── shipped skills ───────────────────────────────────────────────────────
+  if (skillsDir) {
     const exclude = readSkillsExclude(projectRoot);
     for (const skill of SKILLS) {
       if (exclude.has(skill.id)) {
         actions.push(`· skipped skill ${skill.id} (skills.exclude)`);
         continue;
       }
-      const skillPath = join(projectRoot, CLAUDE_SKILLS_DIR, skill.relPath);
+      const skillPath = join(projectRoot, skillsDir, skill.relPath);
       const content = skill.render(opts.binName);
       const before = existsSync(skillPath) ? readFileSync(skillPath, "utf8") : null;
       if (before === content) {
@@ -235,6 +246,7 @@ export function removeInstructions(projectRoot: string, opts: RemoveOpts): Apply
   const actions: string[] = [];
   const warnings: string[] = [];
   const claudeCode = opts.adapter === "claude-code";
+  const skillsDir = adapterSkillsDir(opts.adapter);
 
   // ── AGENTS.md block + host addendum ─────────────────────────────────────
   const agentsPath = join(projectRoot, AGENTS_FILE);
@@ -288,10 +300,10 @@ export function removeInstructions(projectRoot: string, opts: RemoveOpts): Apply
     }
   }
 
-  // ── shipped skills (claude-code) ────────────────────────────────────────
-  if (claudeCode) {
+  // ── shipped skills ───────────────────────────────────────────────────────
+  if (skillsDir) {
     for (const skill of SKILLS) {
-      const skillPath = join(projectRoot, CLAUDE_SKILLS_DIR, skill.relPath);
+      const skillPath = join(projectRoot, skillsDir, skill.relPath);
       if (!existsSync(skillPath)) continue;
       if (!isOwnedFile(readFileSync(skillPath, "utf8"))) {
         warnings.push(`left ${skill.relPath} (hand-edited; no harnery ownership marker)`);
@@ -299,7 +311,7 @@ export function removeInstructions(projectRoot: string, opts: RemoveOpts): Apply
       }
       if (!opts.dryRun) {
         rmSync(skillPath);
-        // drop the now-empty skill dir (harn-decide/), leaving .claude/skills/ intact
+        // Drop the now-empty harn-* dir, leaving the adapter skills root intact.
         const dir = dirname(skillPath);
         try {
           if (readdirSync(dir).length === 0) rmdirSync(dir);
@@ -321,7 +333,7 @@ export interface CheckResult {
 
 /**
  * Read-only drift report for `init --check`: the AGENTS.md block and each
- * shipped skill (claude-code). Fresh → exit 0; any stale / missing / hand-edit
+ * shipped skill for the selected adapter. Fresh → exit 0; stale / missing / hand-edit
  * → drift (exit 2); an unreadable file → error (exit 1). Mirrors the wiki-theme
  * `--check-only` contract the first host wires into pre-commit.
  */
@@ -361,11 +373,12 @@ export function checkInstructions(
       issues.push(`${AGENTS_FILE} host addendum: present but no longer configured (re-run init)`);
     }
 
-    if (opts.adapter === "claude-code") {
+    const skillsDir = adapterSkillsDir(opts.adapter);
+    if (skillsDir) {
       const exclude = readSkillsExclude(projectRoot);
       for (const skill of SKILLS) {
         if (exclude.has(skill.id)) continue;
-        const skillPath = join(projectRoot, CLAUDE_SKILLS_DIR, skill.relPath);
+        const skillPath = join(projectRoot, skillsDir, skill.relPath);
         const c = existsSync(skillPath) ? readFileSync(skillPath, "utf8") : "";
         note(`skill ${skill.id}`, checkOwnedSkill(c, skillBody(skill.render, opts.binName)));
       }

package/src/lib/instructions/bundle.ts

@@ -0,0 +1,199 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { Adapter } from "../../core/adapter.ts";
+
+export type InstructionComponentRole = "always_loaded" | "just_in_time" | "runtime_config";
+
+export interface InstructionBundleComponent {
+  path: string;
+  role: InstructionComponentRole;
+  bytes: number;
+  sha256: string;
+}
+
+export interface InstructionBundle {
+  schema_version: 1;
+  adapter: Adapter;
+  coord_root: string;
+  profile_root: string;
+  instruction_roots: string[];
+  instruction_bundle_id: string;
+  canonical_source_id: string;
+  components: InstructionBundleComponent[];
+  canonical_sources: InstructionBundleComponent[];
+}
+
+interface BuildBundleOptions {
+  coordRoot: string;
+  cwd: string;
+  adapter: Adapter;
+}
+
+interface Candidate {
+  absolutePath: string;
+  role: InstructionComponentRole;
+}
+
+/**
+ * Build the content identity for the repo-authored instruction surface an
+ * adapter can load at one working path. The identity intentionally excludes
+ * timestamps and git revisions: two checkouts with byte-identical effective
+ * instructions belong to the same cohort.
+ */
+export function buildInstructionBundle(options: BuildBundleOptions): InstructionBundle {
+  const coordRoot = resolve(options.coordRoot);
+  const cwd = resolve(options.cwd);
+  const roots = resolveInstructionRoots(coordRoot, cwd);
+  const profileRoot = roots.at(-1) ?? coordRoot;
+  const components = dedupeCandidates(
+    roots.flatMap((root) => adapterCandidates(root, options.adapter)),
+    coordRoot,
+  );
+  const canonicalSources = dedupeCandidates(
+    roots.flatMap((root) => canonicalCandidates(root)),
+    coordRoot,
+  );
+
+  return {
+    schema_version: 1,
+    adapter: options.adapter,
+    coord_root: coordRoot,
+    profile_root: relativePath(coordRoot, profileRoot),
+    instruction_roots: roots.map((root) => relativePath(coordRoot, root)),
+    instruction_bundle_id: identity("instruction-bundle-v1", options.adapter, components),
+    canonical_source_id: identity("instruction-source-v1", null, canonicalSources),
+    components,
+    canonical_sources: canonicalSources,
+  };
+}
+
+function resolveInstructionRoots(coordRoot: string, cwd: string): string[] {
+  const roots = [coordRoot];
+  if (!isWithin(coordRoot, cwd)) return roots;
+
+  const ancestors: string[] = [];
+  let cursor = cwd;
+  while (cursor !== coordRoot) {
+    if (existsSync(join(cursor, "AGENTS.md")) || existsSync(join(cursor, "CLAUDE.md"))) {
+      ancestors.push(cursor);
+    }
+    const parent = dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+  roots.push(...ancestors.reverse().filter((root) => root !== coordRoot));
+  return roots;
+}
+
+function adapterCandidates(root: string, adapter: Adapter): Candidate[] {
+  const candidates: Candidate[] = [];
+  const addFile = (path: string, role: InstructionComponentRole) => {
+    if (existsSync(path) && lstatSync(path).isFile()) candidates.push({ absolutePath: path, role });
+  };
+  const addTree = (path: string, role: InstructionComponentRole) => {
+    for (const file of walkFiles(path)) candidates.push({ absolutePath: file, role });
+  };
+
+  if (adapter === "claude-code") {
+    addFile(join(root, "CLAUDE.md"), "always_loaded");
+    addTree(join(root, ".claude", "rules"), "always_loaded");
+    addTree(join(root, ".claude", "skills"), "just_in_time");
+    addFile(join(root, ".claude", "settings.json"), "runtime_config");
+    addFile(join(root, ".claude", "settings.local.json"), "runtime_config");
+  } else if (adapter === "cursor") {
+    addFile(join(root, "AGENTS.md"), "always_loaded");
+    addTree(join(root, ".cursor", "rules"), "always_loaded");
+    addTree(join(root, ".agents", "skills"), "just_in_time");
+    addTree(join(root, ".cursor", "skills"), "just_in_time");
+    addFile(join(root, ".cursor", "hooks.json"), "runtime_config");
+  } else {
+    addFile(join(root, "AGENTS.md"), "always_loaded");
+    addTree(join(root, ".agents", "skills"), "just_in_time");
+    addFile(join(root, ".codex", "hooks.json"), "runtime_config");
+  }
+
+  // Harnery's host configuration governs hook enforcement for all adapters.
+  addFile(join(root, ".harnery", "config.jsonc"), "runtime_config");
+  return candidates;
+}
+
+function canonicalCandidates(root: string): Candidate[] {
+  const candidates: Candidate[] = [];
+  const agents = join(root, "AGENTS.md");
+  if (existsSync(agents) && lstatSync(agents).isFile()) {
+    candidates.push({ absolutePath: agents, role: "always_loaded" });
+  }
+  for (const file of walkFiles(join(root, ".agents"))) {
+    candidates.push({ absolutePath: file, role: "just_in_time" });
+  }
+  return candidates;
+}
+
+function walkFiles(root: string): string[] {
+  if (!existsSync(root) || !lstatSync(root).isDirectory()) return [];
+  const files: string[] = [];
+  const visit = (dir: string) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) =>
+      a.name.localeCompare(b.name),
+    )) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) visit(path);
+      else if (entry.isFile()) files.push(path);
+    }
+  };
+  visit(root);
+  return files;
+}
+
+function dedupeCandidates(
+  candidates: Candidate[],
+  coordRoot: string,
+): InstructionBundleComponent[] {
+  const byPath = new Map<string, Candidate>();
+  for (const candidate of candidates) {
+    const key = resolve(candidate.absolutePath);
+    const prior = byPath.get(key);
+    if (!prior || roleRank(candidate.role) < roleRank(prior.role)) byPath.set(key, candidate);
+  }
+
+  return [...byPath.values()]
+    .map(({ absolutePath, role }) => {
+      const bytes = readFileSync(absolutePath);
+      return {
+        path: relativePath(coordRoot, absolutePath),
+        role,
+        bytes: bytes.byteLength,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+      };
+    })
+    .sort((a, b) => a.path.localeCompare(b.path) || a.role.localeCompare(b.role));
+}
+
+function identity(
+  prefix: string,
+  adapter: Adapter | null,
+  components: InstructionBundleComponent[],
+): string {
+  const body = components.map(({ path, role, sha256 }) => ({ path, role, sha256 }));
+  return `sha256:${createHash("sha256")
+    .update(JSON.stringify({ prefix, ...(adapter ? { adapter } : {}), components: body }))
+    .digest("hex")}`;
+}
+
+function relativePath(root: string, path: string): string {
+  const rel = relative(root, path);
+  return rel === "" ? "." : rel.split(sep).join("/");
+}
+
+function isWithin(root: string, path: string): boolean {
+  if (!isAbsolute(root) || !isAbsolute(path)) return false;
+  const rel = relative(root, path);
+  return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== "..");
+}
+
+function roleRank(role: InstructionComponentRole): number {
+  if (role === "always_loaded") return 0;
+  if (role === "runtime_config") return 1;
+  return 2;
+}

package/src/lib/instructions/splice.ts

@@ -32,6 +32,24 @@ function escapeRe(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+function trimHorizontalWhitespaceBeforeNewlines(content: string): string {
+  const chunks: string[] = [];
+  let segmentStart = 0;
+  for (let index = 0; index < content.length; index++) {
+    if (content.charCodeAt(index) !== 10) continue;
+    let segmentEnd = index;
+    while (segmentEnd > segmentStart) {
+      const code = content.charCodeAt(segmentEnd - 1);
+      if (code !== 32 && code !== 9) break;
+      segmentEnd--;
+    }
+    chunks.push(content.slice(segmentStart, segmentEnd), "\n");
+    segmentStart = index + 1;
+  }
+  chunks.push(content.slice(segmentStart));
+  return chunks.join("");
+}
+
 /**
  * Marker comment style. Markdown/HTML files wrap markers in HTML comments;
  * shell files (git hooks) use `#` line comments. The style only changes the
@@ -94,7 +112,7 @@ export function spliceRegion(
     const text = content.replace(re, () => fresh);
     return { text, changed: text !== content, had: true, stale };
   }
-  const trimmed = content.replace(/\s+$/, "");
+  const trimmed = content.trimEnd();
   const text = trimmed ? `${trimmed}\n\n${fresh}\n` : `${fresh}\n`;
   return { text, changed: true, had: false, stale: false };
 }
@@ -112,9 +130,7 @@ export function removeRegion(
 ): { text: string; removed: boolean } {
   const re = regionRe(region, style);
   if (!re.test(content)) return { text: content, removed: false };
-  const stripped = content
-    .replace(re, "")
-    .replace(/[ \t]+\n/g, "\n")
+  const stripped = trimHorizontalWhitespaceBeforeNewlines(content.replace(re, ""))
     .replace(/\n{3,}/g, "\n\n")
     .trim();
   return { text: stripped ? `${stripped}\n` : "", removed: true };
@@ -150,15 +166,13 @@ export function isOwnedFile(content: string): boolean {
 export function buildOwnedSkill(opts: {
   name: string;
   description: string;
-  argumentHint?: string;
   binName: string;
   body: string;
 }): string {
   const fm = [
     "---",
     `name: ${opts.name}`,
-    `description: ${opts.description}`,
-    ...(opts.argumentHint ? [`argument-hint: ${JSON.stringify(opts.argumentHint)}`] : []),
+    `description: ${JSON.stringify(opts.description)}`,
     "---",
   ].join("\n");
   const body = opts.body.trim();

package/src/lib/instructions/templates.ts

@@ -28,10 +28,12 @@ export const HOST_ADDENDUM_REGION = "host-addendum";
 
 /** Which shipped skills exist in the project the block is rendered for. */
 export interface BlockSkills {
-  /** the `harn-decide` skill file is present (claude-code, not excluded) */
+  /** the `harn-decide` skill file is present */
   decide: boolean;
   /** the `harn-council` skill file is present */
   council: boolean;
+  /** the `harn-end` skill file is present */
+  end: boolean;
 }
 
 /**
@@ -39,22 +41,24 @@ export interface BlockSkills {
  * lines: it costs every agent context on every turn, so it states that each
  * surface *exists* and gives one line of *when* — the *how* lives in the skills
  * and each command's `--help`. Skill names are fixed (`harn-decide`,
- * `harn-council`) even for a renamed bin; only command strings track `binName`.
+ * `harn-council`, `harn-end`) even for a renamed bin; only command strings
+ * track `binName`.
  *
  * The block only points at a skill that actually exists here: a host that
- * excludes one via `skills.exclude`, or a adapter with no skill primitive
- * (cursor/codex get the block but no skill files), gets a `--help` pointer
- * instead of a dangling reference to a skill it doesn't have.
+ * excludes one via `skills.exclude` gets a CLI pointer instead of a dangling
+ * reference to a skill it doesn't have.
  */
 export function renderInstructionsBlock(
   binName: string,
-  skills: BlockSkills = { decide: true, council: true },
+  skills: BlockSkills = { decide: true, council: true, end: true },
 ): string {
   const b = binName;
 
-  const named = [skills.decide && "`harn-decide`", skills.council && "`harn-council`"].filter(
-    Boolean,
-  ) as string[];
+  const named = [
+    skills.decide && "`harn-decide`",
+    skills.council && "`harn-council`",
+    skills.end && "`harn-end`",
+  ].filter(Boolean) as string[];
   const deeper =
     named.length > 0
       ? `Procedures for the deeper flows live in the ${named.join(" and ")} skill${named.length > 1 ? "s" : ""}.`
@@ -65,6 +69,9 @@ export function renderInstructionsBlock(
   const councilPointer = skills.council
     ? "The `harn-council` skill has the steward and member flow."
     : `See \`${b} agents council --help\` for the steward and member flow.`;
+  const endPointer = skills.end
+    ? "When the whole session is genuinely finished, use the `harn-end` skill as the final workflow."
+    : `When the whole session is genuinely finished, run \`${b} agents status --end-turn --end-session\` as the final tool action.`;
   // Render the journal categories from the canonical enum so this prose can
   // never drift from what `journal add` actually accepts (the "note, plan…" list
   // silently lagged the tool by two categories before this).
@@ -87,6 +94,14 @@ active peers and the files they've claimed; \`${b} agents set-task "<focus>"\`
 declares your current focus so peers can see it. Check for peers before editing
 widely-shared files.
 
+**Task lifecycle.** Beside the activity peers already see, declare whether your
+objective is still open: \`${b} agents lifecycle blocked --reason "<why>"\` when
+it cannot proceed, \`${b} agents lifecycle done\` when it is complete, and
+\`${b} agents lifecycle active\` to reopen. \`done\` requires a current task and
+a passing Git finalization check (dirty or unpushed work refuses, and nothing is
+written). Ordinary \`set-task\` calls never change lifecycle, and a transition
+that re-mints the session title tells you the new name to copy. ${endPointer}
+
 **Dispatching a team.** Everything else here coordinates the agents already
 present. These three start new ones, and they differ by how long the objective
 outlives a single execution. \`${b} run <script>\` is one bounded pass:
@@ -251,7 +266,7 @@ The web UI is the member + steward picker; don't create from the CLI (that skips
 the steward choice). Emit the link with the objective URL-encoded:
 
 \`\`\`
-http://localhost:9000/councils/new?objective=<encoded>
+http://localhost:4276/councils/new?objective=<encoded>
 \`\`\`
 
 If the dev server isn't up, start it with \`${b} web up\`.
@@ -307,6 +322,54 @@ mismatch), and offer the right next step. Don't propose a workaround that bypass
 the guard.`;
 }
 
+function endBody(b: string): string {
+  return `Finalize only after the work is genuinely complete. This is the deliberate,
+high-confidence escape hatch for adapters that do not provide a trustworthy
+native session-end callback.
+
+## Workflow
+
+1. Finish all in-scope work, tests, documentation, commits, pushes, and
+   user-facing reporting first.
+2. Confirm no tool call, open turn, delegated child, file claim, or uncommitted
+   session write remains. Do not fabricate completion or use this skill to hide
+   unfinished work.
+3. Run the closing status and end request as the final tool action:
+
+   \`\`\`bash
+   ${b} agents status --end-turn --end-session
+   \`\`\`
+
+   When automatic identity resolution is unavailable, pass the current native
+   adapter session ID with \`--session-id <id>\`. The command durably queues the
+   authoritative end while it is still running. The adapter's stop hook records
+   \`session.ended\` only after this command, its tool span, and the current turn
+   have closed.
+4. Do not run another tool after a successful request. Reproduce the status
+   output, tell the operator the end is queued, and yield. The terminal event ID
+   becomes available after the response completes and can be verified from a
+   later session or the web UI.
+
+## Refusals and recovery
+
+- If the command reports delegated work, finish or explicitly cancel those
+  children, then try again.
+- If Git finalization fails, complete the repository's required commit and push
+  workflow before retrying.
+- If the V3 ledger is unavailable or unsafe, do not fall back to deleting a
+  projection or writing a synthetic ledger row. Report the failure.
+- Starting a new turn or tool after the request cancels the pending end. Run the
+  workflow again when the session is actually finished.
+- On a manual \`${b} agents end\` call, use \`--outcome failed\`, \`cancelled\`,
+  \`interrupted\`, or \`unknown\` only when that describes the completed session
+  honestly.
+
+Never use this skill to end another operator's session unless the operator
+explicitly identifies it. Use the web control or \`${b} agents end --instance-id
+<id>\` for that operator action; it records immediately for an idle session or
+durably queues the end for its current turn.`;
+}
+
 export const SKILLS: SkillTemplate[] = [
   {
     id: "harn-decide",
@@ -316,7 +379,6 @@ export const SKILLS: SkillTemplate[] = [
         name: "harn-decide",
         description:
           "File a decision into the docket instead of blocking on a human: search precedent, file it, and proceed on a reversible default; or pick up and resolve an open decision with cited evidence. Use whenever you're about to ask a human a decision-shaped question you could resolve yourself.",
-        argumentHint: "[<the decision / question you're facing> | resolve <id> | review]",
         binName,
         body: decideBody(binName),
       }),
@@ -329,10 +391,20 @@ export const SKILLS: SkillTemplate[] = [
         name: "harn-council",
         description:
           "Interact with the multi-agent council system: list / create / show / prompts (steward) / contribute (member). Guards against misrouting: refuses to contribute when you aren't a member, have already contributed, or weren't routed a prompt.",
-        argumentHint:
-          "[<id-or-fragment> | create <objective> | contribute <id> | prompts <id> | show <id>]",
         binName,
         body: councilBody(binName),
       }),
   },
+  {
+    id: "harn-end",
+    relPath: "harn-end/SKILL.md",
+    render: (binName) =>
+      buildOwnedSkill({
+        name: "harn-end",
+        description:
+          "Safely finalize the current Harnery agent session with an authoritative V3 session-ended event. Use when the operator says /harn-end, asks to end or close the current session, or when all work is complete and the session should stop counting as live.",
+        binName,
+        body: endBody(binName),
+      }),
+  },
 ];

package/dist/core/agents/cli-emit.d.ts

@@ -1,27 +0,0 @@
-/**
- * CLI-side canonical event emission helper. Importable from any CLI surface
- * to emit-then-project in one call.
- *
- * Pattern: every state-changing CLI command appends its event first, then
- * runs the projector synchronously for the affected owner.
- */
-import { type EmitInput, type Envelope } from "./events/emit.js";
-export interface EmitAndProjectResult {
-    envelope: Envelope;
-    projected: boolean;
-}
-/**
- * Emit a canonical event AND synchronously project it into the owner's v2
- * heartbeat. Idempotent on event_id: replays don't double-apply.
- *
- * Returns the emitted envelope so callers can inspect / log.
- *
- * Soft-fails on any internal error: never throws into the caller, because
- * this runs inside operator-facing CLI commands and a corrupt events.ndjson
- * line shouldn't break `agents set-task`.
- */
-export declare function emitAndProject(input: EmitInput, opts?: {
-    coordRoot?: string;
-    skipProject?: boolean;
-}): EmitAndProjectResult | null;
-//# sourceMappingURL=cli-emit.d.ts.map

package/dist/core/agents/cli-emit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-emit.d.ts","sourceRoot":"","sources":["../../../src/core/agents/cli-emit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAQ,MAAM,kBAAkB,CAAC;AAIvE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACvD,oBAAoB,GAAG,IAAI,CAiC7B"}

package/dist/core/agents/cli-emit.js

@@ -1,57 +0,0 @@
-/**
- * CLI-side canonical event emission helper. Importable from any CLI surface
- * to emit-then-project in one call.
- *
- * Pattern: every state-changing CLI command appends its event first, then
- * runs the projector synchronously for the affected owner.
- */
-import { emit } from "./events/emit.js";
-import { findCoordRoot } from "./paths.js";
-import { projectHeartbeats } from "./state/heartbeat-projector.js";
-/**
- * Emit a canonical event AND synchronously project it into the owner's v2
- * heartbeat. Idempotent on event_id: replays don't double-apply.
- *
- * Returns the emitted envelope so callers can inspect / log.
- *
- * Soft-fails on any internal error: never throws into the caller, because
- * this runs inside operator-facing CLI commands and a corrupt events.ndjson
- * line shouldn't break `agents set-task`.
- */
-export function emitAndProject(input, opts = {}) {
-    const root = opts.coordRoot ?? findCoordRoot();
-    if (!root)
-        return null;
-    try {
-        const envelope = emit(root, input);
-        let projected = false;
-        if (!opts.skipProject) {
-            try {
-                projectHeartbeats(root, [
-                    {
-                        schema_version: envelope.schema_version,
-                        event_id: envelope.event_id,
-                        event_type: envelope.event_type,
-                        ts: envelope.ts,
-                        instance_id: envelope.instance_id,
-                        session_id: envelope.session_id,
-                        parent_session_id: envelope.parent_session_id,
-                        turn_id: envelope.turn_id,
-                        parent_turn_id: envelope.parent_turn_id,
-                        adapter: envelope.adapter,
-                        source: envelope.source,
-                        data: envelope.data,
-                    },
-                ]);
-                projected = true;
-            }
-            catch {
-                /* projector failure is non-fatal; next agent-coord project run catches up */
-            }
-        }
-        return { envelope, projected };
-    }
-    catch {
-        return null;
-    }
-}