import { reconcileCreate } from './create-recovery.mjs';
import { BusError, createMarker, createDigest } from '../../bus/src/broker.mjs';
import { outcome, refusal } from './vikunja.mjs';
import { ref, parseRef, checkTask, taskFields, digest } from './digest.mjs';
import { board, normal } from './sync.mjs';
import { discover, inspect } from './startup.mjs';
// The eight task verbs (addendum B section 4). Each one: field-table writer check, compare-read with
// the sync token, the caller's expected digest, broker authority, the writes with the acting role's
// own token, a final read, then one self snapshot and its event. A write that answers 5xx or not at
// all is checked by a re-read and never retried (bus README rule).
// Row B: a verb acts in any installed project of the tree (ctx.tree, the root alone with
// descendants off), on that project's own board.
const refuse = (code) => {
  throw new BusError(code);
};
// Verbs whose fields only the pm writes. Checked before authorize so a refused call consumes nothing.
const PM_VERBS = new Set(['task.create', 'task.assign', 'task.reassign', 'task.schedule', 'task.priority.change', 'task.close']);
const STATES = ['todo', 'in-progress', 'in-review', 'blocked'];
const RELATIONS = [
  'subtask',
  'parenttask',
  'related',
  'duplicateof',
  'duplicates',
  'blocking',
  'blocked',
  'precedes',
  'follows',
  'copiedfrom',
  'copiedto',
];
const object = (x) => x !== null && typeof x === 'object' && !Array.isArray(x);
function keys(x, allowed, required = []) {
  if (!object(x) || Object.keys(x).some((k) => !allowed.includes(k)) || required.some((k) => x[k] === undefined))
    refuse('invalid-request');
}
const text = (x, max, min = 0) => {
  if (typeof x !== 'string' || x.length < min || x.length > max) refuse('invalid-request');
  return x;
};
const canonical = (x) =>
  typeof x === 'string' &&
  /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(x) &&
  Number.isFinite(Date.parse(x)) &&
  new Date(x).toISOString() === x;
// Vikunja keeps due dates to the second (review r1, B1), so the milliseconds are dropped before the
// write. The snapshot, the event and an uncertain write's re-read then all hold what Vikunja holds.
const due = (x) => {
  if (x !== null && !canonical(x)) refuse('invalid-request');
  return x === null ? null : `${x.slice(0, 19)}.000Z`;
};
const priority = (x) => {
  if (!Number.isSafeInteger(x) || x < 0 || x > 5) refuse('invalid-request');
  return x;
};
const percent = (x) => {
  if (typeof x !== 'number' || !Number.isFinite(x) || x < 0 || x > 1) refuse('invalid-request');
  return x;
};
const ids = (list) => {
  if (!Array.isArray(list) || list.length > 50 || list.some((x) => !Number.isSafeInteger(x) || x < 1))
    refuse('invalid-request');
  return [...new Set(list)];
};
const sorted = (a) => [...a].sort((x, y) => x - y);
const decision = (x) => (x === undefined ? null : text(x, 128, 1));
export function verbs(ctx) {
  const fail = (code) => refuse(code);
  const scopeArgs = plan => ({ request: plan.request, requirement: plan.requirement,
    ...(plan.project === undefined ? {} : { project: plan.project }),
    ...Object.fromEntries(['project_key','requirement_snapshot','op'].filter(k => plan[k] !== undefined).map(k => [k, plan[k]])) });
  const label = (id) => {
    // Second guard after the bot-owner rule (probes.md, L): only label ids in the business file.
    if (!ctx.labels.has(id)) fail('label-not-allowed');
    return id;
  };
  // A project outside the tree isn't the business's: task-project. A watch-only one has no board the
  // adapter trusts, so nothing writes to it: project-not-installed.
  const installed = (project) => {
    if (!ctx.tree.has(project)) fail('task-project');
    const view = ctx.tree.get(project);
    if (!view) fail('project-not-installed');
    return view;
  };
  const relation = (x) => {
    keys(x, ['kind', 'task_ref'], ['kind', 'task_ref']);
    if (!RELATIONS.includes(x.kind)) fail('invalid-request');
    const other = parseRef(x.task_ref);
    installed(other.project);
    return { kind: x.kind, other: other.task, project: other.project };
  };
  // Where a verb acts: the task's project, its board and the task id.
  const target = (taskRef) => {
    const r = parseRef(taskRef);
    return { project: r.project, view: installed(r.project), id: r.task };
  };
  // The ref's project is only a claim until a read shows it, so each related task is read once
  // with the sync token before anything is authorized.
  async function located(list) {
    for (const r of list) {
      const x = await ctx.sync('GET', `/tasks/${r.other}`);
      if (outcome(x) !== 'ok') fail(refusal(x));
      checkTask(x.json);
      if (x.json.id !== r.other) fail('tracker-shape');
      if (x.json.project_id !== r.project) fail('task-moved');
    }
  }
  // The live state of one task: the task read plus its board bucket, both with the sync token.
  async function read(at) {
    const id = at.id;
    const x = await ctx.sync('GET', `/tasks/${id}`);
    if (outcome(x) !== 'ok') fail(refusal(x));
    checkTask(x.json);
    if (x.json.id !== id) fail('tracker-shape');
    if (x.json.project_id !== at.project) fail('task-moved');
    let bucket = at.view.done;
    if (!x.json.done) {
      bucket = (await board(ctx, at.project, at.view)).get(id)?.bucket;
      if (!bucket) fail('task-placement');
    }
    const fields = taskFields(x.json, bucket);
    return { task: x.json, bucket, fields, digest: digest(fields), etag: x.etag, updated: normal(x.json.updated) };
  }
  const relatedTo = (task, kind, other) =>
    Array.isArray(task.related_tasks?.[kind]) && task.related_tasks[kind].some((t) => t?.id === other);
  // One write with the acting role's token. An uncertain answer is settled by a re-read.
  // `me` is the broker's session for the caller's cap (design D5).
  async function step(me, method, path, body, at, done) {
    const r = await ctx.as(me, method, path, { body });
    const o = outcome(r);
    if (o === 'ok') return r;
    if (o === 'uncertain' && at !== null && done) {
      let after = null;
      try {
        after = await read(at);
      } catch {
        // the re-read failed too: the outcome stays unknown
      }
      if (after && done(after)) return null;
    }
    fail(o === 'uncertain' ? 'write-uncertain' : refusal(r));
  }
  return async function handle(cap, verb, args) {
    const me = ctx.broker.identity(cap);
    const role = me.role;
    const mine = ctx.roles[role];
    if (!mine) fail('tracker-role');
    if (PM_VERBS.has(verb) && mine.definition !== 'pm') fail('field-writer');
    const plan = prepare(verb, args, role, mine);
    if (verb === 'task.create') return create(cap, me, plan);
    const at = target(args.task_ref);
    const before = await read(at);
    if (args.expect !== undefined && args.expect !== before.digest) {
      ctx.broker.recordTask({
        cap,
        business: ctx.business,
        events: [{ kind: 'task.conflict', subject: args.task_ref, body: { verb, expected: args.expect, actual: before.digest } }],
      });
      fail('task-conflict');
    }
    // Reopening a done task is a person's act; no verb writes to one.
    if (before.task.done) fail('task-done');
    const work = plan.check(before, at);
    await located(plan.others ?? []);
    // Row 93 (#1587): task.close's verdict goes to the broker, which checks it on a pushed task.
    ctx.broker.authorize(cap, verb, { decision: plan.decision, target: args.task_ref, ...(verb === 'task.close' ? { verdict: args.verdict } : {}) });
    let failure = null;
    let landed = 0;
    try {
      for (const [method, path, body, done] of work.steps) {
        await step(me, method, path, body, at, done);
        landed++;
      }
    } catch (e) {
      failure = e instanceof BusError ? e : new BusError('adapter-failed');
    }
    let after = null;
    try {
      after = await read(at);
    } catch {
      // handled below: a failed final read must not hide a write that landed (review r1, B2)
    }
    // The final read failed after some writes and not others: what the tracker holds isn't known.
    if (!after && failure) throw landed ? new BusError('write-uncertain') : failure;
    // Expected fields on success, so a concurrent edit still shows as external on the next poll. When
    // every write landed but the final read failed, that is still what the writes set, and `updated`
    // is the compare-read's. On a failure the snapshot is what the tracker holds now.
    const fields = failure ? after.fields : work.expect(before.fields);
    const seen = after ?? before;
    ctx.broker.recordTask({
      cap,
      business: ctx.business,
      snapshots: [{ task_ref: args.task_ref, updated: seen.updated, etag: after?.etag ?? null, digest: digest(fields), fields }],
      events: failure || !work.event ? [] : [{ ...work.event, subject: args.task_ref }],
    });
    if (failure) throw failure;
    return { task_ref: args.task_ref, digest: digest(fields), updated: seen.updated };
  };
  function prepare(verb, args, role, mine) {
    const common = ['task_ref', 'decision', 'expect'];
    const plan = { decision: decision(args?.decision) };
    if (args?.expect !== undefined && !/^[0-9a-f]{64}$/.test(args.expect)) fail('invalid-request');
    switch (verb) {
      case 'task.create': {
        keys(args, ['title', 'description', 'due_date', 'priority', 'labels', 'relations', 'request', 'requirement', 'decision', 'project', 'op', 'project_key', 'requirement_snapshot'], ['title', 'request', 'requirement']);
        // The optional numeric project is only a board assertion. The broker resolves the target
        // from the confirmed request (or the explicitly bound legacy Stack catalogue).
        if (args.project !== undefined) {
          if (!Number.isSafeInteger(args.project) || args.project < 1) fail('invalid-request');
          if (!ctx.tree.get(args.project)) fail('project-not-installed');
        }
        plan.project = args.project;
        const body = { title: text(args.title, 250, 1) };
        if (!body.title.trim()) fail('invalid-request');
        if (args.description !== undefined) body.description = text(args.description, 65536);
        if (args.due_date !== undefined) body.due_date = due(args.due_date);
        if (args.priority !== undefined) body.priority = priority(args.priority);
        plan.body = body;
        plan.labels = args.labels === undefined ? [] : ids(args.labels).map(label);
        if (args.relations !== undefined && (!Array.isArray(args.relations) || args.relations.length > 50)) fail('invalid-request');
        plan.relations = (args.relations ?? []).map(relation);
        plan.others = plan.relations;
        plan.request = text(args.request, 64, 1);
        plan.requirement = text(args.requirement, 64);
        if (!/^REQ-[A-Z]+-[1-9][0-9]*$/.test(plan.requirement)) fail('invalid-request');
        for (const field of ['op', 'project_key', 'requirement_snapshot'])
          if (args[field] !== undefined) {
            plan[field] = text(args[field], 256, 1);
            if (/[;\r\n]/.test(plan[field])) fail('invalid-request');
          }
        return plan;
      }
      case 'task.assign':
      case 'task.reassign': {
        keys(args, [...common, 'role'], ['task_ref', 'role']);
        const to = ctx.roles[text(args.role, 64, 1)];
        if (!to || !Object.hasOwn(ctx.roles, args.role)) fail('unknown-role');
        const bots = new Map(Object.entries(ctx.roles).map(([r, x]) => [x.botId, r]));
        plan.check = ({ fields }, { id }) => {
          const held = fields.assignees.filter((u) => bots.has(u));
          const previous = held.map((u) => bots.get(u)).sort();
          if (verb === 'task.assign' && held.length) fail('task-assigned');
          if (verb === 'task.reassign' && held.length === 1 && held[0] === to.botId) fail('task-assigned');
          if (verb === 'task.reassign' && !held.length) fail('task-unassigned');
          const steps = [];
          if (!held.includes(to.botId))
            steps.push(['POST', `/tasks/${id}/assignees`, { user_id: to.botId }, (a) => a.fields.assignees.includes(to.botId)]);
          // Unassign answers 204 for a user who isn't assigned (probes.md, D), so only users the
          // compare-read showed are removed.
          for (const u of held.filter((u) => u !== to.botId))
            steps.push(['DELETE', `/tasks/${id}/assignees/${u}`, undefined, (a) => !a.fields.assignees.includes(u)]);
          return {
            steps,
            expect: (f) => ({ ...f, assignees: sorted([...f.assignees.filter((u) => !bots.has(u)), to.botId]) }),
            event: { kind: 'task.assigned', body: { role: args.role, previous } },
          };
        };
        return plan;
      }
      case 'task.schedule': {
        keys(args, [...common, 'due_date', 'labels', 'relations'], ['task_ref']);
        if (args.due_date === undefined && args.labels === undefined && args.relations === undefined) fail('invalid-request');
        const labels = { add: [], remove: [] };
        if (args.labels !== undefined) {
          keys(args.labels, ['add', 'remove']);
          labels.add = ids(args.labels.add ?? []).map(label);
          labels.remove = ids(args.labels.remove ?? []).map(label);
        }
        const list = (x) => {
          if (x !== undefined && (!Array.isArray(x) || x.length > 50)) fail('invalid-request');
          return x;
        };
        const relations = args.relations === undefined ? { add: [], remove: [] } : (keys(args.relations, ['add', 'remove']), {
          add: (list(args.relations.add) ?? []).map(relation),
          remove: (list(args.relations.remove) ?? []).map(relation),
        });
        const dueDate = args.due_date === undefined ? undefined : due(args.due_date);
        plan.others = [...relations.add, ...relations.remove];
        plan.check = ({ task, fields }, { id }) => {
          const steps = [];
          const iso = dueDate === undefined ? undefined : dueDate;
          if (iso !== undefined && iso !== fields.due_date)
            steps.push(['PATCH', `/tasks/${id}`, { due_date: iso }, (a) => a.fields.due_date === iso]);
          for (const l of labels.add.filter((l) => !fields.labels.includes(l)))
            steps.push(['POST', `/tasks/${id}/labels`, { label_id: l }, (a) => a.fields.labels.includes(l)]);
          // A label that isn't on the task answers 403 to a delete, so only labels shown are removed.
          for (const l of labels.remove.filter((l) => fields.labels.includes(l)))
            steps.push(['DELETE', `/tasks/${id}/labels/${l}`, undefined, (a) => !a.fields.labels.includes(l)]);
          for (const r of relations.add.filter((r) => !relatedTo(task, r.kind, r.other)))
            steps.push(['POST', `/tasks/${id}/relations`, { other_task_id: r.other, relation_kind: r.kind }, (a) => relatedTo(a.task, r.kind, r.other)]);
          for (const r of relations.remove.filter((r) => relatedTo(task, r.kind, r.other)))
            steps.push(['DELETE', `/tasks/${id}/relations/${r.kind}/${r.other}`, undefined, (a) => !relatedTo(a.task, r.kind, r.other)]);
          return {
            steps,
            expect: (f) => ({
              ...f,
              due_date: iso === undefined ? f.due_date : iso,
              labels: sorted([...new Set([...f.labels.filter((l) => !labels.remove.includes(l)), ...labels.add])]),
            }),
            event: null,
          };
        };
        return plan;
      }
      case 'task.priority.change': {
        keys(args, [...common, 'priority'], ['task_ref', 'priority']);
        const p = priority(args.priority);
        plan.check = ({ fields }, { id }) => ({
          steps: p === fields.priority ? [] : [['PATCH', `/tasks/${id}`, { priority: p }, (a) => a.fields.priority === p]],
          expect: (f) => ({ ...f, priority: p }),
          event: null,
        });
        return plan;
      }
      case 'task.scope.change': {
        keys(args, [...common, 'title', 'description'], ['task_ref']);
        const body = {};
        if (args.title !== undefined) body.title = text(args.title, 250, 1);
        if (body.title !== undefined && !body.title.trim()) fail('invalid-request');
        if (args.description !== undefined) body.description = text(args.description, 65536);
        if (!Object.keys(body).length) fail('invalid-request');
        plan.check = ({ fields }, { id }) => {
          const send = Object.fromEntries(Object.entries(body).filter(([k, v]) => fields[k] !== v));
          return {
            steps: Object.keys(send).length
              ? [['PATCH', `/tasks/${id}`, send, (a) => Object.entries(send).every(([k, v]) => a.fields[k] === v)]]
              : [],
            expect: (f) => ({ ...f, ...body }),
            event: null,
          };
        };
        return plan;
      }
      case 'task.update.assigned': {
        keys(args, [...common, 'percent_done', 'state', 'comment'], ['task_ref']);
        const pct = args.percent_done === undefined ? undefined : percent(args.percent_done);
        // done is not a target here: closing is the pm's task.close after a review verdict.
        if (args.state !== undefined && !STATES.includes(args.state)) fail('invalid-state');
        const note = args.comment === undefined ? undefined : text(args.comment, 10000, 1);
        if (pct === undefined && args.state === undefined && note === undefined) fail('invalid-request');
        plan.check = ({ fields }, { id, project, view }) => {
          if (!fields.assignees.includes(mine.botId)) fail('not-assigned');
          const to = args.state === undefined ? fields.bucket : view.ids[args.state];
          const steps = [];
          if (pct !== undefined && pct !== fields.percent_done)
            steps.push(['PATCH', `/tasks/${id}`, { percent_done: pct }, (a) => a.fields.percent_done === pct]);
          if (to !== fields.bucket)
            steps.push([
              'PUT',
              `/projects/${project}/views/${view.id}/buckets/${to}/tasks`,
              { task_id: id },
              (a) => a.bucket === to,
            ]);
          // Comment text stays in the tracker; the event records only that there was one.
          if (note !== undefined) steps.push(['POST', `/tasks/${id}/comments`, { comment: note }, null]);
          return {
            steps,
            expect: (f) => ({ ...f, bucket: to, percent_done: pct ?? f.percent_done }),
            event: {
              kind: 'task.state',
              body: {
                role,
                state: view.titles[to],
                previous: view.titles[fields.bucket] ?? null,
                percent_done: pct ?? fields.percent_done,
                comment: note !== undefined,
              },
            },
          };
        };
        return plan;
      }
      case 'task.close': {
        keys(args, [...common, 'verdict'], ['task_ref', 'verdict']);
        // A review.verdict event id. On a task with a recorded push the broker checks it
        // (row 93); on any other task it is a citation, recorded and not checked.
        const verdict = text(args.verdict, 256, 1);
        plan.check = (_before, { id, project, view }) => ({
          steps: [
            [
              'PUT',
              `/projects/${project}/views/${view.id}/buckets/${view.done}/tasks`,
              { task_id: id },
              (a) => a.task.done && a.bucket === view.done,
            ],
          ],
          expect: (f) => ({ ...f, done: true, bucket: view.done }),
          event: { kind: 'task.closed', body: { verdict } },
        });
        return plan;
      }
      default:
        fail('unknown-verb');
    }
  }
  async function recoverableCreate(cap, me, plan) {
    // Reservation is durable before even a relation's compare-read. A kill anywhere beyond this
    // point can only reconcile, including a kill before the POST actually left the process.
    const prepared = {
      op: plan.op, request: plan.request, requirement: plan.requirement, decision: plan.decision,
      project: plan.at.project, view: plan.at.view, creator: ctx.roles[me.role].botId,
      body: plan.body, body_digest: createDigest(plan.body), labels: plan.labels, relations: plan.relations,
      evidence: plan.evidence,
      ...(plan.project_key === undefined ? {} : { project_key: plan.project_key }),
      ...(plan.requirement_snapshot === undefined ? {} : { requirement_snapshot: plan.requirement_snapshot }),
    };
    const { receipt, fresh } = ctx.broker.prepareTaskCreate(cap, prepared);
    let taskRef;
    if (fresh) {
      await located(plan.others);
      await admit(cap, plan);
      ctx.broker.prepareTaskCreate(cap, prepared);
      const r = await ctx.as(me, 'POST', `/projects/${plan.at.project}/tasks`, { body: plan.body });
      if (outcome(r) !== 'ok' || ![200, 201].includes(r.status)) {
        ctx.broker.recordCreateWait({ receipt, code: 'task-create-uncertain' });
        fail('task-create-uncertain');
      }
      try {
        checkTask(r.json);
        taskRef = ref(plan.at.project, r.json.id);
        const fields = taskFields(r.json, plan.at.view.todo);
        ctx.broker.recordRecoveredCreate({ receipt, task_ref: taskRef, snapshot: {
          task_ref: taskRef, fields, digest: digest(fields), updated: normal(r.json.updated), etag: null, creator: r.json.created_by?.id,
        } });
      } catch {
        ctx.broker.recordCreateWait({ receipt, code: 'task-create-uncertain' });
        fail('task-create-uncertain');
      }
    } else {
      const result = await reconcileCreate({ ctx, receipt });
      if (result.state !== 'committed') fail(result.code);
      taskRef = result.task_ref;
    }
    const at = target(taskRef);
    let after = await read(at);
    // The read side may recover a closed task; only an acting PM can finish writes on an open one.
    if (!after.task.done) {
      await located(plan.others);
      for (const l of plan.labels) if (!after.fields.labels.includes(l)) {
        await admit(cap, plan);
        ctx.broker.prepareTaskCreate(cap, prepared);
        await step(me, 'POST', `/tasks/${at.id}/labels`, { label_id: l }, at, a => a.fields.labels.includes(l));
        after = await read(at);
      }
      for (const x of plan.relations) if (!relatedTo(after.task, x.kind, x.other)) {
        await admit(cap, plan);
        ctx.broker.prepareTaskCreate(cap, prepared);
        await step(me, 'POST', `/tasks/${at.id}/relations`, { other_task_id: x.other, relation_kind: x.kind }, at,
          a => relatedTo(a.task, x.kind, x.other));
        after = await read(at);
      }
    }
    ctx.broker.recordTask({ cap, business: ctx.business, snapshots: [{
      task_ref: taskRef, fields: after.fields, digest: after.digest, updated: after.updated, etag: after.etag,
    }] });
    return { task_ref: taskRef, digest: after.digest, updated: after.updated };
  }
  async function admit(cap, plan) {
    // Refresh tracker membership and installation after planning; a cached tree cannot admit a
    // reparented/archived board. Reservation already precedes these reads on the recovery path.
    const boardProject = ctx.broker.taskCreateTarget(cap, scopeArgs(plan));
    if (ctx.descendants) await discover(ctx);
    installed(boardProject);
    const control = await ctx.sync('GET', `/projects/${boardProject}`);
    if (outcome(control) !== 'ok') fail(refusal(control));
    if (control.json?.id !== boardProject || control.json?.is_archived !== false) fail('task-project');
    const liveView = await inspect(ctx, boardProject);
    if (createDigest(liveView) !== createDigest(plan.at.view)) fail('project-not-installed');
    // The catalog and session are the last slow check before the PM's authority admission.
    const snapshot = await ctx.broker.requirementsFor(cap, scopeArgs(plan));
    const project = ctx.broker.taskCreateTarget(cap, scopeArgs(plan));
    const view = installed(project);
    if (createDigest(snapshot) !== createDigest(plan.catalog) || project !== plan.at.project || createDigest(view) !== createDigest(plan.at.view)) fail('requirement-snapshot-refused');
    ctx.broker.identity(cap);
  }
  async function create(cap, me, plan) {
    const project = ctx.broker.taskCreateTarget(cap, scopeArgs(plan));
    plan.at = { project, view: installed(project) };
    plan.catalog = await ctx.broker.requirementsFor(cap, scopeArgs(plan));
    const snap = plan.catalog;
    plan.evidence = { scope: { project_key: snap.project, requirement_snapshot: snap.id, requirement: plan.requirement },
      prd_version: snap.prd_version ?? snap.version,
      ...(snap.origin === 'product' ? { records_commit: snap.records_commit, spec_commit: snap.spec_commit } : { prd: snap.prd, catalog_sha256: snap.catalog_sha256 }) };
    if (plan.op !== undefined) plan.body.description = (plan.body.description ? plan.body.description + '\n\n' : '') + createMarker(plan);
    if (plan.op !== undefined) return recoverableCreate(cap, me, plan);
    await located(plan.others);
    await admit(cap, plan);
    ctx.broker.authorize(cap, 'task.create', { decision: plan.decision, target: null });
    // No re-read can find a create whose answer was lost, so an uncertain create is reported as such.
    const r = await step(me, 'POST', `/projects/${plan.at.project}/tasks`, plan.body, null, null);
    if (r.status !== 201 && r.status !== 200) fail('tracker-unexpected');
    checkTask(r.json);
    const id = r.json.id;
    const at = { ...plan.at, id };
    const taskRef = ref(at.project, id);
    let failure = null;
    try {
      for (const l of plan.labels)
        await step(me, 'POST', `/tasks/${id}/labels`, { label_id: l }, at, (a) => a.fields.labels.includes(l));
      for (const x of plan.relations)
        await step(me, 'POST', `/tasks/${id}/relations`, { other_task_id: x.other, relation_kind: x.kind }, at, (a) =>
          relatedTo(a.task, x.kind, x.other),
        );
    } catch (e) {
      failure = e instanceof BusError ? e : new BusError('adapter-failed');
    }
    let after = null;
    try {
      after = await read(at);
    } catch {
      // handled below, as in handle()
    }
    // Every write landed but the final read failed: the create's answer plus the labels written, in
    // the default bucket. A refusal here would read as "nothing happened" and invite a second create.
    if (!after && !failure) {
      const fields = { ...taskFields(r.json, at.view.ids.todo), labels: sorted(plan.labels) };
      after = { fields, digest: digest(fields), etag: null, updated: normal(r.json.updated) };
    }
    // task.created is recorded even when a later label or relation write failed: the task exists.
    ctx.broker.recordTask({
      cap,
      business: ctx.business,
      snapshots: after
        ? [{ task_ref: taskRef, updated: after.updated, etag: after.etag ?? null, digest: after.digest, fields: after.fields }]
        : [],
      events: [{ kind: 'task.created', subject: taskRef, body: { request: plan.request, requirement: plan.requirement, ...plan.evidence } }],
    });
    if (failure) throw failure;
    return { task_ref: taskRef, digest: after.digest, updated: after.updated };
  }
}