breakaway 2.0.2-main.1 → 2.0.2-main.3

package/scripts/tasks/footprint-hook.js

@@ -0,0 +1,188 @@
+/**
+ * What the session hooks do about footprints (docs/specs/IDEA-55-footprints.md, sections 1a and 1b): the edit hook
+ * claims the file an edit names before it runs, and the session hook reports the agent's dirty paths. Pure, apart from
+ * the notes kept in the system's temp folder (never the repository, where a cloud session's Stop check would take a new
+ * file as work to commit), so it's tested without git or a board.
+ */
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { EDIT_MATCHER } from '../../src/init.js';
+
+const EDIT_TOOLS = new Set(EDIT_MATCHER.split('|'));
+
+/**
+ * How long the edit hook waits for the board before it lets the edit through. Claude Code's own `timeout` on the hook
+ * (EDIT_HOOK_TIMEOUT in src/init.js) is the backstop: a PreToolUse command hook that times out doesn't block the tool
+ * call (source: https://code.claude.com/docs/en/hooks, "A timed-out command, http, or mcp_tool hook doesn't block the
+ * tool call").
+ */
+export const EDIT_CLAIM_MS = 3000;
+/** Dirty paths go to the board at most this often (section 1b). */
+export const DIRTY_EVERY_MS = 60_000;
+
+/** Whether a hook event is an edit tool's. */
+export function isEdit(hook) {
+  return EDIT_TOOLS.has(hook?.tool_name);
+}
+
+/**
+ * The repository path an edit names, or null when it names none or one outside the checkout (or inside `.git/`).
+ * Claude Code hands the file tools' `file_path` over absolute, with backslashes on Windows (source:
+ * https://code.claude.com/docs/en/hooks, "For the file tools Write, Edit, and Read, tool_input.file_path is always
+ * absolute"); NotebookEdit names `notebook_path`.
+ * @param {any} hook the hook's input
+ * @param {string} root the checkout's root
+ */
+export function editedPath(hook, root) {
+  const raw = hook?.tool_input?.file_path ?? hook?.tool_input?.notebook_path;
+  if (typeof raw !== 'string' || !raw.trim()) return null;
+  const path = raw.replaceAll('\\', '/');
+  const base = String(root ?? '')
+    .replaceAll('\\', '/')
+    .replace(/\/+$/u, '');
+  let rel;
+  if (/^(?:\/|[A-Za-z]:\/)/u.test(path)) {
+    if (!base || !path.startsWith(`${base}/`)) return null;
+    rel = path.slice(base.length + 1);
+  } else rel = path;
+  const parts = rel.split('/').filter((p) => p && p !== '.');
+  if (!parts.length || parts.includes('..') || parts[0] === '.git') return null;
+  return parts.join('/');
+}
+
+/**
+ * What the edit hook prints for the board's answer to its claim, or null to stay quiet and let the edit go ahead.
+ * Granted or already the task's: quiet. Refused (409): the edit is denied, with the board's reason, which Claude reads
+ * (`permissionDecision: "deny"` shows `permissionDecisionReason` to Claude; source: https://code.claude.com/docs/en/hooks,
+ * PreToolUse decision control). Anything else: the edit goes ahead, and Claude hears why it isn't claimed
+ * (`additionalContext`, same source), because a board that's down never stops work.
+ * @param {{ status: number, data?: any } | { error: string }} answer
+ * @param {string} path
+ * @param {{ wid?: string | null }} claim
+ */
+export function editOutput(answer, path, claim) {
+  if ('status' in answer && answer.status >= 200 && answer.status < 300) return null;
+  if ('status' in answer && answer.status === 409) {
+    const reason =
+      typeof answer.data?.error === 'string' && answer.data.error.trim()
+        ? answer.data.error.trim()
+        : `\`${path}\` is claimed by another task. Back off: change other files, ask its holder on the peloton, or comment why and release your task.`;
+    return {
+      hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason },
+    };
+  }
+  const why =
+    'error' in answer
+      ? answer.error
+      : typeof answer.data?.error === 'string'
+        ? `HTTP ${answer.status}: ${answer.data.error}`
+        : `HTTP ${answer.status}`;
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: `The board didn't grant a claim on \`${path}\` (${String(why).slice(0, 200)}), so this edit went ahead unclaimed. Claims are advisory: carry on, and once the board answers, claim it with npx breakaway paths ${claim?.wid ?? '<your task>'} --claim ${path}.`,
+    },
+  };
+}
+
+/**
+ * `git status --porcelain -z` → the paths it names: a rename's or copy's new path and its old one, an untracked file,
+ * and a deleted one alike.
+ * @param {string} out
+ */
+export function porcelainPaths(out) {
+  const parts = String(out ?? '').split('\0');
+  /** @type {string[]} */
+  const paths = [];
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    paths.push(entry.slice(3));
+    // -z puts a rename's or a copy's old path in the next entry, on its own.
+    if (/[RC]/u.test(entry.slice(0, 2)) && parts[i + 1]) paths.push(parts[++i]);
+  }
+  return paths;
+}
+
+/**
+ * The agent's dirty paths (section 1b): what `git status` lists and what differs from the default branch's merge base,
+ * paths only, never contents, sorted. `git(args)` runs git in the checkout and answers its output, or null when it
+ * fails. Null when git can't say at all (not a checkout).
+ * @param {(args: string[]) => string | null} git
+ */
+export function dirtyPaths(git) {
+  const status = git(['status', '--porcelain', '-z', '--untracked-files=all']);
+  if (status === null) return null;
+  const paths = new Set(porcelainPaths(status));
+  const head = git(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])?.trim();
+  for (const branch of [head, 'origin/main', 'origin/master'].filter(Boolean)) {
+    const base = git(['merge-base', 'HEAD', /** @type {string} */ (branch)])?.trim();
+    if (!base) continue;
+    const diff = git(['diff', '--name-only', '-z', base]);
+    for (const path of String(diff ?? '').split('\0')) if (path) paths.add(path);
+    break;
+  }
+  return [...paths].sort();
+}
+
+const notePath = (kind, uuid, dir) => join(dir, `breakaway-${kind}-${String(uuid).replace(/[^\w-]/gu, '')}`);
+
+/** Whether the session hook should report dirty paths now: an edit tool's call or a stop, at most once a minute. */
+export function dirtyDue(hook, uuid, { dir = tmpdir(), now = Date.now() } = {}) {
+  if (!isEdit(hook) && hook?.hook_event_name !== 'Stop') return false;
+  let last = 0;
+  try {
+    last = Number(readFileSync(notePath('dirty', uuid, dir), 'utf8')) || 0;
+  } catch {
+    /* never sent */
+  }
+  if (now - last < DIRTY_EVERY_MS) return false;
+  try {
+    writeFileSync(notePath('dirty', uuid, dir), String(now));
+  } catch {
+    /* nowhere to note it: it sends again next time */
+  }
+  return true;
+}
+
+/**
+ * The board's answer about the dirty paths → what Claude hears: each conflict the board flagged for the first time
+ * (section 1b), or '' when there's none.
+ * @param {{ conflicts?: { path: string, task: string, agent: string, pattern: string, new?: boolean }[] } | undefined} footprint
+ */
+export function conflictText(footprint) {
+  const fresh = (footprint?.conflicts ?? []).filter((c) => c?.new);
+  return fresh
+    .map(
+      (c) =>
+        `You changed \`${c.path}\`, which ${c.agent} claims on ${c.task} (\`${c.pattern}\`). Agree on the peloton who goes first (@${c.agent}); by default the second one backs off and leaves the file to its holder.`,
+    )
+    .join('\n');
+}
+
+/**
+ * A note the session hook couldn't hand Claude yet (a Stop's output can't carry context): kept for the task until its
+ * next event that can. `keepNote` adds to it; `takeNote` answers it and clears it.
+ */
+export function keepNote(uuid, text, dir = tmpdir()) {
+  if (!text) return;
+  const before = takeNote(uuid, dir);
+  try {
+    writeFileSync(notePath('note', uuid, dir), [before, text].filter(Boolean).join('\n').slice(-4000));
+  } catch {
+    /* nowhere to keep it */
+  }
+}
+
+/** The kept note for task `uuid`, cleared, or ''. */
+export function takeNote(uuid, dir = tmpdir()) {
+  const path = notePath('note', uuid, dir);
+  try {
+    const text = readFileSync(path, 'utf8');
+    rmSync(path, { force: true });
+    return text;
+  } catch {
+    return '';
+  }
+}

package/scripts/tasks/hook-config.js

@@ -7,7 +7,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { boardUrl, configDir, parseEnvFile, readSetting, settingFrom } from './settings.js';
+import { authHeaders, boardUrl, configDir, parseEnvFile, readSetting, settingFrom } from './settings.js';
 
 /** The git root of the current folder, or null outside a repository. */
 function gitRoot() {
@@ -70,9 +70,9 @@ export function boardConfig(root = projectRoot()) {
   }
   const { url } = boardUrl({ env: process.env, file, taskrc: readOptional(join(root, '.taskrc')), config });
   // In a cloud session there's no token here: the environment's API credential adds it. In the plugin's hooks, its
-  // `token` comes after the CLI's own (CLI-8).
+  // `token` comes after the CLI's own (CLI-8). A lent run's key goes in its own header (BRK-324).
   const token = settingFrom('TOKEN', { env: process.env, file }).value;
-  return { base: url, headers: token ? { Authorization: `Bearer ${token}` } : {} };
+  return { base: url, headers: authHeaders(token, settingFrom('RUN_KEY', { env: process.env, file }).value) };
 }
 
 /** The board says this checkout's task isn't claimed by its agent any more: drop the marker so later calls post nothing (BRK-87). */

package/scripts/tasks/mcp.js

@@ -3,6 +3,7 @@
  * board's /mcp, and whether it answers. Pure apart from the `fetch` it's handed, so it's tested without a board.
  */
 import { githubFromRemote, pickRepo } from './repo.js';
+import { authHeaders } from './settings.js';
 
 /** The MCP revision `--check` speaks: the one with an `initialize` handshake, which /mcp accepts (src/mcp.js, LEGACY). */
 export const CHECK_PROTOCOL = '2025-11-25';
@@ -57,12 +58,14 @@ export function mcpConfig({ url, agent, repo = null, tokenVar }) {
  * tasks.env). Otherwise it's `agent`, claude-<branch>, as X-Breakaway-Agent-Default: the helper can't see the plugin's
  * agent_name, which the plugin sends as a static X-Breakaway-Agent that this one would override, and /mcp takes the
  * default only when that's empty (CLI-16).
- * @param {{ token?: string | null, named?: string | null, agent: string, repo?: string | null }} options
+ *
+ * A lent run's key (`runKey`, BRK-324) goes in its own header, which a cloud session's proxy leaves alone.
+ * @param {{ token?: string | null, runKey?: string | null, named?: string | null, agent: string, repo?: string | null }} options
  * @returns {Record<string, string>}
  */
-export function mcpHeaders({ token = null, named = null, agent, repo = null }) {
+export function mcpHeaders({ token = null, runKey = null, named = null, agent, repo = null }) {
   return {
-    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    ...authHeaders(token, runKey),
     ...(repo
       ? {
           ...(named ? { 'X-Breakaway-Agent': named } : { 'X-Breakaway-Agent-Default': agent }),
@@ -77,15 +80,15 @@ export function mcpHeaders({ token = null, named = null, agent, repo = null }) {
  * null when it tracks none of them. A plugin's headersHelper runs without the plugin's settings, so with only the
  * plugin set up there's no token to ask with: then it's the checkout's GitHub `owner/name`, which /mcp matches against
  * its repositories itself (src/mcp.js). `named` is --repo or BREAKAWAY_REPO. Never throws: Claude Code is waiting.
- * @param {{ base?: string | null, token?: string | null, named?: string | null, remote?: string | null, fetch: typeof globalThis.fetch }} options
+ * @param {{ base?: string | null, token?: string | null, runKey?: string | null, named?: string | null, remote?: string | null, fetch: typeof globalThis.fetch }} options
  * @returns {Promise<string | null>}
  */
-export async function headersRepo({ base = null, token = null, named = null, remote = null, fetch }) {
+export async function headersRepo({ base = null, token = null, runKey = null, named = null, remote = null, fetch }) {
   let registry = null;
   if (base)
     try {
       const res = await fetch(`${String(base).replace(/\/+$/u, '')}/api/repos`, {
-        headers: token ? { Authorization: `Bearer ${token}` } : {},
+        headers: authHeaders(token, runKey),
         signal: AbortSignal.timeout(5000),
       });
       if (res.ok) registry = await res.json();
@@ -133,12 +136,12 @@ export function mcpLines(config, { repo = null, tokenVar }) {
 /**
  * `--check`: an `initialize` and a `tools/list` against /mcp with the same headers the config sends, and what came
  * back. `ok` is false with the board's own error when either fails.
- * @param {{ endpoint: string, token?: string | null, agent: string, repo?: string | null, fetch: typeof globalThis.fetch }} options
+ * @param {{ endpoint: string, token?: string | null, runKey?: string | null, agent: string, repo?: string | null, fetch: typeof globalThis.fetch }} options
  * @returns {Promise<{ ok: boolean, lines: string[] }>}
  */
-export async function checkMcp({ endpoint, token = null, agent, repo = null, fetch }) {
+export async function checkMcp({ endpoint, token = null, runKey = null, agent, repo = null, fetch }) {
   const headers = {
-    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    ...authHeaders(token, runKey),
     'Content-Type': 'application/json',
     Accept: 'application/json, text/event-stream',
     'X-Breakaway-Agent': agent,

package/scripts/tasks/peloton.js

@@ -37,7 +37,9 @@ const usable = (p) => typeof p?.id === 'number' && typeof p?.text === 'string' &
 const fromOwner = (p) => p.agent === 'owner' && !p.task;
 const author = (p) => {
   if (fromOwner(p)) return 'the owner';
-  return p.agent === 'board' && !p.task ? 'the board' : `${p.agent}${p.task ? ` on ${p.task}` : ''}`;
+  if (p.agent === 'board' && !p.task) return 'the board';
+  // A person the owner invited posts from the board with no task (BRK-303): named, never taken for the owner.
+  return p.task ? `${p.agent} on ${p.task}` : `${p.agent} via the board`;
 };
 const noPeloton = (agent) =>
   `${agent || 'this agent'} rides no peloton: claim your task first (npx breakaway claim <task>), then check in`;
@@ -240,6 +242,23 @@ export function planLines(plan, { indent = '' } = {}) {
   return [head, ...body];
 }
 
+/** Patterns shown of one rider's footprint before "and n more". */
+const SHOWN_PATTERNS = 6;
+
+/**
+ * What a rider is changing, after its name (IDEA-55 section 4): its footprint, and which of the reader's own paths
+ * overlap it. '' when the board doesn't know.
+ * @param {{ changing?: string[], overlaps?: string[] }} rider
+ */
+export function riderFootprint(rider) {
+  const changing = rider?.changing ?? [];
+  if (!changing.length) return '';
+  const more = changing.length - SHOWN_PATTERNS;
+  const list = `${changing.slice(0, SHOWN_PATTERNS).join(', ')}${more > 0 ? ` and ${more} more` : ''}`;
+  const overlaps = rider.overlaps?.length ? `; overlaps yours: ${rider.overlaps.join(', ')}` : '';
+  return `: changing ${list}${overlaps}`;
+}
+
 /**
  * The agent's views → what `npx breakaway peloton` prints: each peloton's riders, its open huddle and its plan (a
  * chase's), then its new posts and the newest SHOWN_POSTS (every one with `all`), new ones starred.
@@ -258,7 +277,9 @@ export function pelotonLines(views, { agent, all = false } = {}) {
       const lines = [`${v.peloton} (you ride it on ${v.task}): ${state}`];
       for (const r of roster) {
         const since = sentAt(r.since);
-        lines.push(`  ${r.agent}${r.task ? ` on ${r.task}` : ''}${since ? `, since ${since}` : ''}`);
+        lines.push(
+          `  ${r.agent}${r.task ? ` on ${r.task}` : ''}${since ? `, since ${since}` : ''}${riderFootprint(r)}`,
+        );
       }
       if (v.huddle) lines.push(...huddleLines(v.huddle));
       if (v.plan) lines.push(...planLines(v.plan, { indent: '  ' }));

package/scripts/tasks/plugin-hooks.js

@@ -10,6 +10,8 @@ import { join } from 'node:path';
 /** A session hook command repos init writes: through npx, any version, or an old copy's script. */
 const BOARD_HOOK =
   /\bbreakaway(?:@[^\s"]+)? hook (?:session|wait)\b|scripts\/tasks\/(?:session-hook|message-wait)\.mjs/u;
+/** The edit hook (IDEA-55): settings from before it run the other hooks but not this one. */
+const EDIT_HOOK = /\bbreakaway(?:@[^\s"]+)? hook edit\b|scripts\/tasks\/edit-hook\.mjs/u;
 
 /** A file's text, or null when it can't be read. */
 function readOptional(path) {
@@ -24,9 +26,8 @@ function readOptional(path) {
  * Whether this hook is the plugin's and the checkout's settings already run the board's hooks, so this one does
  * nothing. Outside the plugin it's always false: the checkout's own hooks always run.
  */
-export function checkoutRunsHooks(root, env = process.env, read = readOptional) {
+export function checkoutRunsHooks(root, env = process.env, read = readOptional, hook = 'session') {
   if (!env.CLAUDE_PLUGIN_ROOT) return false;
-  return ['settings.json', 'settings.local.json'].some((name) =>
-    BOARD_HOOK.test(read(join(root, '.claude', name)) ?? ''),
-  );
+  const runs = hook === 'edit' ? EDIT_HOOK : BOARD_HOOK;
+  return ['settings.json', 'settings.local.json'].some((name) => runs.test(read(join(root, '.claude', name)) ?? ''));
 }

package/scripts/tasks/session-hook.mjs

@@ -13,9 +13,15 @@
  * that fails leaves its reason in the temp folder, which the CLI's next command here shows (BRK-86).
  *
  * Run by the plugin at SessionStart, it first passes the plugin's settings on to the session's Bash commands (CLI-8).
+ *
+ * After an edit tool's call and at a stop, at most once a minute, the post carries the agent's dirty paths (paths
+ * only, never contents), and the board answers with what they conflict with, which Claude hears on its next turn
+ * (docs/specs/IDEA-55-footprints.md, section 1b).
  */
 import { checkoutRunsHooks } from './plugin-hooks.js';
 import { boardConfig, claimedTask, dropClaim, projectRoot } from './hook-config.js';
+import { execFileSync } from 'node:child_process';
+import { conflictText, dirtyDue, dirtyPaths, keepNote, takeNote } from './footprint-hook.js';
 import { passPluginEnv } from './plugin-env.js';
 import { clearHookFailure, noteHookFailure, sessionRequest } from './proxy.js';
 import { entryFor } from './session-log.js';
@@ -37,6 +43,7 @@ async function main() {
 
   const { base, headers } = boardConfig(root);
   if (!base) return noteHookFailure(claim.uuid, 'no board address: set BREAKAWAY_URL');
+  const dirty = claim.agent && dirtyDue(hook, claim.uuid) ? dirtyPaths(git(root)) : null;
   let res;
   try {
     // Through curl in a cloud session, so it works on whichever Node runs hooks there (BRK-86).
@@ -50,6 +57,7 @@ async function main() {
         entries: [entry],
         // A Stop hook's output can't reach Claude, so it leaves the messages for the next event.
         messages: CONTEXT_EVENTS.has(hook.hook_event_name),
+        ...(dirty ? { dirty } : {}),
       }),
       timeoutMs: 4000,
     });
@@ -65,10 +73,31 @@ async function main() {
     if (output) process.stdout.write(`${JSON.stringify(output)}\n`);
     return;
   }
-  const output = messageOutput(answer, hook.hook_event_name);
+  // What the dirty paths conflict with, and what an earlier event couldn't say, go with the messages.
+  const conflicts = conflictText(answer?.footprint);
+  if (!CONTEXT_EVENTS.has(hook.hook_event_name)) return keepNote(claim.uuid, conflicts);
+  const note = [takeNote(claim.uuid), conflicts].filter(Boolean).join('\n');
+  const output = messageOutput(answer, hook.hook_event_name, note);
   if (output) process.stdout.write(`${JSON.stringify(output)}\n`);
 }
 
+/** Runs git in the checkout: its output, or null when it fails. */
+function git(root) {
+  return (/** @type {string[]} */ args) => {
+    try {
+      return execFileSync('git', args, {
+        cwd: root,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 2000,
+        maxBuffer: 4 * 1024 * 1024,
+      });
+    } catch {
+      return null;
+    }
+  };
+}
+
 main()
   .catch(() => {})
   .finally(() => process.exit(0));

package/scripts/tasks/session-messages.js

@@ -20,10 +20,11 @@ export function sentAt(sent) {
 /**
  * The board's answer to the session post, and the hook's event → the JSON the hook prints, or
  * null when there's nothing to say (no messages or posts, an event that can't carry them, a bad answer).
+ * `note` is the hook's own word after them: a conflict on a changed path (IDEA-55 section 1b).
  */
-export function messageOutput(answer, event) {
+export function messageOutput(answer, event, note = '') {
   if (!CONTEXT_EVENTS.has(event)) return null;
-  const text = waitingText(answer);
+  const text = [waitingText(answer), note].filter(Boolean).join('\n\n');
   if (!text) return null;
   return { hookSpecificOutput: { hookEventName: event, additionalContext: text } };
 }
@@ -42,7 +43,9 @@ export function messageText(answer) {
     .filter((m) => typeof m?.text === 'string' && m.text.trim())
     .map((m) => {
       const at = sentAt(m.sent);
-      return `Message from the owner (via the board${at ? `, ${at}` : ''}): ${m.text.trim()}`;
+      // A person's message names them (BRK-303): only the owner's reads "from the owner".
+      const from = typeof m.from === 'string' && m.from && m.from !== 'owner' ? m.from : 'the owner';
+      return `Message from ${from} (via the board${at ? `, ${at}` : ''}): ${m.text.trim()}`;
     })
     .join('\n\n');
 }

package/scripts/tasks/settings.js

@@ -13,6 +13,7 @@ export const NAMES = Object.freeze({
   SECRET: 'BREAKAWAY_SECRET',
   SYNC_KEY: 'BREAKAWAY_SYNC_KEY',
   SESSION_LOG: 'BREAKAWAY_SESSION_LOG',
+  RUN_KEY: 'BREAKAWAY_RUN_KEY',
 });
 
 /**
@@ -26,6 +27,31 @@ export const PLUGIN_OPTIONS = Object.freeze({
   AGENT: 'CLAUDE_PLUGIN_OPTION_AGENT_NAME',
 });
 
+/**
+ * A lent run's key (BRK-324), from the `Run key:` line of the run's payload: the RUN_KEY setting, which `run-key`
+ * saves in tasks.env so the hooks, which don't share the agent's shell, send it too. It travels in its own header,
+ * which a cloud session's proxy leaves alone (it replaces Authorization), and the board takes it over any token beside
+ * it.
+ */
+export const RUN_KEY_HEADER = 'X-Breakaway-Run-Key';
+/** A run key's shape, as the board makes them. */
+export const RUN_KEY = /^bkr_[0-9a-f]{64}$/u;
+
+/**
+ * The headers that say who a request to the board is: the token as Authorization when there is one, and a lent run's
+ * key in its own header when there is one (BRK-324).
+ * @param {string | null | undefined} token
+ * @param {string | null | undefined} [runKey]
+ * @returns {Record<string, string>}
+ */
+export function authHeaders(token, runKey = null) {
+  const key = String(runKey ?? '').trim();
+  return {
+    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    ...(key ? { [RUN_KEY_HEADER]: key } : {}),
+  };
+}
+
 /**
  * A setting's value: from the environment first, then the env file, else `fallback`. The environment always wins,
  * so `BREAKAWAY_URL=… npx breakaway` points one command elsewhere. The plugin's options aren't read here: see

package/scripts/tasks/structure.js

@@ -82,7 +82,8 @@ export const PING_TEMPLATE = {
       title: 'Create the Sentry project',
       project: 'ops',
       horizon: 'now',
-      tags: ['owner'],
+      who: 'person',
+      assignee: 'owner',
       brief: 'What has to happen and why.',
       done_when: 'What has to be true to call it done.',
       depends: [],
@@ -93,8 +94,7 @@ export const PING_TEMPLATE = {
       type: 'modify',
       task: 'CLD-112',
       horizon: 'next',
-      addTags: ['owner'],
-      removeTags: ['agent'],
+      who: 'person',
       done_when: 'The new done when.',
     },
     { type: 'done', task: 'CLD-113', note: 'Does not reproduce any more; it behaves as expected.' },
@@ -161,7 +161,7 @@ export function ownerSaidLines(t) {
         .map((l) => `    > ${l}`.trimEnd()),
     );
     out.push(
-      `      (${q.from}, ${q.by === 'owner' ? 'from the owner' : `quoted by ${q.by}`}${q.at ? `, ${String(q.at).slice(0, 10)}` : ''})`,
+      `      (${q.from}, ${q.by === 'owner' ? 'from the owner' : q.from === 'board' ? `${q.by}’s own words` : `quoted by ${q.by}`}${q.at ? `, ${String(q.at).slice(0, 10)}` : ''})`,
     );
   }
   return out;