breakaway 2.0.2-main.2 → 2.0.2-main.3

package/scripts/tasks.mjs

@@ -88,6 +88,7 @@ import {
   staleCliWarning,
   releaseBehind,
   removedRepoByHand,
+  needsOwner,
   unknownSubcommand,
 } from './tasks/cli.js';
 import { InfraReadError, infraRead } from './tasks/infra-read.js';
@@ -112,6 +113,8 @@ import { cwdOf, parentOf, sessionDir } from './tasks/session-dir.js';
 import { parseInstall, secretName } from '../src/install.js';
 import {
   NAMES,
+  RUN_KEY,
+  authHeaders,
   boardUrl,
   configDir,
   parseEnvFile,
@@ -241,10 +244,11 @@ const HELP = `npx breakaway <command> [options]
 
 Reading                (list, next, claim, and add work in this checkout's repository; see Repositories below)
   list                   open tasks, best first (the default command)
-    --ready --blocked --active --mine --owner   narrow it down
+    --ready --blocked --active --mine   narrow it down
+    --who agent|person|decision --assignee <handle|owner>   who does it (--owner: decisions, and people's tasks for the owner or anyone)
     --project <p> --tag <t> --horizon <h> --status pending|completed|deleted|all
   show <ref>             one task: description, done when, related, comments, dependencies, and what it blocks
-  next                   the best ready task for an agent (+agent, not +decide, unclaimed)
+  next                   the best ready task for an agent (who: agent, unclaimed)
     --claim              …and claim it in the same step
     --project <p> --horizon <h> --tag <t>
   activity               recent changes, newest first  [--limit <n>]
@@ -304,13 +308,17 @@ Reading                (list, next, claim, and add work in this checkout's repos
 Working
   claim <ref>            take a task (atomic: fails if someone else has it)  [--force]
                          refuses another repository's task unless --repo names it
+  run-key <key>          a run on a routine the owner lends: save the Run key from its payload in tasks.env, so this
+                         CLI, its hooks, and mcp --headers send it in its own header (BRK-324). It's the run's only
+                         credential, with its person's rights, until its claim ends  [--forget] drops it
   release <ref>          give it back  [--force]
   comment <ref> <text>   add a comment (signed with your agent name); note is the same command
   quote <ref> <words> --from <source>   put the owner's exact words on a task you hold, quoted and marked as yours:
                          shown first on the task and to every agent that claims it. <source> is where they said it:
                          message, peloton, ping, decision, or comment, with a pointer if you have one ("peloton #12")
   review <ref> --verdict ready|follow-up|changes <note>   your review of the pull request that closes the task you
-                         hold: a comment on it, and the review on the pull request's page (the note is Markdown)  [--pr <n>]
+                         hold, or, as a chase's road captain, a task of your chase: a comment on it, and the review on
+                         the pull request's page (the note is Markdown)  [--pr <n>]
   risk-review <ref> --file <findings.json>   a risky-path reviewer's findings on the pull request the board started it
                          for: { "summary", "findings": [{ "severity": "blocking"|"note", "text", "path", "line" }] }
                          [--pr <n>]; without --file, the task's reviews and their answers
@@ -319,11 +327,13 @@ Working
   done <ref>             finish it  [--note <text>] [--pr <url>]
   add <description>      new task; gets the next work ID for its project
     --project <p> --tag <t>… --priority H|M|L --horizon now|next|later
+    --who agent|person|decision   who does it: an agent builds it, a person does it, or the owner decides first
+    --assignee <handle|owner>   on a person's task, who it's for (without one, any member of the repository)
     --repo <slug>        the repository it belongs to (default: the checkout's; its areas decide the prefix)
     --depends <ref,…> --related <ref,…> --spec <path> --due <date> --wait <date>
     --brief <text> | --brief-file <path>   the description (--note is the same)
     --done-when <text>   what has to be true to call it done
-    --decision <file.json>   questions for the owner to answer on the board (adds +decide); see decision --template
+    --decision <file.json>   questions for the owner to answer on the board (makes it a decision); see decision --template
     --force              add it even though it resembles open tasks the board named (--related links them instead)
   decision <ref> --template   print an example decision file to edit (nothing here answers a decision: the owner does, on the board)
   ping <ref> <message>   tell the owner you need them, in the inbox and as a push (you must hold the task; only when they must act)
@@ -373,6 +383,7 @@ Working
     --done-when <text>   change what has to be true to call it done
     --decision <file.json>   set the decision's questions (answers to questions that still exist are kept)
     --related <ref> --unrelated <ref>   add or remove a "see also" link (repeatable; it doesn't block)
+    --who agent|person|decision --assignee <handle|owner>   who does it (--assignee "" removes it)
     --tag <t> --untag <t> --depends <ref> --undepends <ref>   (repeatable)
     --autostart yes|no   start a cloud agent by itself when the task is ready
 
@@ -567,6 +578,7 @@ const FLAGS = new Set([
   'no-captain',
   'handover',
   'anyway',
+  'forget',
 ]);
 /** Flags only in repos init (BRK-91): --pipeline takes a file in repos modify, and is a flag there. */
 const INIT_FLAGS = new Set(['pipeline', 'copies']);
@@ -614,14 +626,15 @@ function fail(message) {
  */
 async function call(method, path, body, { soft = false, raw = false } = {}) {
   // Without a token the request still goes out: in a Claude cloud environment with an API
-  // credential for this host, the agent proxy adds the Authorization header on the way.
+  // credential for this host, the agent proxy adds the Authorization header on the way. A lent run's key goes in its
+  // own header, which the proxy leaves alone (BRK-324).
   const token = setting('TOKEN');
   let res;
   try {
     res = await fetch(`${BASE}/api/${path}`, {
       method,
       headers: {
-        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        ...authHeaders(token, setting('RUN_KEY')),
         ...(body ? { 'Content-Type': 'application/json' } : {}),
       },
       body: body ? JSON.stringify(body) : undefined,
@@ -633,7 +646,7 @@ async function call(method, path, body, { soft = false, raw = false } = {}) {
     );
   }
   warnIfStale(res.headers.get('X-Tasks-Cli'), res.headers.get('X-Tasks-Release'));
-  if (res.status === 401 && !token)
+  if (res.status === 401 && !token && !setting('RUN_KEY'))
     fail(
       `no token. Set BREAKAWAY_TOKEN, put it in ${ENV_FILE}, set it in the breakaway plugin's settings, or add it as an API credential in the cloud environment (see docs/tasks.md#cloud-agents).`,
     );
@@ -705,7 +718,7 @@ async function upload(taskRef, file, alt = '') {
     res = await fetch(`${BASE}/api/tasks/${enc(taskRef)}/attachments`, {
       method: 'POST',
       headers: {
-        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        ...authHeaders(token, setting('RUN_KEY')),
         'Content-Type': 'application/octet-stream',
         'X-Attachment-Name': enc(basename(file)),
         'X-Attachment-Alt': enc(alt),
@@ -799,7 +812,7 @@ async function startSessionLog(t) {
   try {
     const res = await fetch(`${BASE}/api/tasks/${enc(t.uuid)}/session`, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+      headers: { 'Content-Type': 'application/json', ...authHeaders(token, setting('RUN_KEY')) },
       body: JSON.stringify({
         agent: t.claim,
         remote: process.env.CLAUDE_CODE_REMOTE === 'true',
@@ -861,14 +874,25 @@ function line(t) {
     t.description,
   ];
   const extra = [];
+  if (t.who) extra.push(t.who === 'person' ? `person: ${t.assignee ?? 'anyone'}` : t.who);
   if (t.tags.length) extra.push(t.tags.map((x) => `+${x}`).join(' '));
   if (t.claim) extra.push(`claimed by ${t.claim} ${age(t.start)}`);
-  if (t.blocked) extra.push(`blocked by ${t.blockedBy.length}`);
+  // A person's answer leaves out a blocker in a repository they can't read, but keeps the block (BRK-338).
+  if (t.blocked) extra.push(`blocked by ${t.blockedBy.length || 'a task you can’t see'}`);
   if (t.waiting) extra.push(`waiting until ${t.wait.slice(0, 10)}`);
   if (t.status !== 'pending') extra.push(`${t.status}${t.end ? ` ${t.end.slice(0, 10)}` : ''}`);
   return `${bits.join('  ')}${extra.length ? `  (${extra.join('; ')})` : ''}`;
 }
 
+/** Who does a task (BRK-330), in words: an agent, a person (its assignee, or any member), or a decision. */
+function whoWords(t) {
+  if (t.who === 'person')
+    return `a person: ${!t.assignee ? 'any member' : t.assignee === 'owner' ? 'the owner' : t.assignee}`;
+  if (t.who === 'agent') return 'an agent';
+  if (t.who === 'decision') return 'a decision first';
+  return 'nobody yet';
+}
+
 function detail(t) {
   const said = ownerSaidLines(t);
   const out = [`${ref(t)} · ${t.description}`, '', ...(said.length ? [...said, ''] : [])];
@@ -881,6 +905,7 @@ function detail(t) {
   row('Project', t.project);
   row('Horizon', t.horizon);
   row('Priority', t.priority);
+  row('Who', whoWords(t));
   row('Tags', t.tags.map((x) => `+${x}`).join(' '));
   row('Claimed by', t.claim && `${t.claim} (${age(t.start)} ago)`);
   row('Spec', t.spec);
@@ -1038,6 +1063,8 @@ function changesFrom(o) {
   for (const key of ['description', 'project', 'priority', 'horizon', 'spec', 'pr', 'due', 'wait', 'status'])
     if (key in o) c[key] = o[key];
   if (c.priority) c.priority = c.priority.toUpperCase();
+  if (o.who !== undefined) c.who = String(o.who).toLowerCase();
+  if (o.assignee !== undefined) c.assignee = o.assignee === true ? null : String(o.assignee).toLowerCase() || null;
   if (o.tag) c.addTags = o.tag;
   if (o.untag) c.removeTags = o.untag;
   Object.assign(
@@ -1101,7 +1128,9 @@ const commands = {
         (!opts.blocked || t.blocked) &&
         (!opts.active || t.claim || t.active) &&
         (!opts.mine || t.claim === me) &&
-        (!opts.owner || t.tags.includes('owner') || t.tags.includes('decide')) &&
+        (!opts.owner || needsOwner(t)) &&
+        (!opts.who || t.who === String(opts.who).toLowerCase()) &&
+        (!opts.assignee || t.assignee === String(opts.assignee).toLowerCase()) &&
         (!opts.project || t.project === opts.project) &&
         // The archive is hidden from open work only: --status completed or all lists it too (CLD-193).
         (opts.horizon
@@ -1794,7 +1823,8 @@ const commands = {
     const body = { agent: agent(), claim: Boolean(opts.claim), project: opts.project, horizon: opts.horizon };
     const repo = await scopedRepo();
     if (repo) body.repo = repo;
-    if (opts.tag) body.tags = ['agent', ...opts.tag];
+    body.who = 'agent';
+    if (opts.tag) body.tags = opts.tag;
     const { task } = await call('POST', 'next', body);
     if (task && opts.claim) {
       markSession(task);
@@ -2051,7 +2081,7 @@ const commands = {
       const token = setting('TOKEN');
       for (const image of attachments) {
         const res = await fetch(`${BASE}/api/attachments/${image.id}`, {
-          headers: token ? { Authorization: `Bearer ${token}` } : {},
+          headers: authHeaders(token, setting('RUN_KEY')),
         });
         if (!res.ok) fail(`couldn't download ${image.name} (HTTP ${res.status})`);
         const ext = { 'image/png': 'png', 'image/jpeg': 'jpg', 'image/webp': 'webp', 'image/gif': 'gif' }[image.type];
@@ -2208,15 +2238,17 @@ const commands = {
       }
       // Claude Code says which server it's connecting: the plugin's board_url, when the CLI's settings don't name one.
       const server = process.env.CLAUDE_CODE_MCP_SERVER_URL?.replace(/\/mcp\/?$/u, '');
+      const runKey = setting('RUN_KEY') ?? null;
       const repo = await headersRepo({
         base: BASE ?? (server?.startsWith('http') ? server : null),
         token,
+        runKey,
         named: opts.repo ?? setting('REPO'),
         remote,
         fetch,
       });
       // Standard output is Claude Code's, and only the headers go there: never --json's wrapping, never a line of text.
-      console.log(JSON.stringify(mcpHeaders({ token, named, agent: name, repo })));
+      console.log(JSON.stringify(mcpHeaders({ token, runKey, named, agent: name, repo })));
       return;
     }
     const tokenVar = envName('TOKEN');
@@ -2228,6 +2260,7 @@ const commands = {
     const checked = await checkMcp({
       endpoint: config.endpoint,
       token: setting('TOKEN'),
+      runKey: setting('RUN_KEY') ?? null,
       agent: name,
       repo: slug,
       fetch,
@@ -2235,6 +2268,37 @@ const commands = {
     print(checked, (c) => c.lines.join('\n'));
     if (!checked.ok) process.exitCode = 1;
   },
+  /**
+   * A lent run's key (BRK-324), saved in tasks.env (0600, outside the checkout) because the hooks don't share the
+   * agent's shell: an exported variable never reaches them. --forget drops it.
+   */
+  async 'run-key'() {
+    const name = envName('RUN_KEY');
+    const env = readEnvFile();
+    if (opts.forget) {
+      if (!(name in env)) return print({ forgotten: false }, () => `There's no run key in ${ENV_FILE}.`);
+      const { [name]: _gone, ...rest } = env;
+      writePrivate(`${ENV_FILE}.next`, envFile(rest));
+      renameSync(`${ENV_FILE}.next`, ENV_FILE);
+      return print({ forgotten: true }, () => `Dropped the run key from ${ENV_FILE}.`);
+    }
+    const key = String(need(args[0], 'run key')).trim();
+    if (!RUN_KEY.test(key))
+      fail('that isn’t a run key: copy the whole Run key line’s value from your payload (bkr_…).');
+    writePrivate(`${ENV_FILE}.next`, envFile({ ...env, [name]: key }));
+    renameSync(`${ENV_FILE}.next`, ENV_FILE);
+    process.env[name] = key;
+    const session = await call('GET', 'session', undefined, { raw: true });
+    if (!session.ok) fail(`saved, but the board refused it: ${session.data?.error ?? `HTTP ${session.status}`}`);
+    print({ saved: true, person: session.data.person ?? null }, (d) =>
+      [
+        `Saved the run key in ${ENV_FILE}. This CLI, its hooks, and mcp --headers send it from now on.`,
+        d.person ? `The board knows it: you act for ${d.person.name ?? d.person.handle}, with their rights.` : '',
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    );
+  },
   async health() {
     const settings = settingSources();
     print({ ...(await call('GET', 'health')), settings }, (h) =>

package/src/decision.js

@@ -228,8 +228,11 @@ function show(q, answer) {
   return String(value);
 }
 
-/** The plain comment the board adds when a decision is submitted. Nothing reads it back. */
-export function summarize(questions, answers) {
+/**
+ * The plain comment the board adds when a decision is submitted. Nothing reads it back. `by` is who answered
+ * (BRK-303): the owner, or the maintainer who did, by handle.
+ */
+export function summarize(questions, answers, by = 'owner') {
   const parts = questions.map((q) => {
     const answer = answers[q.id];
     const body = answer
@@ -237,11 +240,11 @@ export function summarize(questions, answers) {
       : 'no answer';
     return `${clip(text(q.prompt).replace(/\s+/gu, ' '), 60)} = ${body}`;
   });
-  return `Decided by the owner: ${parts.join('; ')}`;
+  return `Decided by ${!by || by === 'owner' ? 'the owner' : by}: ${parts.join('; ')}`;
 }
 
 /** Tags that aren't a feature's (IDEA-28 section 1): the board's own, horizons, and release tags. */
-const NOT_FEATURES = new Set(['agent', 'owner', 'decide', 'idea', 'general', 'version']);
+const NOT_FEATURES = new Set(['idea', 'general', 'version']);
 export const featureTags = (tags) =>
   (tags ?? []).filter((t) => !NOT_FEATURES.has(t) && !t.startsWith('horizon-') && !/^v\d/u.test(t));
 
@@ -267,18 +270,21 @@ const MAX_BRIEF = 10000;
  * agent that brings the work waiting for an answered decision in line with its answers. `decision` is the decision's
  * task (its `ref` is its work ID or short ID), `waiting` the open tasks that depend on it, and `note` the owner's,
  * which goes under the board's prompt. Returns the task's title and description.
- * @param {{ ref: string, description: string, spec?: string | null, questions: any[], answers: Record<string, any> }} decision
+ * `by` is who answered (BRK-303): the owner, or a maintainer's handle.
+ * @param {{ ref: string, description: string, spec?: string | null, questions: any[], answers: Record<string, any>,
+ *   by?: string | null }} decision
  * @param {{ ref: string, description: string, tags?: string[], spec?: string | null }[]} waiting
  * @param {string | null} [note]
  */
 export function refinePrompt(decision, waiting, note = null) {
+  const who = !decision.by || decision.by === 'owner' ? 'the owner' : decision.by;
   const title = clip(`Refine from the answers to ${decision.ref}: ${decision.description}`, 200);
   const questions = decision.questions.flatMap((q, i) => {
     const answer = decision.answers[q.id];
     return [
       `${i + 1}. ${q.prompt.trim()}`,
       `   Answer: ${spell(q, answer)}`,
-      ...(answer?.comment ? [`   The owner's note: ${answer.comment.trim()}`] : []),
+      ...(answer?.comment ? [`   ${who === 'the owner' ? 'The owner' : who}'s note: ${answer.comment.trim()}`] : []),
     ];
   });
   const specs = [...new Set([decision.spec, ...waiting.map((t) => t.spec)].filter(Boolean))];
@@ -296,7 +302,7 @@ export function refinePrompt(decision, waiting, note = null) {
     '- If nothing in the repository needs to change, comment what you changed on the board, task by task, and release your task.',
     ...(note && String(note).trim() ? ['', 'Note from the owner:', String(note).trim().slice(0, 4000)] : []),
   ];
-  const intro = `The owner answered the decision on ${decision.ref} (${decision.description}). Bring the work waiting for it in line with the answers.`;
+  const intro = `${who === 'the owner' ? 'The owner' : who} answered the decision on ${decision.ref} (${decision.description}). Bring the work waiting for it in line with the answers.`;
   const rest = [
     '',
     `Waiting for ${decision.ref}`,

package/src/model.js

@@ -6,7 +6,8 @@
  * (`wid`, `horizon`, `spec`, `claim`, `pr`) as plain properties. The task structure (IDEA-5): `brief`
  (the current description), `brief_by`, `done_when`, `rel_<uuid>` plus a `related` list, and `by_<epoch>`
  beside `annotation_<epoch>` for a comment's author. The owner's words (BRK-284): `said_<epoch>` (the quote),
- `said_from_<epoch>` (where it came from), and `said_by_<epoch>` (who put it on the task).
+ `said_from_<epoch>` (where it came from), and `said_by_<epoch>` (who put it on the task). Who does it (BRK-330):
+ `who` (agent, person, or decision) and, on a person's task, `assignee` (a person's handle, or owner).
  */
 
 import { keepAnswers, validateQuestions } from './decision.js';
@@ -42,6 +43,78 @@ export const AREA_NAMES = {
 export const HORIZONS = ['now', 'next', 'later', 'archive'];
 export const PRIORITIES = ['H', 'M', 'L'];
 export const STATUSES = ['pending', 'completed', 'deleted'];
+/**
+ * Who does a task (BRK-330, docs/specs/BRK-299-people-and-roles.md, "Who does it"): an agent builds it, a person does
+ * it (its `assignee`, or any member of its repository when it has none), or the owner decides it first.
+ */
+export const WHO = ['agent', 'person', 'decision'];
+/** A person's handle (src/store-people.js), or `owner`: who a person's task is assigned to. */
+const ASSIGNEE = /^[a-z][a-z0-9-]{0,31}$/u;
+
+/**
+ * The tags `who` replaced (BRK-330), and what each one means now. A task carried them before the migration, and an
+ * older CLI copied into another repository, a Taskwarrior replica, or an older prompt still sends them: withChanges
+ * and legacyWho map them onto the field, so none is ever stored. Kept by BRK-331 because released CLIs still send
+ * them: up to 2.0.2-main.2 (the stable 2.0.1 among them); the first release after it sends --who. BRK-349 (waits until
+ * 10 Nov 2026) removes the mapping once every repository's copy is past them.
+ */
+export const LEGACY_WHO_TAGS = {
+  decide: { who: 'decision' },
+  agent: { who: 'agent' },
+  owner: { who: 'person', assignee: 'owner' },
+};
+/**
+ * When a task carried several of them, the one that wins, as the board read them: a decision held every start, and
+ * +agent let agents start a task whatever else it carried, so it beats +owner.
+ */
+const LEGACY_ORDER = ['decide', 'agent', 'owner'];
+export const isLegacyTag = (/** @type {string} */ tag) => Object.hasOwn(LEGACY_WHO_TAGS, tag);
+
+/**
+ * What the tags `who` replaced among `tags` mean (BRK-330): `{ who, assignee? }`, or null when there are none.
+ * @param {string[]} tags
+ * @returns {{ who: string, assignee?: string } | null}
+ */
+export function whoFromTags(tags) {
+  const tag = LEGACY_ORDER.find((t) => tags.includes(t));
+  return tag ? LEGACY_WHO_TAGS[tag] : null;
+}
+
+/**
+ * A task's map with its questions moved from `decision`, where they were kept before BRK-346, to `decision_questions`.
+ * Taskwarrior reads a word that names an attribute as that attribute's value, so while the questions' UDA was called
+ * `decision`, `task add … who:decision` stored no who. What the migration and a replica's version go through: a
+ * replica with an older shared taskrc may still send `decision`. A map without it comes back as it is (the same object).
+ * Kept until every repository's copied taskrc is past BRK-346; BRK-349 removes it.
+ * @param {Record<string, string>} map
+ */
+export function legacyQuestions(map) {
+  if (!('decision' in map)) return map;
+  const { decision, ...after } = map;
+  if (!after.decision_questions && decision) after.decision_questions = decision;
+  return after;
+}
+
+/**
+ * A task's map with the tags `who` replaced (BRK-330) turned into `who` and `assignee`: what the migration and a
+ * Taskwarrior replica's version go through. A map without them comes back as it is (the same object).
+ * @param {Record<string, string>} map
+ */
+export function legacyWho(map) {
+  const tags = tagsOf(map);
+  const mapped = whoFromTags(tags);
+  if (!mapped) return map;
+  const after = { ...map };
+  setTags(
+    after,
+    tags.filter((tag) => !isLegacyTag(tag)),
+  );
+  const { who, assignee } = mapped;
+  after.who = who;
+  if (assignee && !(map.who === 'person' && map.assignee)) after.assignee = assignee;
+  if (who !== 'person') delete after.assignee;
+  return after;
+}
 /** Properties the API may set directly (strings, or null to remove). */
 export const PLAIN = [
   'description',
@@ -181,6 +254,8 @@ export function view(uuid, map, all, now = new Date()) {
     priority: map.priority ?? '',
     horizon: map.horizon ?? null,
     tags: tagsOf(map),
+    who: map.who ?? null,
+    assignee: map.assignee ?? null,
     depends,
     blockedBy,
     blocked: blockedBy.length > 0,
@@ -193,7 +268,7 @@ export function view(uuid, map, all, now = new Date()) {
     autostart: map.autostart === 'yes',
     session: map.session ?? null,
     alert: map.alert ?? null,
-    decision: map.decision ? parseJson(map.decision, isList) : null,
+    decision: map.decision_questions ? parseJson(map.decision_questions, isList) : null,
     decisionAnswers: map.decision_answers ? parseJson(map.decision_answers, isRecord) : null,
     entry: iso(map.entry),
     modified: iso(map.modified),
@@ -300,7 +375,9 @@ function setRelated(map, rel) {
  *   status, due, wait, scheduled (date text or null), start: true|false, entry, end (epoch),
  *   brief, done_when (text or null), addTags, removeTags, addDepends, removeDepends, addRelated,
  *   removeRelated (arrays), annotate (text), by (who wrote the annotation or the brief),
- *   said ({ text, from, by }: the owner's words, quoted), unsay (a quote's id, to remove it)}
+ *   said ({ text, from, by }: the owner's words, quoted), unsay (a quote's id, to remove it),
+ *   who (agent, person, decision, or null), assignee (a handle, owner, or null: a person's task only)}
+ * A tag `who` replaced (LEGACY_WHO_TAGS) in addTags or removeTags changes `who` instead.
  */
 export function withChanges(before, changes, now = new Date()) {
   const map = { ...(before ?? {}) };
@@ -337,8 +414,10 @@ export function withChanges(before, changes, now = new Date()) {
   if ('entry' in changes && changes.entry) map.entry = String(changes.entry);
   if ('decision' in changes) {
     if (changes.decision === null || changes.decision === '') {
-      delete map.decision;
+      delete map.decision_questions;
       delete map.decision_answers;
+      // Questions an older replica still keeps under `decision` (BRK-346) go too, or legacyQuestions brings them back.
+      delete map.decision;
     } else {
       let input = changes.decision;
       if (typeof input === 'string') {
@@ -349,13 +428,12 @@ export function withChanges(before, changes, now = new Date()) {
         }
       }
       const questions = validateQuestions(input);
-      map.decision = JSON.stringify(questions);
+      map.decision_questions = JSON.stringify(questions);
       const old = map.decision_answers ? parseJson(map.decision_answers, isRecord) : null;
       if (old) {
         const { answers } = keepAnswers(questions, old.answers);
         map.decision_answers = JSON.stringify({ ...old, answers });
       }
-      setTags(map, [...new Set([...tagsOf(map), 'decide'])]);
     }
   }
   if ('decisionAnswers' in changes) {
@@ -367,7 +445,32 @@ export function withChanges(before, changes, now = new Date()) {
     for (const tag of changes.addTags ?? []) tags.add(checkTag(tag));
     for (const tag of changes.removeTags ?? []) tags.delete(tag);
     setTags(map, [...tags]);
+    // An older CLI's +agent, +owner, or +decide (BRK-330): removing the one that names who does it clears it.
+    for (const tag of changes.removeTags ?? [])
+      if (isLegacyTag(tag) && map.who === LEGACY_WHO_TAGS[tag].who) {
+        delete map.who;
+        delete map.assignee;
+      }
+  }
+  const mapped = legacyQuestions(legacyWho(map));
+  if (mapped !== map) {
+    for (const key of Object.keys(map)) if (!(key in mapped)) delete map[key];
+    Object.assign(map, mapped);
+  }
+  // Questions make it a decision, whatever else the same change says about who does it (an older CLI's --tag owner too).
+  const asking = Boolean(changes.decision);
+  if (asking) map.who = 'decision';
+  for (const key of ['who', 'assignee']) {
+    if (asking || !(key in changes) || changes[key] === undefined) continue;
+    const value = changes[key];
+    if (value === null || value === '') delete map[key];
+    else map[key] = String(value).trim().toLowerCase();
   }
+  if (map.who && !WHO.includes(map.who)) throw new InputError('who is agent, person, or decision');
+  if ((asking || 'who' in changes) && map.who !== 'person' && (asking || !changes.assignee)) delete map.assignee;
+  if (map.assignee && !ASSIGNEE.test(map.assignee)) throw new InputError("an assignee is a person's handle, or owner");
+  if (map.assignee && map.who !== 'person')
+    throw new InputError("only a person's task has an assignee: set who to person too");
   if (changes.addDepends || changes.removeDepends) {
     const deps = new Set(dependsOf(map));
     for (const dep of changes.addDepends ?? []) deps.add(dep);

package/src/ping.js

@@ -3,7 +3,7 @@
  * before anything is stored. Pure functions over the board's tasks, so the rules are tested without
  * a Durable Object. The same checks run again when the owner applies a proposal (CLD-112).
  */
-import { InputError, MAX_TEXT, PROJECTS, dependsOf } from './model.js';
+import { InputError, MAX_TEXT, PROJECTS, WHO, dependsOf, isLegacyTag, whoFromTags } from './model.js';
 
 export const PING_KINDS = ['blocked', 'question', 'stale', 'done', 'fyi'];
 /** The kinds that send a push; `fyi` only shows in the inbox. */
@@ -29,6 +29,7 @@ export const PINGS_PER_AGENT_PER_DAY = 50;
 const REF = /^[a-z][a-z0-9_-]{0,19}$/u;
 const WID = /^[A-Z]+-\d+$/u;
 const TAG = /^[a-z][\w-]{0,39}$/u;
+const ASSIGNEE = /^[a-z][a-z0-9-]{0,31}$/u;
 const MAX_TITLE = 200;
 const MAX_NOTE = 1000;
 const NEW_HORIZONS = ['now', 'next', 'later'];
@@ -111,6 +112,14 @@ const checkTags = (tags, where) => {
   }
   return tags;
 };
+/** A proposed assignee (BRK-330): a handle or owner, on a person's task only. The store checks their role on apply. */
+const assigneeOf = (value, who, where) => {
+  if (value === undefined || value === null || value === '') return null;
+  if (typeof value !== 'string' || !ASSIGNEE.test(value))
+    throw new InputError(`${where}: assignee is a person's handle, or owner`);
+  if (who !== 'person') throw new InputError(`${where}: only a person's task has an assignee: set who to person too`);
+  return value;
+};
 
 /**
  * Checks a proposal against the board as it is now. `ctx`:
@@ -206,7 +215,20 @@ export function validateProposal(raw, ctx) {
     if (change.type === 'add') {
       only(
         change,
-        ['type', 'ref', 'title', 'project', 'horizon', 'tags', 'brief', 'done_when', 'depends', 'priority'],
+        [
+          'type',
+          'ref',
+          'title',
+          'project',
+          'horizon',
+          'who',
+          'assignee',
+          'tags',
+          'brief',
+          'done_when',
+          'depends',
+          'priority',
+        ],
         where,
       );
       const title = text(change.title, 'title', MAX_TITLE, where, true);
@@ -217,9 +239,18 @@ export function validateProposal(raw, ctx) {
         throw new InputError(`${where}: horizon is one of ${NEW_HORIZONS.join(', ')}`);
       if (change.priority !== undefined && !PRIORITIES.includes(change.priority))
         throw new InputError(`${where}: priority is H, M, or L`);
-      const tags = checkTags(strings(change.tags, 'tags'), where);
-      if (!tags.some((t) => ['agent', 'owner', 'decide'].includes(t)))
-        throw new InputError(`${where}: tags need agent, owner, or decide, so the board knows who does it`);
+      const given = checkTags(strings(change.tags, 'tags'), where);
+      // An older proposal says who does it with a tag (BRK-330): it still means who.
+      const mapped = whoFromTags(given);
+      const tags = given.filter((t) => !isLegacyTag(t));
+      const who = change.who === undefined ? mapped?.who : change.who;
+      if (!WHO.includes(who))
+        throw new InputError(`${where}: who is agent, person, or decision, so the board knows who does it`);
+      const assignee = assigneeOf(
+        change.assignee === undefined && who === 'person' ? mapped?.assignee : change.assignee,
+        who,
+        where,
+      );
       const brief = text(change.brief, 'brief', MAX_TEXT, where, true);
       const doneWhen = text(change.done_when, 'done_when', MAX_TEXT, where, true);
       const depends = [];
@@ -235,6 +266,8 @@ export function validateProposal(raw, ctx) {
         title,
         project: change.project,
         horizon: change.horizon,
+        who,
+        ...(assignee ? { assignee } : {}),
         tags,
         brief,
         done_when: doneWhen,
@@ -272,7 +305,11 @@ export function validateProposal(raw, ctx) {
       }
       changes.push({ type: 'depend', task: from.token, add: added, remove: removed });
     } else if (change.type === 'modify') {
-      only(change, ['type', 'task', 'horizon', 'addTags', 'removeTags', 'brief', 'done_when'], where);
+      only(
+        change,
+        ['type', 'task', 'horizon', 'who', 'assignee', 'addTags', 'removeTags', 'brief', 'done_when'],
+        where,
+      );
       const uuid = existing(change.task, where, { open: true });
       if (ctx.tasks.get(uuid).claim === ctx.by)
         throw new InputError(
@@ -284,6 +321,12 @@ export function validateProposal(raw, ctx) {
           throw new InputError(`${where}: horizon is one of ${NEW_HORIZONS.join(', ')}`);
         out.horizon = change.horizon;
       }
+      if (change.who !== undefined) {
+        if (!WHO.includes(change.who)) throw new InputError(`${where}: who is agent, person, or decision`);
+        out.who = change.who;
+      }
+      const assignee = assigneeOf(change.assignee, change.who ?? ctx.tasks.get(uuid).who, where);
+      if (assignee) out.assignee = assignee;
       const addTags = checkTags(strings(change.addTags, 'addTags'), where);
       const removeTags = checkTags(strings(change.removeTags, 'removeTags'), where);
       if (addTags.length) out.addTags = addTags;
@@ -293,7 +336,9 @@ export function validateProposal(raw, ctx) {
       if (brief) out.brief = brief;
       if (doneWhen) out.done_when = doneWhen;
       if (Object.keys(out).length === 2)
-        throw new InputError(`${where}: say what changes (horizon, addTags, removeTags, brief, or done_when)`);
+        throw new InputError(
+          `${where}: say what changes (horizon, who, assignee, addTags, removeTags, brief, or done_when)`,
+        );
       changes.push(out);
     } else if (change.type === 'done') {
       only(change, ['type', 'task', 'note'], where);

package/src/redact.js

@@ -20,6 +20,9 @@ const PATTERNS = [
   // A runbook run's act key (BRK-252), on its own or on its payload's line.
   [/(\bAct key:\s*)\S+/gu, '$1[redacted]'],
   [/\bact_[0-9a-f]{64}\b/gu, '[redacted]'],
+  // A lent run's run key (BRK-324), the same way.
+  [/(\bRun key:\s*)\S+/gu, '$1[redacted]'],
+  [/bkr_[0-9a-f]{64}/gu, '[redacted]'],
   // Bearer tokens in headers.
   [/(\bBearer\s+)[\w.~+/=-]{16,}/giu, '$1[redacted]'],
   // Long base64 blobs with mixed case and digits (keys, secrets); hex SHAs and UUIDs don't match.