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

package/src/init.js

@@ -21,10 +21,15 @@ export { routinePrompt };
  */
 export const CLI_PACKAGE = 'breakaway@2';
 /**
- * Where the CLI starts: the command, and the two session hooks. repos init no longer copies them (BRK-7): an old copy
- * is replaced by npx, and these still version the CLI and say which files an old copy holds.
+ * Where the CLI starts: the command, and the session hooks (the edit hook since IDEA-55). repos init no longer copies
+ * them (BRK-7): an old copy is replaced by npx, and these still version the CLI and say which files an old copy holds.
  */
-export const CLI_ENTRIES = ['scripts/tasks.mjs', 'scripts/tasks/session-hook.mjs', 'scripts/tasks/message-wait.mjs'];
+export const CLI_ENTRIES = [
+  'scripts/tasks.mjs',
+  'scripts/tasks/session-hook.mjs',
+  'scripts/tasks/message-wait.mjs',
+  'scripts/tasks/edit-hook.mjs',
+];
 /**
  * While breakaway was private, nothing reached npm (BRK-57), so repos init copied the two hooks and what they import
  * under HOOKS_DIR and settings.json ran them from there (BRK-64). breakaway is public and on npm now, so the hooks run
@@ -32,7 +37,24 @@ export const CLI_ENTRIES = ['scripts/tasks.mjs', 'scripts/tasks/session-hook.mjs
  */
 export const HOOKS_FROM_COPY = false;
 /** The session hooks' entry files, and where their copy goes: its own folder, so it never touches the repository's src/. */
-export const HOOK_ENTRIES = ['scripts/tasks/session-hook.mjs', 'scripts/tasks/message-wait.mjs'];
+export const HOOK_ENTRIES = [
+  'scripts/tasks/session-hook.mjs',
+  'scripts/tasks/message-wait.mjs',
+  'scripts/tasks/edit-hook.mjs',
+];
+/** Each session hook's name (`npx breakaway hook <name>`) → its entry file. */
+const HOOK_FILES = { session: 'session-hook', wait: 'message-wait', edit: 'edit-hook' };
+/**
+ * The edit tools the edit hook runs on (IDEA-55 section 1a), as a PreToolUse matcher: exact tool names split by `|`
+ * (source: the matcher table in Claude Code's hooks reference, https://code.claude.com/docs/en/hooks).
+ */
+export const EDIT_MATCHER = 'Edit|Write|MultiEdit|NotebookEdit';
+/**
+ * The edit hook's `timeout`, in seconds: the field is in seconds and a command hook's defaults to 600, and a PreToolUse
+ * command hook that times out doesn't block the tool call (source: https://code.claude.com/docs/en/hooks, the hook
+ * handler fields and PreToolUse). Room for npx to start the CLI and for the hook's own wait on the board (3 s).
+ */
+export const EDIT_HOOK_TIMEOUT = 15;
 export const HOOKS_DIR = 'tools/tasks/cli/';
 /**
  * The release helpers a repository's Deploy, Promote, Roll back, and Release workflows run (BRK-45), copied with what
@@ -84,7 +106,7 @@ export function pluginSettings() {
 
 /** Whether a hook command is one of the session hooks repos init wrote: through npx, any version, or an old copy's. */
 const BOARD_HOOK =
-  /\bbreakaway(?:@[^\s"]+)? hook (?:session|wait)\b|scripts\/tasks\/(?:session-hook|message-wait)\.mjs/u;
+  /\bbreakaway(?:@[^\s"]+)? hook (?:session|wait|edit)\b|scripts\/tasks\/(?:session-hook|message-wait|edit-hook)\.mjs/u;
 
 /**
  * settings.json moved to the plugin (repos init --update): the session hooks repos init wrote are gone, with any event
@@ -229,11 +251,18 @@ export function cliCopySources(read) {
 /** The command a session hook runs: from the copy under HOOKS_DIR while breakaway is private, else through npx (BRK-7). */
 export function hookCommand(name, { fromCopy = HOOKS_FROM_COPY, pkg = CLI_PACKAGE } = {}) {
   if (!fromCopy) return `npx --yes ${pkg} hook ${name}`;
-  const entry = HOOK_ENTRIES.find((path) => path.includes(name === 'wait' ? 'message-wait' : 'session-hook'));
+  const file = HOOK_FILES[/** @type {keyof typeof HOOK_FILES} */ (name)] ?? HOOK_FILES.session;
+  const entry = HOOK_ENTRIES.find((path) => path.endsWith(`/${file}.mjs`));
   return `node "$CLAUDE_PROJECT_DIR/${HOOKS_DIR}${entry}"`;
 }
 
-/** The session hooks .claude/settings.json runs (see HOOKS_FROM_COPY). */
+/**
+ * The session hooks .claude/settings.json runs (see HOOKS_FROM_COPY). All run in the background but the edit hook
+ * (IDEA-55 section 1a), which claims the file an edit names before the edit runs: a hook with `async: true` runs in
+ * the background without blocking, so it couldn't turn an edit away (source: https://code.claude.com/docs/en/hooks,
+ * the `async` field). It has a short `timeout` instead (EDIT_HOOK_TIMEOUT), and a board that doesn't answer lets the
+ * edit through.
+ */
 export function sessionHooks(pkg = CLI_PACKAGE) {
   const hook = (name, extra = {}) => ({
     type: 'command',
@@ -242,9 +271,11 @@ export function sessionHooks(pkg = CLI_PACKAGE) {
     ...extra,
   });
   const session = [{ hooks: [hook('session')] }];
+  const edit = { type: 'command', command: hookCommand('edit', { pkg }), timeout: EDIT_HOOK_TIMEOUT };
   return {
     SessionStart: session,
     UserPromptSubmit: session,
+    PreToolUse: [{ matcher: EDIT_MATCHER, hooks: [edit] }],
     PostToolUse: session,
     Stop: [{ hooks: [hook('session'), hook('wait', { asyncRewake: true, timeout: 300 })] }],
   };
@@ -256,7 +287,7 @@ export function sessionHooks(pkg = CLI_PACKAGE) {
  */
 export function rewireHooks(text) {
   let out = text;
-  for (const name of ['session', 'wait'])
+  for (const name of ['session', 'wait', 'edit'])
     for (const fromCopy of [true, false]) {
       const was = JSON.stringify(hookCommand(name, { fromCopy })).slice(1, -1);
       const now = JSON.stringify(hookCommand(name)).slice(1, -1);
@@ -265,7 +296,7 @@ export function rewireHooks(text) {
   const current = (_, name) => JSON.stringify(hookCommand(name === 'message-wait' ? 'wait' : name)).slice(1, -1);
   return (
     out
-      .replace(/npx --yes breakaway(?:@[^\s"\\]+)? hook (session|wait)\b/gu, current)
+      .replace(/npx --yes breakaway(?:@[^\s"\\]+)? hook (session|wait|edit)\b/gu, current)
       // The old CLI copy's hook scripts, from before BRK-7, quoted or not (BRK-79): its copy is about to go.
       .replace(
         /node (\\")?(?:\$CLAUDE_PROJECT_DIR\/)?(?:tools\/tasks\/cli\/)?scripts\/tasks\/(session-hook|message-wait)\.mjs\1/gu,
@@ -592,6 +623,11 @@ export function initPlan({
       notes.push(
         `.claude/settings.json is already there: set its session hooks to \`${hookCommand('session')}\` (and \`${hookCommand('wait')}\` on Stop), or a started agent's output won't show on its task.${HOOKS_FROM_COPY ? '' : ' Hooks that run scripts/tasks/session-hook.mjs stop working once the old copy is removed.'}`,
       );
+    // Settings from before the edit hook (IDEA-55): agents there don't claim the files they edit until it's added.
+    if (!rewired.includes(hookCommand('edit')))
+      notes.push(
+        `.claude/settings.json has no edit hook: add ${JSON.stringify({ PreToolUse: sessionHooks().PreToolUse })} to its hooks, so agents claim each file before they edit it.`,
+      );
   }
   if (readTarget('.claude/skills') === null) files.push({ path: '.claude/skills', link: '../.agents/skills' });
   if (!usePlugin) copy(SKILL, skillFor(read(SKILL), board, repo));

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.

package/taskrc

@@ -47,29 +47,40 @@ uda.done_when.label=Done when
 
 # A decision for the owner (docs/specs/IDEA-6-decisions-with-questions.md): the questions, and the
 # owner's answers once submitted, both JSON. Attach and answer them through the board, not by hand.
-uda.decision.type=string
-uda.decision.label=Decision
+# The questions were `decision` before BRK-346: Taskwarrior reads a word that names an attribute as
+# that attribute's value, so who:decision stored nothing. The board moves an old `decision` forward.
+uda.decision_questions.type=string
+uda.decision_questions.label=Decision
 uda.decision_answers.type=string
 uda.decision_answers.label=Answers
 
+# Who does it (BRK-330): an agent builds it, a person does it, or the owner decides first. A person's task
+# names who it's for in `assignee` (a person's handle, or owner); without one, any member of its repository
+# does it. Set them with who:agent, who:decision, who:person assignee:owner, and so on.
+uda.who.type=string
+uda.who.label=Who
+uda.who.values=agent,person,decision,
+uda.assignee.type=string
+uda.assignee.label=Assignee
+
 # Order work like the board: horizon first, then priority. Waiting on a decision sinks.
 urgency.uda.horizon.now.coefficient=8.0
 urgency.uda.horizon.next.coefficient=2.0
 urgency.uda.horizon.later.coefficient=-4.0
 urgency.uda.horizon.archive.coefficient=-8.0
-urgency.user.tag.decide.coefficient=-3.0
+urgency.uda.who.decision.coefficient=-3.0
 
 # Reports: `task board`, `task agent`, `task claimed`, `task owner`.
 report.board.description=Open work, best first
-report.board.columns=id,wid,priority,horizon,project,tags,claim,depends.indicator,description.count
-report.board.labels=ID,Work,P,Horizon,Area,Tags,Claimed by,D,Description
+report.board.columns=id,wid,priority,horizon,project,who,tags,claim,depends.indicator,description.count
+report.board.labels=ID,Work,P,Horizon,Area,Who,Tags,Claimed by,D,Description
 report.board.filter=status:pending -WAITING
 report.board.sort=urgency-
 
 report.agent.description=Ready for an agent: unblocked, unclaimed, not waiting on a decision
 report.agent.columns=id,wid,priority,horizon,project,tags,description.count
 report.agent.labels=ID,Work,P,Horizon,Area,Tags,Description
-report.agent.filter=status:pending +READY +agent -decide claim:
+report.agent.filter=status:pending +READY who:agent claim:
 report.agent.sort=urgency-
 
 report.claimed.description=In progress, oldest claim first
@@ -78,10 +89,10 @@ report.claimed.labels=ID,Work,Claimed by,For,Area,Description
 report.claimed.filter=status:pending claim.any:
 report.claimed.sort=start+
 
-report.owner.description=Needs the owner: owner work and open decisions
-report.owner.columns=id,wid,priority,horizon,project,tags,description.count
-report.owner.labels=ID,Work,P,Horizon,Area,Tags,Description
-report.owner.filter=status:pending (+owner or +decide)
+report.owner.description=Needs the owner: the owner's work, work for anyone, and open decisions
+report.owner.columns=id,wid,priority,horizon,project,who,assignee,tags,description.count
+report.owner.labels=ID,Work,P,Horizon,Area,Who,For,Tags,Description
+report.owner.filter=status:pending ( who:decision or ( who:person and ( assignee:owner or assignee.none: ) ) )
 report.owner.sort=urgency-
 
 # Repositories (IDEA-14): one report and one context each, for every repository the board tracks. This file