@poetic-ai/poetic 1.42.0

package/integrations/bb-plugin-poetic/src/task-authoring-view.ts

@@ -0,0 +1,1227 @@
+/**
+ * Pure BB presentation for custom task authoring and task relationships.
+ *
+ * This module is presentation only. It labels the BPAU-02 authoring vocabulary,
+ * gates a draft before it may be submitted, builds exactly one typed BPAU-02
+ * request from a confirmed draft, and renders the outcome BPAU-02 returned. It
+ * holds the same authority boundary as the rest of this plugin:
+ *
+ *   - Poetic is the only mutation and sync authority. Nothing here spawns a
+ *     process, reads a file, resolves a path, or calls an RPC method.
+ *   - Custom task creation is labelled as its own product. It is never rendered
+ *     as adding an existing backlog item to a sprint, and never as a lifecycle
+ *     transition: no control here can emit `start`, `block`, `unblock`,
+ *     `review`, `complete`, `cancel`, or `reopen`, and the shipped lifecycle
+ *     panel is untouched.
+ *   - Relationship mutations name both endpoints explicitly. A missing,
+ *     malformed, self-referential, or not-currently-shown endpoint is refused
+ *     rather than guessed.
+ *   - A Description replacement is offered only when BB prepopulated the current
+ *     canonical Description, and the replacement scope is always disclosed.
+ *   - One confirmed draft emits one request and then waits. While a submission is
+ *     unresolved every control is refused, and no resulting identity, status,
+ *     membership, capacity, or push success is predicted: the outcome view
+ *     reports Poetic's own effect phase, its fresh rereads, and its sync
+ *     evidence, never the exit code.
+ *
+ * Nothing from the shared adapter, model, contract, server, app, or route
+ * modules is imported here.
+ */
+
+import {
+  TASK_AUTHORING_CONSENT_LABELS,
+  TASK_AUTHORING_CREATE_DISTINCTION_NOTICE,
+  TASK_AUTHORING_DESCRIPTION_REPLACEMENT_NOTICE,
+  TASK_AUTHORING_EFFECTS,
+  TASK_AUTHORING_LABELS,
+  type TaskAuthoringConsentState,
+  type TaskAuthoringPrepopulation,
+  taskAuthoringArgv,
+  taskAuthoringConsentPayload,
+  taskAuthoringDeclaredIdentities,
+  taskAuthoringDeniedInputKeys,
+  taskAuthoringDescriptionPrepopulation,
+  taskAuthoringRequiredConsentKeys,
+} from './task-authoring-model.js';
+import {
+  type ApplyTaskAuthoringInput,
+  type ApplyTaskAuthoringOutput,
+  applyTaskAuthoringInputSchema,
+  TASK_AUTHORING_DISCLOSURE,
+  TASK_AUTHORING_VOCABULARY,
+  type TaskAuthoringAction,
+  type TaskAuthoringCommandEvidence,
+  type TaskAuthoringEffect,
+  type TaskAuthoringRefusal,
+  type TaskAuthoringRefusalReason,
+  type TaskAuthoringSync,
+  taskAuthoringIdentitySchema,
+} from './task-authoring-schema.js';
+
+/** Version of the presentation this module publishes. */
+export const TASK_AUTHORING_VIEW_VERSION = '1.0.0' as const;
+
+/**
+ * Domain every control here carries. It is deliberately not the lifecycle
+ * panel's `task-lifecycle` domain, so an authoring control can never be rendered
+ * in the lifecycle group or read as a status transition.
+ */
+export const TASK_AUTHORING_DOMAIN = 'task-authoring' as const;
+
+/** Concise action-first labels for buttons; detailed effects stay adjacent. */
+export const TASK_AUTHORING_BUTTON_LABELS: Readonly<Record<TaskAuthoringAction, string>> = {
+  createCustomTask: 'Create Custom Task',
+  updateCustomTask: 'Save Task Details',
+  addTaskDependency: 'Add Dependency',
+  removeTaskDependency: 'Remove Dependency',
+  linkTaskToBacklog: 'Link Backlog Item',
+};
+
+export const TASK_AUTHORING_LIFECYCLE_SEPARATION_NOTICE =
+  'These are authoring controls. None of them starts, blocks, unblocks, reviews, completes, cancels, reopens, or archives a task; task status stays with the separate task lifecycle controls, which this panel does not change.';
+
+export const TASK_AUTHORING_ADD_FROM_BACKLOG_SEPARATION_NOTICE =
+  'Creating a custom task is not "add from backlog". Scheduling an existing backlog item into a sprint is a separate control with its own Poetic command; this panel never schedules a backlog item.';
+
+export const TASK_AUTHORING_CONCURRENCY_NOTICE =
+  'This panel submits one authoring action at a time and waits for Poetic to answer. Another BB panel or another process can still submit concurrently; Poetic-side admission, not this panel, is the authority for that.';
+
+export const TASK_AUTHORING_AWAITING_REREAD_NOTICE =
+  "Poetic is running this command once. BB is waiting for Poetic's own outcome and its fresh canonical reread, and has predicted no task id, status, membership, capacity, or push result.";
+
+export const TASK_AUTHORING_REREAD_NOTICE =
+  "Everything below is Poetic's own outcome and its fresh reread. BB derived no identity, status, membership, or capacity of its own, and a zero exit never confirmed the managed sync reached the remote.";
+
+/** Kinds of relationship endpoint this panel can address. */
+export type TaskAuthoringEndpointKind = 'task' | 'sprint' | 'backlog-item';
+
+/**
+ * One authoring draft exactly as the operator left it. Every field is raw form
+ * text so nothing is coerced before it is validated, and the discriminant is
+ * `kind` rather than `action` so a draft object can never carry a key from the
+ * refused input surface.
+ */
+export type TaskAuthoringDraft =
+  | {
+      kind: 'createCustomTask';
+      sprintId: string;
+      title: string;
+      /** Required plain decimal hours; never defaulted from a CLI value. */
+      estimate: string;
+      expectedRuntimeMinutes: string;
+      description: string;
+      /** `P0`-`P3`, or empty to send none. */
+      priority: string;
+      dependsOn: readonly string[];
+      backlogItemId: string;
+    }
+  | {
+      kind: 'updateCustomTask';
+      taskId: string;
+      title: string;
+      /** Prepopulated from the canonical Description; empty sends none. */
+      description: string;
+      priority: string;
+      estimate: string;
+      expectedRuntimeMinutes: string;
+    }
+  | { kind: 'addTaskDependency'; taskId: string; onTaskId: string }
+  | { kind: 'removeTaskDependency'; taskId: string; removeTaskId: string }
+  | { kind: 'linkTaskToBacklog'; taskId: string; backlogItemId: string };
+
+/** An empty draft per action, so a panel never starts from a partial shape. */
+export function emptyTaskAuthoringDraft(action: TaskAuthoringAction): TaskAuthoringDraft {
+  switch (action) {
+    case 'createCustomTask':
+      return {
+        kind: 'createCustomTask',
+        sprintId: '',
+        title: '',
+        estimate: '',
+        expectedRuntimeMinutes: '',
+        description: '',
+        priority: '',
+        dependsOn: [],
+        backlogItemId: '',
+      };
+    case 'updateCustomTask':
+      return {
+        kind: 'updateCustomTask',
+        taskId: '',
+        title: '',
+        description: '',
+        priority: '',
+        estimate: '',
+        expectedRuntimeMinutes: '',
+      };
+    case 'addTaskDependency':
+      return { kind: 'addTaskDependency', taskId: '', onTaskId: '' };
+    case 'removeTaskDependency':
+      return { kind: 'removeTaskDependency', taskId: '', removeTaskId: '' };
+    case 'linkTaskToBacklog':
+      return { kind: 'linkTaskToBacklog', taskId: '', backlogItemId: '' };
+  }
+}
+
+/** The action one draft addresses. */
+export function taskAuthoringDraftAction(draft: TaskAuthoringDraft): TaskAuthoringAction {
+  return draft.kind;
+}
+
+/** True when this draft asks to replace the task's Description section. */
+export function taskAuthoringDraftReplacesDescription(draft: TaskAuthoringDraft): boolean {
+  return draft.kind === 'updateCustomTask' && draft.description.trim().length > 0;
+}
+
+/** The canonical read state BB holds for the task a draft addresses. */
+export type TaskAuthoringDetailState = 'available' | 'missing' | 'unavailable' | 'none';
+
+/** One unresolved submission this panel owns. */
+export interface TaskAuthoringSubmissionState {
+  action: TaskAuthoringAction;
+  /** Task id for an edit or relationship, sprint id for a creation. */
+  identity: string;
+}
+
+/** Why a draft may not be submitted, in BPAU-02's own refusal vocabulary. */
+export interface TaskAuthoringViewRefusal {
+  reason: TaskAuthoringRefusalReason;
+  message: string;
+}
+
+export interface TaskAuthoringGateInput {
+  draft: TaskAuthoringDraft;
+  consent: TaskAuthoringConsentState;
+  /** BB's canonical read state for the addressed task; `none` for a creation. */
+  detailState: TaskAuthoringDetailState;
+  /** Task id BB currently holds canonical detail for, or null when it holds none. */
+  canonicalTaskId: string | null;
+  /** Task `updated` timestamp BB built this draft from, or null. */
+  observedTaskUpdatedAt: string | null;
+  /** Task `updated` timestamp of BB's latest canonical read, or null. */
+  canonicalTaskUpdatedAt: string | null;
+  /**
+   * Canonical Description prepopulation for this task, or null when the panel
+   * holds none. Required before a Description replacement may be submitted.
+   */
+  descriptionPrepopulation: TaskAuthoringPrepopulation | null;
+  /** Unresolved submission this panel already owns, or null. */
+  inFlight: TaskAuthoringSubmissionState | null;
+}
+
+type IdentityCheck = { state: 'valid'; value: string } | { state: 'empty' } | { state: 'invalid' };
+
+/** Validate one entered identity without repairing, completing, or guessing it. */
+function checkIdentity(raw: string): IdentityCheck {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return { state: 'empty' };
+  return taskAuthoringIdentitySchema.safeParse(trimmed).success
+    ? { state: 'valid', value: trimmed }
+    : { state: 'invalid' };
+}
+
+const ENDPOINT_NOUNS: Readonly<Record<TaskAuthoringEndpointKind, string>> = {
+  task: 'task',
+  sprint: 'sprint',
+  'backlog-item': 'backlog item',
+};
+
+/**
+ * Refuse an endpoint that is not exactly one named managed identity. An
+ * ambiguous endpoint is never resolved by BB: it is reported, and nothing is
+ * submitted.
+ */
+function endpointRefusal(
+  kind: TaskAuthoringEndpointKind,
+  role: string,
+  raw: string
+): TaskAuthoringViewRefusal | null {
+  const check = checkIdentity(raw);
+  if (check.state === 'empty') {
+    return {
+      reason: 'missing-identity',
+      message: `No ${role} ${ENDPOINT_NOUNS[kind]} is named, so BB will not submit an ambiguous ${ENDPOINT_NOUNS[kind]} endpoint.`,
+    };
+  }
+  if (check.state === 'invalid') {
+    return {
+      reason: 'invalid-request',
+      message: `The ${role} ${ENDPOINT_NOUNS[kind]} "${raw.trim()}" is not a single managed planning id, so BB will not submit it as an endpoint.`,
+    };
+  }
+  return null;
+}
+
+type NumberField =
+  | { state: 'absent' }
+  | { state: 'value'; value: number }
+  | { state: 'invalid'; raw: string };
+
+/**
+ * Read one numeric form field. Only a plain decimal token is accepted, mirroring
+ * the wire schema, so an exponent, a sign, a separator, or a non-finite form is
+ * refused rather than coerced into a value the operator never typed.
+ */
+function readNumberField(raw: string): NumberField {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return { state: 'absent' };
+  if (!/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) return { state: 'invalid', raw: trimmed };
+  const value = Number(trimmed);
+  if (!Number.isFinite(value) || value <= 0) return { state: 'invalid', raw: trimmed };
+  return { state: 'value', value };
+}
+
+const PRIORITIES = ['P0', 'P1', 'P2', 'P3'] as const;
+
+type PriorityField =
+  | { state: 'absent' }
+  | { state: 'value'; value: (typeof PRIORITIES)[number] }
+  | { state: 'invalid'; raw: string };
+
+function readPriorityField(raw: string): PriorityField {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return { state: 'absent' };
+  const match = PRIORITIES.find((priority) => priority === trimmed);
+  if (match === undefined) return { state: 'invalid', raw: trimmed };
+  return { state: 'value', value: match };
+}
+
+function invalidNumberRefusal(field: string, raw: string): TaskAuthoringViewRefusal {
+  return {
+    reason: 'invalid-request',
+    message: `"${raw}" is not a plain positive number for ${field}, so BB will not submit it.`,
+  };
+}
+
+/** Refuse a draft whose addressed task is not one BB can currently read. */
+function detailRefusal(
+  taskId: string,
+  input: TaskAuthoringGateInput
+): TaskAuthoringViewRefusal | null {
+  switch (input.detailState) {
+    case 'missing':
+      return {
+        reason: 'missing-identity',
+        message: `Poetic reports no managed task ${taskId}, so no authoring action is submitted for it.`,
+      };
+    case 'unavailable':
+      return {
+        reason: 'task-unavailable',
+        message: `Poetic could not describe task ${taskId}, so no authoring action is submitted for it.`,
+      };
+    case 'none':
+      return {
+        reason: 'task-unavailable',
+        message: `BB holds no canonical detail for task ${taskId}, so no authoring action is submitted for it.`,
+      };
+    default:
+      break;
+  }
+  if (input.canonicalTaskId !== null && input.canonicalTaskId !== taskId) {
+    return {
+      reason: 'expected-identity-mismatch',
+      message: `BB holds canonical detail for task ${input.canonicalTaskId} but this draft addresses ${taskId}, so the endpoint is ambiguous and nothing is submitted.`,
+    };
+  }
+  if (
+    input.observedTaskUpdatedAt !== null &&
+    input.canonicalTaskUpdatedAt !== null &&
+    input.observedTaskUpdatedAt !== input.canonicalTaskUpdatedAt
+  ) {
+    return {
+      reason: 'changed-identity',
+      message: `Task ${taskId} changed in Poetic after this draft was prepared (BB read ${input.observedTaskUpdatedAt}, Poetic now reports ${input.canonicalTaskUpdatedAt}). Reload the task before submitting.`,
+    };
+  }
+  return null;
+}
+
+/** Identity checks for one draft, before any field is parsed. */
+function identityRefusal(draft: TaskAuthoringDraft): TaskAuthoringViewRefusal | null {
+  switch (draft.kind) {
+    case 'createCustomTask': {
+      const sprint = endpointRefusal('sprint', 'selected', draft.sprintId);
+      if (sprint !== null) return sprint;
+      for (const dependency of draft.dependsOn) {
+        const refusal = endpointRefusal('task', 'dependency', dependency);
+        if (refusal !== null) return refusal;
+      }
+      if (draft.backlogItemId.trim().length > 0) {
+        const backlog = endpointRefusal('backlog-item', 'linked', draft.backlogItemId);
+        if (backlog !== null) return backlog;
+      }
+      return null;
+    }
+    case 'updateCustomTask':
+      return endpointRefusal('task', 'edited', draft.taskId);
+    case 'addTaskDependency': {
+      const source = endpointRefusal('task', 'source', draft.taskId);
+      if (source !== null) return source;
+      const target = endpointRefusal('task', 'dependency', draft.onTaskId);
+      if (target !== null) return target;
+      if (draft.taskId.trim() === draft.onTaskId.trim()) {
+        return {
+          reason: 'invalid-request',
+          message: `Task ${draft.taskId.trim()} cannot depend on itself, so BB will not submit this dependency.`,
+        };
+      }
+      return null;
+    }
+    case 'removeTaskDependency': {
+      const source = endpointRefusal('task', 'source', draft.taskId);
+      if (source !== null) return source;
+      const target = endpointRefusal('task', 'removed dependency', draft.removeTaskId);
+      if (target !== null) return target;
+      if (draft.taskId.trim() === draft.removeTaskId.trim()) {
+        return {
+          reason: 'invalid-request',
+          message: `Task ${draft.taskId.trim()} cannot depend on itself, so BB will not submit this removal.`,
+        };
+      }
+      return null;
+    }
+    case 'linkTaskToBacklog': {
+      const source = endpointRefusal('task', 'source', draft.taskId);
+      if (source !== null) return source;
+      return endpointRefusal('backlog-item', 'linked', draft.backlogItemId);
+    }
+  }
+}
+
+/** Field-level checks for one draft, after its identities are known good. */
+function fieldRefusal(draft: TaskAuthoringDraft): TaskAuthoringViewRefusal | null {
+  if (draft.kind === 'createCustomTask') {
+    if (draft.title.trim().length === 0) {
+      return {
+        reason: 'invalid-request',
+        message: 'Enter a title before creating a custom task.',
+      };
+    }
+    const estimate = readNumberField(draft.estimate);
+    if (estimate.state === 'absent') {
+      return {
+        reason: 'invalid-request',
+        message:
+          'Enter an estimate in hours before creating a custom task. BB never inherits an estimate default.',
+      };
+    }
+    if (estimate.state === 'invalid') return invalidNumberRefusal('the estimate', estimate.raw);
+    const runtime = readNumberField(draft.expectedRuntimeMinutes);
+    if (runtime.state === 'invalid') {
+      return invalidNumberRefusal('the expected runtime in minutes', runtime.raw);
+    }
+    const priority = readPriorityField(draft.priority);
+    if (priority.state === 'invalid') {
+      return {
+        reason: 'invalid-request',
+        message: `"${priority.raw}" is not a Poetic priority (P0, P1, P2, or P3), so BB will not submit it.`,
+      };
+    }
+    return null;
+  }
+  if (draft.kind === 'updateCustomTask') {
+    const estimate = readNumberField(draft.estimate);
+    if (estimate.state === 'invalid') return invalidNumberRefusal('the estimate', estimate.raw);
+    const runtime = readNumberField(draft.expectedRuntimeMinutes);
+    if (runtime.state === 'invalid') {
+      return invalidNumberRefusal('the expected runtime in minutes', runtime.raw);
+    }
+    const priority = readPriorityField(draft.priority);
+    if (priority.state === 'invalid') {
+      return {
+        reason: 'invalid-request',
+        message: `"${priority.raw}" is not a Poetic priority (P0, P1, P2, or P3), so BB will not submit it.`,
+      };
+    }
+    const changes =
+      draft.title.trim().length > 0 ||
+      draft.description.trim().length > 0 ||
+      priority.state === 'value' ||
+      estimate.state === 'value' ||
+      runtime.state === 'value';
+    if (!changes) {
+      return {
+        reason: 'invalid-request',
+        message: 'Change at least one task field before saving. BB submits no empty edit.',
+      };
+    }
+  }
+  return null;
+}
+
+/**
+ * Refuse a Description replacement BB could not prepopulate from the canonical
+ * detail. Submitting an unprepopulated editor would silently discard whatever
+ * Poetic currently holds in that section.
+ */
+function prepopulationRefusal(
+  draft: TaskAuthoringDraft,
+  prepopulation: TaskAuthoringPrepopulation | null
+): TaskAuthoringViewRefusal | null {
+  if (!taskAuthoringDraftReplacesDescription(draft)) return null;
+  if (prepopulation === null) {
+    return {
+      reason: 'description-prepopulation-unavailable',
+      message:
+        'BB holds no canonical Description for this task, so it will not replace the Description section.',
+    };
+  }
+  if (prepopulation.state === 'unavailable') {
+    return { reason: 'description-prepopulation-unavailable', message: prepopulation.reason };
+  }
+  return null;
+}
+
+/**
+ * The single refusal gate for an authoring draft, shared by the rendered
+ * controls, the confirmation, and request construction, so a disabled control
+ * and a refused submission always agree.
+ */
+export function taskAuthoringViewRefusal(
+  input: TaskAuthoringGateInput
+): TaskAuthoringViewRefusal | null {
+  const draft = input.draft;
+
+  // A host could hand this panel an object carrying a status, lifecycle,
+  // execution, or filesystem field. It is named and refused here rather than
+  // silently dropped, and no authoring request is built from it.
+  const denied = taskAuthoringDeniedInputKeys(draft);
+  if (denied.length > 0) {
+    return {
+      reason: 'lifecycle-field',
+      message: `This draft carries ${denied.join(', ')}, which authoring never sends. Task status stays with the separate lifecycle controls, and nothing was submitted.`,
+    };
+  }
+  if (!(TASK_AUTHORING_VOCABULARY as readonly string[]).includes(draft.kind)) {
+    return {
+      reason: 'invalid-request',
+      message:
+        'This draft is not one of the custom task authoring actions, so nothing was submitted.',
+    };
+  }
+
+  const identity = identityRefusal(draft);
+  if (identity !== null) return identity;
+
+  if (draft.kind !== 'createCustomTask') {
+    const detail = detailRefusal(draft.taskId.trim(), input);
+    if (detail !== null) return detail;
+  }
+
+  const prepopulation = prepopulationRefusal(draft, input.descriptionPrepopulation);
+  if (prepopulation !== null) return prepopulation;
+
+  const inFlight = input.inFlight;
+  if (inFlight !== null) {
+    return {
+      reason: 'already-in-flight',
+      message: `This panel already submitted ${TASK_AUTHORING_LABELS[inFlight.action].toLowerCase()} for ${inFlight.identity} and Poetic has not answered yet. Wait for that action before submitting another.`,
+    };
+  }
+
+  const fields = fieldRefusal(draft);
+  if (fields !== null) return fields;
+
+  if (
+    taskAuthoringConsentPayload(
+      draft.kind,
+      taskAuthoringDraftReplacesDescription(draft),
+      input.consent
+    ) === null
+  ) {
+    return {
+      reason: 'invalid-request',
+      message: 'Accept every consent line for this action before submitting.',
+    };
+  }
+  return null;
+}
+
+/** Evidence BB last read, submitted with the request so drift is refused. */
+export interface TaskAuthoringObservedState {
+  repositoryPath: string;
+  /** Branch Poetic reported, or null for a detached HEAD. */
+  branch: string | null;
+  /** Sprint BB was showing this task in, or null when it holds none. */
+  observedSprintId: string | null;
+  /** Sprint membership BB last read, or null when it holds none. */
+  observedSprintTaskIds: readonly string[] | null;
+}
+
+export interface TaskAuthoringRequestInput extends TaskAuthoringGateInput {
+  projectId: string;
+  sourceId: string;
+  observed: TaskAuthoringObservedState;
+}
+
+export type TaskAuthoringRequestDecision =
+  | {
+      admitted: true;
+      request: ApplyTaskAuthoringInput;
+      /** The unresolved submission the panel must hold until Poetic answers. */
+      submission: TaskAuthoringSubmissionState;
+    }
+  | { admitted: false; refusal: TaskAuthoringViewRefusal };
+
+/** The draft's whitelisted `input` payload, as raw values for the wire schema. */
+function draftInputPayload(draft: TaskAuthoringDraft): Record<string, unknown> {
+  switch (draft.kind) {
+    case 'createCustomTask': {
+      const estimate = readNumberField(draft.estimate);
+      const runtime = readNumberField(draft.expectedRuntimeMinutes);
+      const priority = readPriorityField(draft.priority);
+      const payload: Record<string, unknown> = {
+        sprintId: draft.sprintId.trim(),
+        title: draft.title.trim(),
+      };
+      if (estimate.state === 'value') payload.estimate = estimate.value;
+      if (runtime.state === 'value') payload.expectedRuntimeMinutes = runtime.value;
+      if (draft.description.trim().length > 0) payload.description = draft.description.trim();
+      if (priority.state === 'value') payload.priority = priority.value;
+      if (draft.dependsOn.length > 0) {
+        payload.dependsOn = draft.dependsOn.map((dependency) => dependency.trim());
+      }
+      if (draft.backlogItemId.trim().length > 0) {
+        payload.backlogItemId = draft.backlogItemId.trim();
+      }
+      return payload;
+    }
+    case 'updateCustomTask': {
+      const estimate = readNumberField(draft.estimate);
+      const runtime = readNumberField(draft.expectedRuntimeMinutes);
+      const priority = readPriorityField(draft.priority);
+      const payload: Record<string, unknown> = { taskId: draft.taskId.trim() };
+      if (draft.title.trim().length > 0) payload.title = draft.title.trim();
+      if (draft.description.trim().length > 0) payload.description = draft.description.trim();
+      if (priority.state === 'value') payload.priority = priority.value;
+      if (estimate.state === 'value') payload.estimate = estimate.value;
+      if (runtime.state === 'value') payload.expectedRuntimeMinutes = runtime.value;
+      return payload;
+    }
+    case 'addTaskDependency':
+      return { taskId: draft.taskId.trim(), onTaskId: draft.onTaskId.trim() };
+    case 'removeTaskDependency':
+      return { taskId: draft.taskId.trim(), removeTaskId: draft.removeTaskId.trim() };
+    case 'linkTaskToBacklog':
+      return { taskId: draft.taskId.trim(), backlogItemId: draft.backlogItemId.trim() };
+  }
+}
+
+/**
+ * Build one typed BPAU-02 request from a confirmed draft, or refuse it.
+ *
+ * The candidate is validated by the frozen wire schema itself, so anything the
+ * legible gate above did not name still fails closed instead of being submitted.
+ * It is parsed twice on purpose: `expected.entityIds` must be exactly the
+ * identities the request declares, and that set is derived from the already
+ * validated request rather than recomputed here.
+ */
+export function buildTaskAuthoringRequest(
+  input: TaskAuthoringRequestInput
+): TaskAuthoringRequestDecision {
+  const refusal = taskAuthoringViewRefusal(input);
+  if (refusal !== null) return { admitted: false, refusal };
+
+  const draft = input.draft;
+  const consent = taskAuthoringConsentPayload(
+    draft.kind,
+    taskAuthoringDraftReplacesDescription(draft),
+    input.consent
+  );
+  if (consent === null) {
+    // Unreachable while the gate above owns consent; kept so a future gate change
+    // cannot turn incomplete consent into a submitted request.
+    return {
+      admitted: false,
+      refusal: {
+        reason: 'invalid-request',
+        message: 'Accept every consent line for this action before submitting.',
+      },
+    };
+  }
+
+  const candidate = (entityIds: readonly string[]): Record<string, unknown> => ({
+    projectId: input.projectId,
+    sourceId: input.sourceId,
+    action: draft.kind,
+    input: draftInputPayload(draft),
+    expected: {
+      repositoryPath: input.observed.repositoryPath,
+      branch: input.observed.branch,
+      entityIds: [...entityIds],
+      observedSprintId: input.observed.observedSprintId,
+      observedTaskUpdatedAt: input.observedTaskUpdatedAt,
+      observedSprintTaskIds:
+        input.observed.observedSprintTaskIds === null
+          ? null
+          : [...input.observed.observedSprintTaskIds],
+    },
+    consent,
+  });
+
+  const provisional = applyTaskAuthoringInputSchema.safeParse(candidate([]));
+  if (!provisional.success) {
+    return {
+      admitted: false,
+      refusal: {
+        reason: 'invalid-request',
+        message:
+          'This draft is not a valid custom task authoring request, so nothing was submitted.',
+      },
+    };
+  }
+  const declared = applyTaskAuthoringInputSchema.safeParse(
+    candidate(taskAuthoringDeclaredIdentities(provisional.data))
+  );
+  if (!declared.success) {
+    return {
+      admitted: false,
+      refusal: {
+        reason: 'invalid-request',
+        message:
+          'This draft is not a valid custom task authoring request, so nothing was submitted.',
+      },
+    };
+  }
+
+  return {
+    admitted: true,
+    request: declared.data,
+    submission: {
+      action: draft.kind,
+      identity: draft.kind === 'createCustomTask' ? draft.sprintId.trim() : draft.taskId.trim(),
+    },
+  };
+}
+
+/** One consent line in the confirmation, with its current acknowledgement. */
+export interface TaskAuthoringConsentLineView {
+  key: keyof TaskAuthoringConsentState;
+  label: string;
+  accepted: boolean;
+  required: true;
+}
+
+/** One rendered authoring control. */
+export interface TaskAuthoringControlView {
+  action: TaskAuthoringAction;
+  label: string;
+  buttonLabel: string;
+  effectLabel: string;
+  /**
+   * Always `task-authoring`: these controls author managed planning content and
+   * relationships, never a status transition and never sprint scheduling.
+   */
+  domain: typeof TASK_AUTHORING_DOMAIN;
+  /** Literal false: no authoring control can move a task's status. */
+  lifecycleTransition: false;
+  /** Literal false: creating a custom task is not adding backlog work. */
+  addFromBacklog: false;
+  /** True while this panel's unresolved submission is exactly this action. */
+  busy: boolean;
+  /** True while this panel holds any unresolved authoring submission. */
+  panelBusy: boolean;
+  submittable: boolean;
+  /** Plain reason the control cannot be submitted; null when it can. */
+  blockedReason: string | null;
+  refusalReason: TaskAuthoringRefusalReason | null;
+}
+
+export interface TaskAuthoringControlsView {
+  viewVersion: typeof TASK_AUTHORING_VIEW_VERSION;
+  domain: typeof TASK_AUTHORING_DOMAIN;
+  /** The draft's action, rendered as the selected control. */
+  action: TaskAuthoringAction;
+  controls: readonly TaskAuthoringControlView[];
+  createDistinctionNotice: string;
+  addFromBacklogSeparationNotice: string;
+  lifecycleSeparationNotice: string;
+  concurrencyNotice: string;
+  /** Literal false: this panel renders no lifecycle control at all. */
+  includesLifecycleControls: false;
+}
+
+/**
+ * Project the authoring controls for one draft. Pure: the same input always
+ * yields the same view. Only the drafted action can be submittable, because a
+ * draft carries the fields of exactly one action.
+ */
+export function buildTaskAuthoringControlsView(
+  input: TaskAuthoringGateInput
+): TaskAuthoringControlsView {
+  const action = taskAuthoringDraftAction(input.draft);
+  const panelBusy = input.inFlight !== null;
+  const controls = TASK_AUTHORING_VOCABULARY.map((candidate) => {
+    const refusal =
+      candidate === action
+        ? taskAuthoringViewRefusal(input)
+        : {
+            reason: 'invalid-request' as const,
+            message: `Open ${TASK_AUTHORING_LABELS[candidate].toLowerCase()} to enter its own fields; this draft is ${TASK_AUTHORING_LABELS[action].toLowerCase()}.`,
+          };
+    return {
+      action: candidate,
+      label: TASK_AUTHORING_LABELS[candidate],
+      buttonLabel: TASK_AUTHORING_BUTTON_LABELS[candidate],
+      effectLabel: TASK_AUTHORING_EFFECTS[candidate],
+      domain: TASK_AUTHORING_DOMAIN,
+      lifecycleTransition: false as const,
+      addFromBacklog: false as const,
+      busy: panelBusy && input.inFlight?.action === candidate,
+      panelBusy,
+      submittable: refusal === null,
+      blockedReason: refusal === null ? null : refusal.message,
+      refusalReason: refusal === null ? null : refusal.reason,
+    };
+  });
+
+  return {
+    viewVersion: TASK_AUTHORING_VIEW_VERSION,
+    domain: TASK_AUTHORING_DOMAIN,
+    action,
+    controls,
+    createDistinctionNotice: TASK_AUTHORING_CREATE_DISTINCTION_NOTICE,
+    addFromBacklogSeparationNotice: TASK_AUTHORING_ADD_FROM_BACKLOG_SEPARATION_NOTICE,
+    lifecycleSeparationNotice: TASK_AUTHORING_LIFECYCLE_SEPARATION_NOTICE,
+    concurrencyNotice: TASK_AUTHORING_CONCURRENCY_NOTICE,
+    includesLifecycleControls: false,
+  };
+}
+
+/** The Description editor for one task, and whether it may be submitted. */
+export interface TaskAuthoringDescriptionEditorView {
+  taskId: string;
+  state: 'prepopulated' | 'unavailable';
+  /** The canonical Description to edit; null when it could not be prepopulated. */
+  value: string | null;
+  editable: boolean;
+  submittable: boolean;
+  replacementNotice: string;
+  /** Poetic's own reason the canonical Description is missing; null otherwise. */
+  unavailableReason: string | null;
+}
+
+/**
+ * Build the Description editor from the canonical `taskDescriptionV1` sibling.
+ * An editor BB could not prepopulate is read-only and unsubmittable, so a
+ * replacement can never discard a Description BB never read.
+ */
+export function buildTaskAuthoringDescriptionEditorView(
+  taskId: string,
+  sibling:
+    | { state: 'available'; value: { taskId: string; description: string } }
+    | { state: 'unavailable'; reason: string }
+): TaskAuthoringDescriptionEditorView {
+  const prepopulation = taskAuthoringDescriptionPrepopulation(taskId, sibling);
+  if (prepopulation.state === 'unavailable') {
+    return {
+      taskId,
+      state: 'unavailable',
+      value: null,
+      editable: false,
+      submittable: false,
+      replacementNotice: TASK_AUTHORING_DESCRIPTION_REPLACEMENT_NOTICE,
+      unavailableReason: prepopulation.reason,
+    };
+  }
+  return {
+    taskId,
+    state: 'prepopulated',
+    value: prepopulation.description,
+    editable: true,
+    submittable: true,
+    replacementNotice: TASK_AUTHORING_DESCRIPTION_REPLACEMENT_NOTICE,
+    unavailableReason: null,
+  };
+}
+
+/** The exact endpoints one relationship mutation addresses. */
+export interface TaskAuthoringRelationshipView {
+  sourceTaskId: string;
+  targetId: string;
+  targetKind: TaskAuthoringEndpointKind;
+  /** Plain line naming both endpoints, never abbreviated to one of them. */
+  identityLine: string;
+}
+
+function relationshipView(draft: TaskAuthoringDraft): TaskAuthoringRelationshipView | null {
+  switch (draft.kind) {
+    case 'addTaskDependency':
+      return {
+        sourceTaskId: draft.taskId.trim(),
+        targetId: draft.onTaskId.trim(),
+        targetKind: 'task',
+        identityLine: `Task ${draft.taskId.trim()} will be recorded as depending on task ${draft.onTaskId.trim()}.`,
+      };
+    case 'removeTaskDependency':
+      return {
+        sourceTaskId: draft.taskId.trim(),
+        targetId: draft.removeTaskId.trim(),
+        targetKind: 'task',
+        identityLine: `The dependency of task ${draft.taskId.trim()} on task ${draft.removeTaskId.trim()} will be removed.`,
+      };
+    case 'linkTaskToBacklog':
+      return {
+        sourceTaskId: draft.taskId.trim(),
+        targetId: draft.backlogItemId.trim(),
+        targetKind: 'backlog-item',
+        identityLine: `Task ${draft.taskId.trim()} will record backlog item ${draft.backlogItemId.trim()} as its provenance.`,
+      };
+    default:
+      return null;
+  }
+}
+
+export interface TaskAuthoringConfirmationView {
+  viewVersion: typeof TASK_AUTHORING_VIEW_VERSION;
+  action: TaskAuthoringAction;
+  headline: string;
+  /** Label of the control that actually submits, named for this action. */
+  submitLabel: string;
+  effectLabel: string;
+  repositoryPath: string;
+  branchLabel: string;
+  targetLine: string;
+  /** The exact fixed Poetic command that will run; null while refused. */
+  commandLine: string | null;
+  /** Endpoints for a relationship mutation; null for create and edit. */
+  relationship: TaskAuthoringRelationshipView | null;
+  /** Description-replacement disclosure; null when no Description is replaced. */
+  descriptionReplacementNotice: string | null;
+  disclosureSummary: string;
+  consentLines: readonly TaskAuthoringConsentLineView[];
+  submittable: boolean;
+  blockedReason: string | null;
+  refusalReason: TaskAuthoringRefusalReason | null;
+  lifecycleSeparationNotice: string;
+}
+
+/**
+ * The mutation confirmation for one draft: what will run, where, on which
+ * branch, against which endpoints, and which consent is still outstanding. The
+ * command line is Poetic's own fixed argv and is shown only once the draft is
+ * admissible, so a refused draft never displays a command it will not run.
+ */
+export function buildTaskAuthoringConfirmationView(
+  input: TaskAuthoringRequestInput
+): TaskAuthoringConfirmationView {
+  const draft = input.draft;
+  const action = taskAuthoringDraftAction(draft);
+  const decision = buildTaskAuthoringRequest(input);
+  const branchLabel = input.observed.branch ?? 'detached HEAD (no named branch)';
+  const consentKeys = taskAuthoringRequiredConsentKeys(
+    action,
+    taskAuthoringDraftReplacesDescription(draft)
+  );
+  const targetLine =
+    draft.kind === 'createCustomTask'
+      ? `New custom task in sprint ${draft.sprintId.trim()} in ${input.observed.repositoryPath} on ${branchLabel}`
+      : `Task ${draft.taskId.trim()} in ${input.observed.repositoryPath} on ${branchLabel}`;
+
+  return {
+    viewVersion: TASK_AUTHORING_VIEW_VERSION,
+    action,
+    headline: `Confirm ${TASK_AUTHORING_LABELS[action].toLowerCase()}`,
+    submitLabel: `Submit ${TASK_AUTHORING_LABELS[action].toLowerCase()}`,
+    effectLabel: TASK_AUTHORING_EFFECTS[action],
+    repositoryPath: input.observed.repositoryPath,
+    branchLabel,
+    targetLine,
+    commandLine: decision.admitted
+      ? `poetic ${taskAuthoringArgv(decision.request).join(' ')}`
+      : null,
+    relationship: relationshipView(draft),
+    descriptionReplacementNotice: taskAuthoringDraftReplacesDescription(draft)
+      ? TASK_AUTHORING_DESCRIPTION_REPLACEMENT_NOTICE
+      : null,
+    disclosureSummary: TASK_AUTHORING_DISCLOSURE.summary,
+    consentLines: consentKeys.map((key) => ({
+      key,
+      label: TASK_AUTHORING_CONSENT_LABELS[key],
+      accepted: input.consent[key],
+      required: true,
+    })),
+    submittable: decision.admitted,
+    blockedReason: decision.admitted ? null : decision.refusal.message,
+    refusalReason: decision.admitted ? null : decision.refusal.reason,
+    lifecycleSeparationNotice: TASK_AUTHORING_LIFECYCLE_SEPARATION_NOTICE,
+  };
+}
+
+/** The panel while one submitted action is unresolved. */
+export interface TaskAuthoringPendingView {
+  viewVersion: typeof TASK_AUTHORING_VIEW_VERSION;
+  state: 'awaiting-canonical-reread';
+  action: TaskAuthoringAction;
+  identity: string;
+  headline: string;
+  attemptsNotice: string;
+  awaitingRereadNotice: string;
+  /** Literal false: nothing about the result is rendered before Poetic answers. */
+  predictsOutcome: false;
+}
+
+/**
+ * Render the wait between submitting one request and receiving Poetic's outcome.
+ * No optimistic identity, status, membership, capacity, or sync result appears
+ * here: the panel only reports that it is waiting.
+ */
+export function buildTaskAuthoringPendingView(
+  submission: TaskAuthoringSubmissionState
+): TaskAuthoringPendingView {
+  return {
+    viewVersion: TASK_AUTHORING_VIEW_VERSION,
+    state: 'awaiting-canonical-reread',
+    action: submission.action,
+    identity: submission.identity,
+    headline: `Waiting for Poetic: ${TASK_AUTHORING_LABELS[submission.action].toLowerCase()} for ${submission.identity}`,
+    attemptsNotice: 'BB submitted this once and never retries it automatically.',
+    awaitingRereadNotice: TASK_AUTHORING_AWAITING_REREAD_NOTICE,
+    predictsOutcome: false,
+  };
+}
+
+export interface TaskAuthoringOutcomeRow {
+  id: string;
+  label: string;
+  value: string;
+}
+
+/**
+ * How the panel presents one completed attempt. It is derived from Poetic's own
+ * effect phase, never from the exit code, and `undetermined` is a distinct state
+ * from both applied and failed.
+ */
+export type TaskAuthoringOutcomeState =
+  | 'applied'
+  | 'applied-incomplete'
+  | 'refused'
+  | 'failed'
+  | 'undetermined';
+
+export interface TaskAuthoringOutcomeView {
+  viewVersion: typeof TASK_AUTHORING_VIEW_VERSION;
+  action: TaskAuthoringAction;
+  state: TaskAuthoringOutcomeState;
+  /** Poetic's own command state, carried verbatim. */
+  commandState: TaskAuthoringCommandEvidence['state'];
+  /** Poetic's own effect phase, carried verbatim. */
+  effectPhase: TaskAuthoringEffect['phase'];
+  headline: string;
+  commandLine: string;
+  attemptsNotice: string;
+  /** Poetic's own diagnostics, verbatim; null when it reported none. */
+  diagnostics: string | null;
+  /** Set whenever the outcome cannot be read as a settled state. */
+  ambiguityNotice: string | null;
+  createdIdentities: readonly string[];
+  affectedIdentities: readonly string[];
+  rows: readonly TaskAuthoringOutcomeRow[];
+  syncState: TaskAuthoringSync['state'];
+  syncWarnings: readonly string[];
+  syncNotice: string;
+  integrityNotes: readonly string[];
+  rereadNotice: string;
+  taskState: 'available' | 'missing' | 'unavailable';
+  taskStateNotice: string;
+  /** Literal false: no status transition is ever reported by this panel. */
+  lifecycleTransition: false;
+}
+
+function outcomeState(phase: TaskAuthoringEffect['phase']): TaskAuthoringOutcomeState {
+  switch (phase) {
+    case 'applied':
+      return 'applied';
+    case 'applied-incomplete':
+      return 'applied-incomplete';
+    case 'refused-before-launch':
+    case 'refused-before-effect':
+      return 'refused';
+    case 'failed-after-partial-effect':
+      return 'failed';
+    case 'unknown-after-timeout':
+      return 'undetermined';
+  }
+}
+
+function outcomeHeadline(
+  action: TaskAuthoringAction,
+  state: TaskAuthoringOutcomeState,
+  identities: readonly string[]
+): string {
+  const label = TASK_AUTHORING_LABELS[action].toLowerCase();
+  const subject = identities.length > 0 ? ` (${identities.join(', ')})` : '';
+  switch (state) {
+    case 'applied':
+      return `Poetic applied ${label}${subject}.`;
+    case 'applied-incomplete':
+      return `Poetic applied ${label}${subject} incompletely; it reported part of the change as not applied.`;
+    case 'refused':
+      return `Poetic refused ${label} before it changed anything.`;
+    case 'failed':
+      return `Poetic reported ${label} failed after a partial effect${subject}.`;
+    case 'undetermined':
+      return `Whether ${label} applied is undetermined; Poetic published no usable outcome for it.`;
+  }
+}
+
+function ambiguityNotice(
+  commandState: TaskAuthoringCommandEvidence['state'],
+  state: TaskAuthoringOutcomeState
+): string | null {
+  if (commandState === 'timed_out') {
+    return 'Poetic reported this command timed out, so whether it finished is unknown. Nothing was retried, and the canonical reread below is the only authority.';
+  }
+  if (commandState === 'ambiguous' || state === 'undetermined') {
+    return 'Poetic published no usable identity evidence for this attempt, so whether it applied is unknown. Nothing was retried, and BB substituted no task it could see.';
+  }
+  if (state === 'failed') {
+    return 'A failed command may still have applied part of its change. Nothing was retried, and the canonical reread below is the only authority.';
+  }
+  if (state === 'applied-incomplete') {
+    return 'Poetic reported the change as incomplete, so part of it is not recorded. BB completed nothing on its own.';
+  }
+  return null;
+}
+
+function rereadLabel(
+  member: { state: 'available'; value: unknown } | { state: 'unavailable'; reason: string } | null
+): string {
+  if (member === null) return 'not part of this action';
+  return member.state === 'available' ? 'reread' : `unavailable - ${member.reason}`;
+}
+
+function identityRow(value: string | null): string {
+  return value ?? 'none';
+}
+
+/**
+ * Plain rendering of one completed authoring attempt.
+ *
+ * Poetic's structured outcome and its fresh rereads are the only authority: the
+ * exit code is not consulted, an unavailable reread is named rather than filled
+ * in, and a zero exit is never rendered as a confirmed push.
+ */
+export function buildTaskAuthoringOutcomeView(
+  outcome: ApplyTaskAuthoringOutput
+): TaskAuthoringOutcomeView {
+  const state = outcomeState(outcome.effect.phase);
+  const reread = outcome.canonicalRereads;
+  const task = reread.task;
+  const taskState = task.state === 'unavailable' ? ('unavailable' as const) : task.value.task.state;
+  const taskStateNotice =
+    task.state === 'unavailable'
+      ? `Poetic could not be reread for this task after the action: ${task.reason}`
+      : task.value.task.state === 'available'
+        ? 'Poetic re-read this task after the action; the canonical detail shown is that reread.'
+        : task.value.task.state === 'missing'
+          ? 'Poetic reports no managed task at this identity after the action. BB inferred no created, completed, cancelled, or archived state.'
+          : `Poetic could not describe this task after the action: ${task.value.task.reason}`;
+
+  const rows: TaskAuthoringOutcomeRow[] = [
+    { id: 'action', label: 'Action', value: TASK_AUTHORING_LABELS[outcome.action] },
+    { id: 'command-state', label: 'Poetic command state', value: outcome.command.state },
+    { id: 'effect-phase', label: 'Poetic effect phase', value: outcome.effect.phase },
+    {
+      id: 'requested-task',
+      label: 'Requested task',
+      value: identityRow(outcome.requestedIdentities.taskId),
+    },
+    {
+      id: 'requested-sprint',
+      label: 'Requested sprint',
+      value: identityRow(outcome.requestedIdentities.sprintId),
+    },
+    {
+      id: 'requested-dependency',
+      label: 'Requested dependency task',
+      value: identityRow(outcome.requestedIdentities.dependencyTaskId),
+    },
+    {
+      id: 'requested-backlog-item',
+      label: 'Requested backlog item',
+      value: identityRow(outcome.requestedIdentities.backlogItemId),
+    },
+    {
+      id: 'created-identities',
+      label: 'Identities Poetic created',
+      value: outcome.effect.createdIdentities.join(', ') || 'none',
+    },
+    {
+      id: 'affected-identities',
+      label: 'Identities Poetic affected',
+      value: outcome.effect.affectedIdentities.join(', ') || 'none',
+    },
+    { id: 'task-reread', label: 'Task reread', value: rereadLabel(task) },
+    { id: 'sprint-reread', label: 'Sprint reread', value: rereadLabel(reread.sprint) },
+    {
+      id: 'description-reread',
+      label: 'Description reread',
+      value: rereadLabel(reread.description),
+    },
+    { id: 'sync-state', label: 'Planning sync', value: outcome.sync.state },
+    { id: 'workspace-reread', label: 'Workspace reread', value: rereadLabel(outcome.workspace) },
+  ];
+
+  return {
+    viewVersion: TASK_AUTHORING_VIEW_VERSION,
+    action: outcome.action,
+    state,
+    commandState: outcome.command.state,
+    effectPhase: outcome.effect.phase,
+    headline: outcomeHeadline(outcome.action, state, [
+      ...outcome.effect.createdIdentities,
+      ...outcome.effect.affectedIdentities,
+    ]),
+    commandLine: `poetic ${outcome.command.argv.join(' ')}`,
+    attemptsNotice: `BB ran this ${outcome.command.attempts} time and never retries it automatically.`,
+    diagnostics: outcome.command.diagnostics,
+    ambiguityNotice: ambiguityNotice(outcome.command.state, state),
+    createdIdentities: [...outcome.effect.createdIdentities],
+    affectedIdentities: [...outcome.effect.affectedIdentities],
+    rows,
+    syncState: outcome.sync.state,
+    syncWarnings: [...outcome.syncWarnings],
+    syncNotice:
+      outcome.syncWarnings.length === 0
+        ? `Poetic reported planning sync as ${outcome.sync.state} on this reread. A zero exit never confirms the managed sync reached the remote.`
+        : "A zero exit never confirms the managed sync reached the remote; the warnings above are Poetic's own fresh evidence.",
+    integrityNotes: [...outcome.integrityNotes],
+    rereadNotice: TASK_AUTHORING_REREAD_NOTICE,
+    taskState,
+    taskStateNotice,
+    lifecycleTransition: false,
+  };
+}
+
+/** How the panel presents a BPAU-02 refusal that never reached a process. */
+export interface TaskAuthoringRefusalView {
+  viewVersion: typeof TASK_AUTHORING_VIEW_VERSION;
+  state: 'refused-before-launch';
+  action: TaskAuthoringAction | null;
+  reason: TaskAuthoringRefusalReason;
+  headline: string;
+  message: string;
+  /** Literal false: a refusal never ran a command, so nothing changed. */
+  commandRan: false;
+  lifecycleSeparationNotice: string;
+}
+
+/** Render a pre-launch refusal as a refusal, never as an empty success. */
+export function buildTaskAuthoringRefusalView(
+  refusal: TaskAuthoringRefusal
+): TaskAuthoringRefusalView {
+  return {
+    viewVersion: TASK_AUTHORING_VIEW_VERSION,
+    state: 'refused-before-launch',
+    action: refusal.action,
+    reason: refusal.reason,
+    headline:
+      refusal.action === null
+        ? 'Poetic ran no command: BB refused this authoring request.'
+        : `Poetic ran no command: BB refused ${TASK_AUTHORING_LABELS[refusal.action].toLowerCase()}.`,
+    message: refusal.message,
+    commandRan: false,
+    lifecycleSeparationNotice: TASK_AUTHORING_LIFECYCLE_SEPARATION_NOTICE,
+  };
+}