From 9c018ed8bdd3c0f408576dff14aa02568ab256ae Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 03:35:19 +0000 Subject: [PATCH 1/4] spec(FIX-2080): a task's filing settings and lifecycle Start, session, result and attempts as fields of the task; one open task per session; dependencies within one board; two cascades on every board, owed with the ending; held replaces blocked and the recorded mark; the epic's one read map for retired row shapes. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01VaN4uTiYqiabCbsFLWM52A --- specs/issues/FIX-2080/DECISIONS.md | 108 ++++++++++++ specs/issues/FIX-2080/SPEC.md | 155 ++++++++++++++++++ specs/issues/FIX-2080/figures/d1-one-held.svg | 105 ++++++++++++ .../FIX-2080/figures/d2-cascade-debt.svg | 105 ++++++++++++ .../issues/FIX-2080/figures/what-changes.svg | 104 ++++++++++++ 5 files changed, 577 insertions(+) create mode 100644 specs/issues/FIX-2080/DECISIONS.md create mode 100644 specs/issues/FIX-2080/SPEC.md create mode 100644 specs/issues/FIX-2080/figures/d1-one-held.svg create mode 100644 specs/issues/FIX-2080/figures/d2-cascade-debt.svg create mode 100644 specs/issues/FIX-2080/figures/what-changes.svg diff --git a/specs/issues/FIX-2080/DECISIONS.md b/specs/issues/FIX-2080/DECISIONS.md new file mode 100644 index 0000000000..2aa4d39285 --- /dev/null +++ b/specs/issues/FIX-2080/DECISIONS.md @@ -0,0 +1,108 @@ +# FIX-2080 · Decisions + +[Spec](SPEC.md) · **Decisions** + +The concept fixed the four settings and both cascades (rules 4, 5, 6, 16); these two carry them +out. + +## The tree + +```mermaid +flowchart TD + I["FIX-2080"] --> D1["D1 · one status, held, for not started"] + D1 -.->|"rejected"| X1["held beside blocked and the recorded mark · three words for one state"] + I --> D2["D2 · a cascade is a debt recorded with the ending"] + D2 -.->|"rejected"| X2["cancel after the ending, as the split does · a crash loses it"] +``` + +Solid edges are what you're signing. Dashed edges lost, and the label says why. + + +## D1 · One status, `held`, replaces `blocked` and recorded-not-started + +| | | +|---|---| +| **Instead of** | Adding `held` beside `blocked` and the recorded-not-started mark, and leaving each to its own tool | +| **Because** | All three mean "filed, not started, until someone says go". `blocked` has no way out (`unblock` has no caller), and the recorded mark is released only by `dispatchTask`, which FIX-2081 removes. Three words for one state is the incoherence the concept retires; one status is what a screen and a filter can show | +| **Locks in** | The status `held`, the collection verbs `hold` and `release`, and change kinds `held` and `released`, all public. `blocked`, `block`, `unblock` and `blockTask` are removed outright ([(e)](../../epics/FIX-2056/DECISIONS.md#e)); the board's `counts.blocked` becomes `counts.held`. On a Workforce board, `addTask` files held and `dispatchTask { taskId }` releases, until FIX-2081. Rows of both old shapes in a store read as `held` through the map, entries turned on here | + +![D1: one status for not started. Held replaces blocked and the recorded mark, chosen, beside held added beside them. Decides it: a screen listing work that has not started. The price: apps outside reading blocked rewrite at upgrade](figures/d1-one-held.svg) + +It comes down to a screen of unstarted work: one word, or three that mean the same. + +**What would change my mind:** a filer that must tell "held by me" from another not-started reason +it can act on. Held on questions is FIX-2058's, and the concept makes it pending, so it is not one. + + +## D2 · A cascade is a debt recorded with the ending, paid within seconds + +| | | +|---|---| +| **Instead of** | Cancelling after the ending write, best effort, as the split's piece cancel does today | +| **Because** | A task's filed work sits on another board in another session, so no one write can end both. Recorded in the ending's own write (the ledger's ending recorder already lands debts that way), a crash between the two leaves the cascade owed, and rule 8 says every debt is paid | +| **Locks in** | One more debt kind: the gate pays it in-process when the task's own session failed or retried, a dispatch into that session pays a cancel from above, and every touch resends it; FIX-2078's sweeper pays it when due. A cascaded cancel records its cause, the task whose ending caused it, server-written, so FIX-2078 can name a failure's dependents in one notice. Dependents on the same board are cancelled right after the ending, with the claim pass as the backstop, so they need no debt | + +![D2: how a task's filed work is cancelled. A debt recorded with the ending, chosen, beside cancelling after it. Decides it: a crash between the ending and the cancel. The price: a few seconds in which the filed work still runs](figures/d2-cascade-debt.svg) + +It comes down to a crash between the two writes: owed, it is paid on restart; best effort, the work runs on. + +**What would change my mind:** a task and the tasks it filed kept in one store write. Then the +cancel lands in the ending's write, and no debt is needed. + +## Decided, not asked + +- **The settings are fields of the task row, in orchestration.** `held` (start, beside `deps`), + `session` (`"new"` default or `"ongoing"`; a follow-up stays `followUpOf`), `resultTo` (`"filer"` + default or `"conversation"`) and `maxAttempts`. Top level and server-written, never in + `metadata`, since they decide routing (BP-031); absent reads as the default (BP-030). FIX-2081 + names them on `createTask`. A board refuses at filing a value it can't honour, naming the + setting: a plain board takes only the defaults; Workforce's takes `ongoing` and `conversation` + only from a conversation, never from a task's session. +- **Editable until start, by one guard.** `held`, `deps` and `maxAttempts` may change while the row + is pending or held; `session`, `resultTo` and `followUpOf` never change (ER-4). The guard is in the + collection's patch, so FIX-2081's `updateTask` inherits it. +- **The convergence points** (tenet 5). *A dependency on this board:* the collection's add and + patch, on both backings, so `addTask`, `addTasks`, seeded `initialTasks`, replans and the Workforce + add all pass it; ids in the same batch count. A dependency already failed or cancelled is refused + too. *One open task per session:* the Workforce board's one start test, read by every start path. + Its key is the session the row runs in: the task's own, its root's for a follow-up, the delegate's + ongoing one; a started, unfinished row holds it, plan rows never. *Cascades:* the ending detection + every write goes through (`endingOf`), for `errored`, `cancelled` and `retried`, whoever wrote it: + the gate, a cancel, a refused hand-over, an abandoned row's settle. +- **The cascade reaches every board Workforce keeps for the task's session**: its delegation board + and FIX-2076's plan board. Those are the only boards a task's session files on in the repo. +- **Dependents keep the `skipped` label** a pattern's output reads, so plan-and-execute and + supervisor outputs don't change when their step goes. +- **The map.** One function at the read boundary, beside the `parked` and `wait` migrations, with a + switch per entry and one test per shape. Five entries: blocked to held and recorded to held, + turned on here; a post to a routed task (FIX-2083), a parked split to running (FIX-2077) and a + reopened row to pending (FIX-2086), built here, turned on by their owners. The epic's D3 named + four: the recorded mark is the fifth, because D1 retires it here. FIX-2077's entry needs the hold + field FIX-2077 adds, so it adds that field to this entry, in this map. Removed no earlier than + FIX-2071. +- **A wait on a conversation-result task is refused on today's wait**, so T-32 holds now; it moves + with the wait to `getTask` (FIX-2082). +- **No POC and no checker.** The premises are read from code (the gaps file's rows, re-read at + `96404d25`), and no claim here rests on a count. + +## Considered and dropped + +| Option | Why it lost | +|---|---| +| Keep `createCascadeSkipDependents` and wire it on Workforce's board | Two routes to one job, and every new board would have to remember the step (tenet 3) | +| Settings in Workforce state only | A plain orchestration board would accept a session it can't honour, silently | +| Keep refusing a follow-up into a busy session | Rule 5 is the owner's: another stays pending | +| File a dependent of a dead dependency, then cancel it | A filing that ends at once tells the filer less than a refusal | +| Leave the recorded mark to FIX-2081 | Two not-started states for one more merge, and a sixth map shape later | + +## Settled + +None yet. + +## How it got here + +- **Draft** — framed as the epic's ER-4 and ER-6: the settings stored on the row, readiness that + holds a busy session, two cascades refined from the pattern step and the split cancel, and the + epic's one read map, with the recorded mark folded into `held`. + +Open: none. diff --git a/specs/issues/FIX-2080/SPEC.md b/specs/issues/FIX-2080/SPEC.md new file mode 100644 index 0000000000..9a688c1a0f --- /dev/null +++ b/specs/issues/FIX-2080/SPEC.md @@ -0,0 +1,155 @@ +# FIX-2080 · A task's filing settings and lifecycle: start, session, result and attempts; order and cascade + +**Spec** · [Decisions](DECISIONS.md) + +## Six people, before and after + +| Someone who… | Today | After | +|---|---|---| +| **files a follow-up to a worker that is still busy** | Is refused, and has to try again later | The follow-up waits, then starts in that session when the open task ends | +| **files a task that must wait until they say go** | Moves it to *blocked*, and nothing ever unblocks it | Files it *held*; it starts when they release it, and not before | +| **names a dependency on another board** | The task stays pending for good | The filing is refused, naming the rule: cross boards with a wait or a held task | +| **has a dependency fail or get cancelled** | The dependent waits for good, unless a pattern wired a cleanup step | The dependent is cancelled, and so are its own dependents | +| **cancels, retries or fails a task that filed work** | The filed work keeps running, unless the task was a split | Every open task it filed is cancelled within seconds, after a restart too ([D2](DECISIONS.md#d2)) | +| **wants a flaky task tried more often** | Gets 2 tries; a post gets 1 | Sets the attempts at filing; the default stays 2 | + +## The goal, and how we'll know it's met + +**A delegated task runs where, when and how often its filer chose at filing, and nothing waits on +work that will never finish: no row stays pending for good, no filed task outlives the task that +filed it, and no busy session refuses a task.** + +| Is it the right goal? | | +|---|---| +| **The real need** | *"Work runs in the order it needs, and nothing waits on work that will never finish"* (the issue). The epic's [ER-4](../../epics/FIX-2056/DECISIONS.md#who-owns-what) and [ER-6](../../epics/FIX-2056/DECISIONS.md#who-owns-what), owned here | +| **Smaller, and rejected** | "Add the four settings." Settings alone leave a dependent of a failed task, and a filed task under a cancelled one, waiting or running for good, and FIX-2083's routed tasks need both cascades | +| **Bigger, and not this issue's** | The settings on `createTask` and `updateTask` (FIX-2081). Delivering a result to the conversation (FIX-2078, used by FIX-2083). A task held on questions (FIX-2058). Due times and the sweeper (FIX-2078) | +| **Not done if** | A row with a dead or foreign dependency stays pending · a filed task survives its parent's cancel, retry or failure, a restart included · `blocked` or the recorded mark is still written · a retired row is dropped or misread · a cascade needs a step a board wires | + +```mermaid +flowchart LR + A["a real engine · durable store · the Workforce session board · deterministic workers"] --> L1["leg a · start: deps, held, another board"] + A --> L2["leg b · session and result settings"] + A --> L3["leg c · attempts 3"] + A --> L4["leg d · cascades, and a kill before one is paid"] + A --> L5["leg e · retired rows in the store at upgrade"] + L1 --> R["rows read through the collection · the session each request ran in"] + L2 --> R + L3 --> R + L4 --> R + L5 --> R + R -->|"every row ends or runs as filed · none pending for good"| P["PASS · goal met"] + R -.->|"control · cascades off"| F["must FAIL leg d"] +``` + +The check reads stored rows and which session each request ran in, not the board's calls. The +dashed path is the same run with both cascades switched off, and it must fail. + +| How we verify | | +|---|---| +| **Goal check** | `goals/task-board/runs-by-its-filing-settings/` · no model · run by the implementer at completion · verdict in the implementation PR | +| **Signal** | a: a dependent starts after its dependency ends; a held task starts only on release; a dependency on another board is refused, filing nothing. b: a follow-up filed while its task runs waits, then runs in that task's session; an ongoing task runs in the delegate's session for this conversation; from a task's session both conversation settings are refused, as is a wait on a conversation-result task. c: attempts 3 fails after the third failure, each retry in the same session. d: a cancel, a retry and a final failure each cancel the open filed task; a failed and a cancelled dependency each cancel a two-deep chain; killed between a cancel and its cascade, the child is cancelled on the next touch. e: a seeded blocked row and recorded row read as held and start on release; the other entries read as today | +| **Input** | Deterministic workers. Another chain depth, attempt count or kill point must pass too | +| **Anti-game** | No assertions on cascade calls or a stubbed collection: stored rows, and session ids from the request records | +| **Control that must fail** | `GOAL_CONTROL=no-cascade` must FAIL leg d on *the open filed task is cancelled* and *the dependent chain is cancelled*. Today's `main` must also FAIL leg a on *refused and files nothing* and leg b on *the follow-up stays unstarted* | + +## What changes + +![Today against after, for start, session, result, attempts, endings and upgrade: blocked, refusals and opt-in cleanup become held, a waiting session, two cascades on every board and one read map](figures/what-changes.svg) + +The four settings become fields of the task, chosen at filing; two cascades run on every board. + +**A flow that files and orders tasks through the collection:** + +```diff + await tasks.addTask({ + goal: "Chart it", +- deps: ["pull-csv"], // an id from another board waited for good ++ deps: ["pull-csv"], // on this board, or the add is refused ++ held: true, // starts when released + maxAttempts: 3, // the attempts setting; Workforce defaults it to 2 ++ session: "ongoing", // Workforce: the delegate's session for this conversation ++ resultTo: "conversation", // Workforce: from a conversation only + }) +- await tasks.block(id, "waiting on legal") +- await tasks.unblock(id) ++ await tasks.hold(id) // before it starts ++ await tasks.release(id) + const plan = sequencer({ name }) + .then(board.drain) +- .tap(createCascadeSkipDependents({ name })) // every board cancels dependents now +``` + +A model's `blockTask` goes; `updateTask({ status: "held" | "pending" })` holds and releases until +FIX-2081 rewrites the tool list. The other settings reach models with FIX-2081's `createTask`. + +**Docs:** update *Orchestration → Task substrate* (`held`, dependencies, cascades), *Orchestration → +Task board* (the built-in cascade replaces *Cascade-skipping dep-blocked tasks*), *Workforce → +Delegating work* (the settings, one task per session), *Patterns → Supervisor* and *Plan and +execute* (no cascade step), and the orchestration, workforce and patterns READMEs. No new page; +FIX-2081 publishes the shared story. + +## How a filed task runs + +```mermaid +flowchart LR + F["filing · deps on this board · held or now · session · result · attempts"] --> Q{"ready? · start met · no other open task in its session"} + Q -->|"yes"| W["work in the chosen session"] + Q -->|"no"| Q + W -->|"done"| D["ending"] + W -->|"fails · attempts left"| R["retry in the same session"] + W -->|"fails · none left · or cancelled"| D + R --> C["cascade owed · paid in seconds"] + D --> C + C --> K["its open filed tasks cancelled · a failed or cancelled row's dependents cancelled"] +``` + +Each ending records what it owes in the same write, so a crash leaves the cascade owed, not lost. + +## What stays as it is + +- **Patterns.** Plan boards as they stand; a dependent of a failed step still ends `cancelled` with + the `skipped` label their outputs read. +- **Who settles a row.** The claim gate and the drain (ER-1); a cascade's cancel is a cancel, the + same write a user's is. +- **Splits, posts, reopen and `dispatchTask`.** Their children retire them and turn on their map + entries; this issue only builds those entries. +- **How a retry re-enters its session**, and the attempts' default of 2 on Workforce boards. A plain + collection's unset `maxAttempts` still means one try. + +## What's already here, and the debt + +| Already here | What this does with it | +|---|---| +| The job, *end what depends on a dead task*: `createCascadeSkipDependents`, a step two patterns tap after a drain, for `errored` only; the split's piece cancel, the only parent cascade. Closest for each half | **Refines.** The first moves into the collection's ending, for failed and cancelled; the second becomes every task's cascade. The step goes | +| `maxAttempts` on every row: 2 on Workforce boards, 1 for posts | **Builds on.** It is the attempts setting | +| `followUpOf`, the earlier task's session, refused while its session is busy | **Builds on.** The refusal becomes a wait (rule 5) | +| `blocked`, and the recorded-not-started mark `dispatchTask` releases | **Replaced** by one status, `held` ([D1](DECISIONS.md#d1)) | +| The read-boundary migrations for `parked` and `wait` (BP-030) | **Built beside.** The retired-shape map sits at the same boundary | +| The epic's [D3](../../epics/FIX-2056/DECISIONS.md#d3), [ER-4, ER-6](../../epics/FIX-2056/DECISIONS.md#who-owns-what) | **Kept**, with a fifth map entry ([decided](DECISIONS.md#decided-not-asked)) | + +| The debt | | +|---|---| +| **Removes** | `blocked`, `block`, `unblock`, `blockTask` · the recorded-not-started mark · `createCascadeSkipDependents` · the busy-session refusal · the split-only cancel cascade · a dependency id that never resolves | +| **Adds** | `held`, `hold` and `release` · the `session` and `resultTo` fields · a cascade debt on the ending · the retired-shape map, removed no earlier than FIX-2071 | +| **Leaves** | A cascade owed after a crash is paid on the next touch until FIX-2078's sweeper pays it on time · the refusal of a wait on a conversation-result task lives on today's wait, and moves with it to `getTask` (FIX-2082) | + +**Net: down.** A status, a mark, a cascade step and a refusal go; one status replaces two, and two +fields arrive. The map is debt by design, with a removal date. + +## Sign off + +**[The goal](#the-goal-and-how-well-know-its-met), at that size:** every task runs as filed, and +nothing waits or runs for good. If wrong: FIX-2083's routed tasks orphan their work. + +**[The debt](#whats-already-here-and-the-debt), net down:** two not-started states become one, +and one cascade replaces two partial ones. If wrong: two fields only Workforce reads. + +1. **[D1](DECISIONS.md#d1) · One status, `held`, replaces `blocked` and recorded-not-started.** + If wrong: apps outside the repo reading `blocked` rewrite at upgrade for nothing. +2. **[D2](DECISIONS.md#d2) · A cascade is a debt recorded with the ending, paid within seconds.** + If wrong: for a few seconds a cancelled task's filed work still spends. + +**Open: none.** Number 1 is the one to weigh: it changes a status screens show. + +Feature · `orchestration` + `workforce` + `patterns` · large · epic [FIX-2056](../../epics/FIX-2056/SPEC.md) diff --git a/specs/issues/FIX-2080/figures/d1-one-held.svg b/specs/issues/FIX-2080/figures/d1-one-held.svg new file mode 100644 index 0000000000..b5b63a5820 --- /dev/null +++ b/specs/issues/FIX-2080/figures/d1-one-held.svg @@ -0,0 +1,105 @@ + + + + + + + D1 · THE CALL + What is a filed task that has not started yet called? + + + + + CHOSEN + One status: held + + INSTEAD OF + Held beside blocked and recorded + + + + + + A SCREEN OF + UNSTARTED WORK + ▸ DECIDES IT + + + One word, one way out + release starts it + − + Three words for one state + and blocked has no way out + + + + APPS OUTSIDE + READING BLOCKED + − + Rewrite at upgrade + one migration line + + + Nothing breaks + the old names stay + + + + + ROWS IN A + STORE AT UPGRADE + − + Two map entries + both read as held + + + No map entry + the old marks stay written + + + + + + LOCKS IN + Public held, hold and release + blocked, block, unblock and blockTask go outright + + + + + FLIPS IF + A filer needs a second not-started reason + one it acts on, apart from its own hold + + diff --git a/specs/issues/FIX-2080/figures/d2-cascade-debt.svg b/specs/issues/FIX-2080/figures/d2-cascade-debt.svg new file mode 100644 index 0000000000..085b5564f7 --- /dev/null +++ b/specs/issues/FIX-2080/figures/d2-cascade-debt.svg @@ -0,0 +1,105 @@ + + + + + + + D2 · THE CALL + When a task ends, how are the tasks it filed cancelled? + + + + + CHOSEN + A debt with the ending + + INSTEAD OF + Cancel after it, best effort + + + + + + A CRASH BETWEEN + ENDING AND CANCEL + ▸ DECIDES IT + + + Owed, paid on restart + the ending's write recorded it + − + Filed work runs for good + nothing remembers it was owed + + + + THE WINDOW + BEFORE THE CANCEL + − + A few seconds of spend + paid by a dispatch or a touch + + + Usually instant + when nothing crashes + + + + + WHAT THE BOARD + KEEPS + − + One more debt kind + the sweeper pays it when due + + + Nothing new + the split cancel, widened + + + + + + LOCKS IN + A cascade debt, and its cause + each cascaded cancel names the task that caused it + + + + + FLIPS IF + A task and its filed tasks share one write + then the cancel lands in the ending itself + + diff --git a/specs/issues/FIX-2080/figures/what-changes.svg b/specs/issues/FIX-2080/figures/what-changes.svg new file mode 100644 index 0000000000..bee7834d5e --- /dev/null +++ b/specs/issues/FIX-2080/figures/what-changes.svg @@ -0,0 +1,104 @@ + + + + + + TODAY + AFTER + + + + START + + Now, deps, or blocked or recorded + blocked has no way out + + Now, deps on this board, or held + release starts it; a foreign dep is refused + + + + SESSION + + New, or a follow-up once it ends + a busy session refuses the follow-up + + New, ongoing, or a follow-up + a busy session holds the next one pending + + + + RESULT + + The filer; a post, the conversation + a row kind of its own + + The filer, or the conversation + a setting, from a conversation only + + + + ATTEMPTS + + Fixed: 2 for a task, 1 for a post + no choice at filing + + maxAttempts at filing + default 2; editable until it starts + + + + ENDINGS + + A split's cancel; a pattern's step + the rest wait or run for good + + Two cascades, on every board + filed tasks and dependents, owed until paid + + + + AT UPGRADE + + Old rows read as written + nothing to read the retired shapes + + One map at the read boundary + five entries, each turned on by its owner + + + From 19e2e347a80ed77b73c958d5152cc3692930e5b2 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Oct 2026 04:05:13 +0000 Subject: [PATCH 2/4] spec(FIX-2080): round 1, cascade debt on FIX-2078's wake; loops and started rows refused D2's payment now rides FIX-2078's wake: one cascade debt covering filed tasks and same-board dependents, recorded by orchestration's own recorder on both backings, due at write + 2 s, paid by a touch only until the wake lands. FIX-2078 now waits on FIX-2080 (epic table and graph amended). Edits are refused once a row has started; dependency loops are refused. held/hold boundary with FIX-2077 stated; epic D3 amended to five shapes; seam row and migration rows corrected. Below-the-bar feedback recorded in DECISIONS.md -> Notes from review. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01VaN4uTiYqiabCbsFLWM52A --- specs/epics/FIX-2056/DECISIONS.md | 6 +-- specs/epics/FIX-2056/SPEC.md | 7 +-- specs/epics/FIX-2056/migration.md | 8 ++++ specs/issues/FIX-2080/DECISIONS.md | 45 ++++++++++++++----- specs/issues/FIX-2080/SPEC.md | 20 +++++---- .../FIX-2080/figures/d2-cascade-debt.svg | 6 +-- 6 files changed, 64 insertions(+), 28 deletions(-) diff --git a/specs/epics/FIX-2056/DECISIONS.md b/specs/epics/FIX-2056/DECISIONS.md index e9ddb47c34..17e458d200 100644 --- a/specs/epics/FIX-2056/DECISIONS.md +++ b/specs/epics/FIX-2056/DECISIONS.md @@ -60,7 +60,7 @@ It comes down to the cycle: a child blocked by FIX-2058 would keep this epic fro |---|---| | **Instead of** | Extending the durable keys' accepted cost (no second spelling read) to the task rows this epic retires | | **Because** | BP-030. The rows are a user's open work in a persistent store; dropping them loses work a person filed. The durable keys are replay detail the owner accepted losing | -| **Locks in** | One map in the collection layer, built and tested by FIX-2080 for all four shapes: a post to a routed task, blocked to held, a parked split to running, a reopened row to pending. FIX-2077, FIX-2083 and FIX-2086 each turn their shape's entry on in the PR that stops writing it, and build no read of their own. The map is removed no earlier than FIX-2071 | +| **Locks in** | One map in the collection layer, built and tested by FIX-2080 for all five shapes: a post to a routed task, blocked to held, the recorded-not-started mark to held, a parked split to running, a reopened row to pending. FIX-2077, FIX-2083 and FIX-2086 each turn their shape's entry on in the PR that stops writing it, and build no read of their own. The map is removed no earlier than FIX-2071 | **What would change my mind:** no persistent store outside tests and local dev databases holds these rows. Then the map is dead code, and the durable keys' rule covers rows too. @@ -89,10 +89,10 @@ FIX-2081's own scope. | Seam | Owner, then who else touches it | |---|---| -| The task tool list (`orchestration/src/skills/task-tools-capability.ts`) | FIX-2081 owns the list and field rules. FIX-2080's settings, FIX-2082's wait and FIX-2086's `message` land after it | +| The task tool list (`orchestration/src/skills/task-tools-capability.ts`) | FIX-2080 lands first: it removes `blockTask`, turns the busy-session refusal into a wait and adds `held` to the status filter. Then FIX-2081 owns the list and field rules, and FIX-2082's wait and FIX-2086's `message` land after it | | The claim gate (`task-board/task-entry.ts`, `blocks/record-result.ts`) and the request's end | FIX-2077 owns the predicate and where it runs: the request's `onFinished`, run after background work drains on every terminal path (`engine/src/execution/runAction.ts:2447`→`:2630`, `:2773`→`:2918`). No engine hook needed. FIX-2082's waits wake on its ending; FIX-2078 calls it when a filed task ends | | The wait (`tasks/helpers/wait-for-response.ts`) and its limits | FIX-2082 owns it and its limits: 5 waits deep; a tree 5 deep, 100 under its top task. FIX-2076 only sets which boards wait. A board's dispatch rides the row's wait. A bare `dispatcher({ wait: true })` has no row, and the engine awaits acceptance only (`core/src/blocks/dispatcher.ts:169-171`, `engine/src/context/dispatch-operation.ts:273-280`): FIX-2082 adds an engine wait that returns the result | -| The sweeper (`engine/src/durability/durability-sweeper.ts:40-50`), re-armed only from wait gates | FIX-2078 adds a due-time source the re-arm reads and a step that pays board debts | +| The sweeper (`engine/src/durability/durability-sweeper.ts:40-50`), re-armed only from wait gates | FIX-2078 adds a due-time source the re-arm reads and a step that pays board debts, FIX-2080's cascade debt among them | | `afterRun`, the notice and `runTaskBoard` (`workforce/src/conversation-board/board.ts`) | FIX-2078 moves the notice, replaces resends with due times, removes the `reportOwed` marker and keeps Shift Manager's error route on the ending path ([f](#f)); FIX-2077 removes the split settle; FIX-2084 renames the entry `dispatch` | | The collection read (`tasks/collection/`) | FIX-2080 owns the map; the retiring children turn entries on | | Queued messages | FIX-2077 runs them through today's message entry; FIX-2070 makes it `receive` | diff --git a/specs/epics/FIX-2056/SPEC.md b/specs/epics/FIX-2056/SPEC.md index 248f1eb691..bfd0a0b6e7 100644 --- a/specs/epics/FIX-2056/SPEC.md +++ b/specs/epics/FIX-2056/SPEC.md @@ -70,7 +70,7 @@ The reviewed snapshot; live state, and each issue's gap rows, are in Linear. |---|---|---| | [FIX-2076](https://linear.app/fixpoint-labs/issue/FIX-2076) · board modes | Plan and delegation boards; wrong boards refused | — | | [FIX-2077](https://linear.app/fixpoint-labs/issue/FIX-2077) · when a task is done | Rule 6 at the claim gate, after background work; a wait leaves a task running | FIX-2080 | -| [FIX-2078](https://linear.app/fixpoint-labs/issue/FIX-2078) · endings and debts | Every ending to its filer once; due times and the sweeper | — | +| [FIX-2078](https://linear.app/fixpoint-labs/issue/FIX-2078) · endings and debts | Every ending to its filer once; due times and the sweeper | FIX-2080 | | [FIX-2080](https://linear.app/fixpoint-labs/issue/FIX-2080) · filing settings | Start, session, result, attempts; cascades; the one read for retired rows ([D3](DECISIONS.md#d3)) | — | | [FIX-2081](https://linear.app/fixpoint-labs/issue/FIX-2081) · four tools | Four task tools, one rule per field; delegates as authority | FIX-2080 | | [FIX-2082](https://linear.app/fixpoint-labs/issue/FIX-2082) · waits | `getTask` and the waited dispatch as one wait; 5 deep, 100 under a top task | FIX-2076, FIX-2077, FIX-2081 | @@ -98,13 +98,14 @@ flowchart LR T -->|"updateTask"| S T -->|"createTask, delegates"| R["FIX-2083 · routed tasks"] L -->|"session, result, attempts"| R - E["FIX-2078 · endings and debts"] -->|"result to the conversation"| R + L -->|"dependents cancelled, with their cause"| E["FIX-2078 · endings and debts"] + E -->|"result to the conversation"| R R -->|"no post entry"| K["FIX-2084 · worker contract"] E -->|"onTaskSettled, dispatch"| K H["FIX-2085 · schedules"] ``` -An edge is what one issue hands the next. FIX-2076, FIX-2078, FIX-2080 and FIX-2085 start at once; +An edge is what one issue hands the next. FIX-2076, FIX-2080 and FIX-2085 start at once; every child blocks the closure, left off. The longest chain is four. ## What stays as it is diff --git a/specs/epics/FIX-2056/migration.md b/specs/epics/FIX-2056/migration.md index fc09f560e9..c4c2776634 100644 --- a/specs/epics/FIX-2056/migration.md +++ b/specs/epics/FIX-2056/migration.md @@ -16,6 +16,14 @@ repo rewrite at upgrade. Each tool's `_tasks` action follows its tool. Shi | `cancelTask` | `updateTask({ status: "cancelled" })` | FIX-2081 | | `completeTask`, `failTask` | Return or throw: the claim gate records the ending | FIX-2081 | | `blockTask`, `TaskCollection.block`, `unblock` | `updateTask({ status: "held" })` and `"pending"` before it starts; `waitForUser` after | FIX-2080 | +| The `"blocked"` task status, and `"blocked"` in `listTasks`' status filter | `"held"` | FIX-2080 | +| `Task.undispatched`, `TaskInit.undispatched` | `held` | FIX-2080 | +| Change kinds `blocked`, `unblocked` | `held`, `released` | FIX-2080 | +| The board's `counts.blocked` | `counts.held` | FIX-2080 | +| `createCascadeSkipDependents` | Nothing: every board cancels a failed or cancelled row's dependents | FIX-2080 | +| A follow-up into a busy session being refused | Nothing: it waits, then starts in that session when the open task ends | FIX-2080 | +| A dependency on another board, waiting for good | Refused at filing: cross boards with a wait or a held task | FIX-2080 | +| Plan-and-execute and supervisor cascading only a failed step | A cancelled step's dependents are cancelled too, with the same `skipped` label | FIX-2080 | | `TaskCollection.reopen` | A follow-up: `createTask` in the task's session | FIX-2086 | | `DELEGATED_POST_ENTRY` | A routed task through `WORKER_TASK_ENTRY` | FIX-2083 | | `settleSplitTask` | Nothing: the claim gate settles a split when its pieces end | FIX-2077 | diff --git a/specs/issues/FIX-2080/DECISIONS.md b/specs/issues/FIX-2080/DECISIONS.md index 2aa4d39285..b9bd84ec6d 100644 --- a/specs/issues/FIX-2080/DECISIONS.md +++ b/specs/issues/FIX-2080/DECISIONS.md @@ -24,7 +24,7 @@ Solid edges are what you're signing. Dashed edges lost, and the label says why. |---|---| | **Instead of** | Adding `held` beside `blocked` and the recorded-not-started mark, and leaving each to its own tool | | **Because** | All three mean "filed, not started, until someone says go". `blocked` has no way out (`unblock` has no caller), and the recorded mark is released only by `dispatchTask`, which FIX-2081 removes. Three words for one state is the incoherence the concept retires; one status is what a screen and a filter can show | -| **Locks in** | The status `held`, the collection verbs `hold` and `release`, and change kinds `held` and `released`, all public. `blocked`, `block`, `unblock` and `blockTask` are removed outright ([(e)](../../epics/FIX-2056/DECISIONS.md#e)); the board's `counts.blocked` becomes `counts.held`. On a Workforce board, `addTask` files held and `dispatchTask { taskId }` releases, until FIX-2081. Rows of both old shapes in a store read as `held` through the map, entries turned on here | +| **Locks in** | The status `held`, the collection verbs `hold` and `release`, and change kinds `held` and `released`, all public. `blocked`, `block`, `unblock` and `blockTask` are removed outright ([(e)](../../epics/FIX-2056/DECISIONS.md#e)); the board's `counts.blocked` becomes `counts.held`. On a Workforce board, `addTask` files held and `dispatchTask { taskId }` releases, until `dispatchTask` goes (FIX-2082, FIX-2083). Rows of both old shapes in a store read as `held` through the map, entries turned on here | ![D1: one status for not started. Held replaces blocked and the recorded mark, chosen, beside held added beside them. Decides it: a screen listing work that has not started. The price: apps outside reading blocked rewrite at upgrade](figures/d1-one-held.svg) @@ -39,12 +39,12 @@ it can act on. Held on questions is FIX-2058's, and the concept makes it pending | | | |---|---| | **Instead of** | Cancelling after the ending write, best effort, as the split's piece cancel does today | -| **Because** | A task's filed work sits on another board in another session, so no one write can end both. Recorded in the ending's own write (the ledger's ending recorder already lands debts that way), a crash between the two leaves the cascade owed, and rule 8 says every debt is paid | -| **Locks in** | One more debt kind: the gate pays it in-process when the task's own session failed or retried, a dispatch into that session pays a cancel from above, and every touch resends it; FIX-2078's sweeper pays it when due. A cascaded cancel records its cause, the task whose ending caused it, server-written, so FIX-2078 can name a failure's dependents in one notice. Dependents on the same board are cancelled right after the ending, with the claim pass as the backstop, so they need no debt | +| **Because** | A task's filed work sits on another board in another session, and even a same-board dependent is a second row write, so no one write can end both. Recorded in the ending's own write (orchestration's ending recorder already lands the resume debt that way, on both backings), a crash between the two leaves the cascade owed, and rule 8 says every debt is paid | +| **Locks in** | One more debt kind, *a cascade owed*, covering both cascades: the task's open filed tasks and a failed or cancelled row's dependents. The ending's own pass pays it at once. It is due at the write + 2 s, one of FIX-2078's debts: FIX-2078 gives it a wake, written before the ending, naming the task's session and its board run. A touch pays it only once past due, and only until that wake lands, so this issue lands before FIX-2078. A cascaded cancel records its cause, the task whose ending caused it, server-written, so FIX-2078 can name a failure's dependents in one notice | ![D2: how a task's filed work is cancelled. A debt recorded with the ending, chosen, beside cancelling after it. Decides it: a crash between the ending and the cancel. The price: a few seconds in which the filed work still runs](figures/d2-cascade-debt.svg) -It comes down to a crash between the two writes: owed, it is paid on restart; best effort, the work runs on. +It comes down to a crash between the two writes: owed, it is paid once due; best effort, the work runs on. **What would change my mind:** a task and the tasks it filed kept in one store write. Then the cancel lands in the ending's write, and no debt is needed. @@ -59,27 +59,35 @@ cancel lands in the ending's write, and no debt is needed. setting: a plain board takes only the defaults; Workforce's takes `ongoing` and `conversation` only from a conversation, never from a task's session. - **Editable until start, by one guard.** `held`, `deps` and `maxAttempts` may change while the row - is pending or held; `session`, `resultTo` and `followUpOf` never change (ER-4). The guard is in the - collection's patch, so FIX-2081's `updateTask` inherits it. + has never started; a retry's return to pending does not reopen them. `session`, `resultTo` and + `followUpOf` never change (ER-4). The guard is in a new collection patch, the first that edits + `deps`, so FIX-2081's `updateTask` inherits it. - **The convergence points** (tenet 5). *A dependency on this board:* the collection's add and patch, on both backings, so `addTask`, `addTasks`, seeded `initialTasks`, replans and the Workforce add all pass it; ids in the same batch count. A dependency already failed or cancelled is refused - too. *One open task per session:* the Workforce board's one start test, read by every start path. + too, and so is one that closes a loop, within a batch or through a patch. *One open task per session:* the Workforce board's one start test, read by every start path. Its key is the session the row runs in: the task's own, its root's for a follow-up, the delegate's ongoing one; a started, unfinished row holds it, plan rows never. *Cascades:* the ending detection every write goes through (`endingOf`), for `errored`, `cancelled` and `retried`, whoever wrote it: - the gate, a cancel, a refused hand-over, an abandoned row's settle. + the gate, a cancel, a refused hand-over, an abandoned row's settle. A lapsed lease's reclaim + writes no ending and cascades nothing: the re-run in the same session adopts its filed work. - **The cascade reaches every board Workforce keeps for the task's session**: its delegation board and FIX-2076's plan board. Those are the only boards a task's session files on in the repo. + Whichever of FIX-2076 and FIX-2080 lands second wires the plan board in. +- **`held` means before a start, and nothing after.** FIX-2077's field naming what keeps a + running task open is not a form of "hold": FIX-2077 renames it (`waitingOn` proposed), and the + parked-split entry below uses that name. +- **One owner for the split's cascade.** This issue builds the general cascade; FIX-2077 deletes + the split's own piece cancel along with the park it keys on. - **Dependents keep the `skipped` label** a pattern's output reads, so plan-and-execute and supervisor outputs don't change when their step goes. - **The map.** One function at the read boundary, beside the `parked` and `wait` migrations, with a switch per entry and one test per shape. Five entries: blocked to held and recorded to held, turned on here; a post to a routed task (FIX-2083), a parked split to running (FIX-2077) and a reopened row to pending (FIX-2086), built here, turned on by their owners. The epic's D3 named - four: the recorded mark is the fifth, because D1 retires it here. FIX-2077's entry needs the hold - field FIX-2077 adds, so it adds that field to this entry, in this map. Removed no earlier than - FIX-2071. + four; this PR amends it to five: the recorded mark is the fifth, because D1 retires it here, + so FIX-2080 owns that entry and FIX-2081 adds none. FIX-2077's entry needs the running-row field + FIX-2077 adds, so it adds that field to this entry, in this map. Removed no earlier than FIX-2071. - **A wait on a conversation-result task is refused on today's wait**, so T-32 holds now; it moves with the wait to `getTask` (FIX-2082). - **No POC and no checker.** The premises are read from code (the gaps file's rows, re-read at @@ -94,6 +102,8 @@ cancel lands in the ending's write, and no debt is needed. | Keep refusing a follow-up into a busy session | Rule 5 is the owner's: another stays pending | | File a dependent of a dead dependency, then cancel it | A filing that ends at once tells the filer less than a refusal | | Leave the recorded mark to FIX-2081 | Two not-started states for one more merge, and a sixth map shape later | +| A filed task cancels itself when it finds its filer ended (a pull, no debt) | A running child that never touches its board is not reached, and every claim reads another board's row. The debt rides FIX-2078's wake instead | +| Build only the two map entries turned on here | The epic's D3 has this issue build every entry, so no child writes its own read | ## Settled @@ -104,5 +114,18 @@ None yet. - **Draft** — framed as the epic's ER-4 and ER-6: the settings stored on the row, readiness that holds a busy session, two cascades refined from the pattern step and the split cancel, and the epic's one read map, with the recorded mark folded into `held`. +- **Round 1** — D2's payment moved onto FIX-2078's wake: one cascade debt, same-board dependents + included, due at the write + 2 s, paid by a touch only until the wake lands, so FIX-2078 now + waits on this issue. Edits are refused once a row has started, and so are dependency loops. + +## Notes from review + +- Cursor: "convergence must not full-scan the board on every ending" … "cascade work should be **O(direct dependents / filed children)** where possible (index at filing, or one batch pass keyed by ending id), not a full-board scan per failure" ([thread](https://github.com/fixpoint-labs/flow-state-dev/pull/3595#discussion_r4332793395)). +- Cursor: "Session 'one open task' already uses `list().find` for busy detection; rule 5 queues more rows per session." … "reverse-dep index, batch cascade pass, cap `maxAttempts` on Workforce" ([review](https://github.com/fixpoint-labs/flow-state-dev/pull/3595#pullrequestreview-5594683719)). +- Cursor: "a single fold sentence that ER-6 cascades are **in scope here** (not FIX-2081) would help PMs size the implementation PR" ([thread](https://github.com/fixpoint-labs/flow-state-dev/pull/3595#discussion_r4332793392)). +- Second look: "`resultTo` lands with no behaviour except refusals … Consider landing `resultTo` with the work that reads it. ER-4 lists the four settings as one set" ([comment](https://github.com/fixpoint-labs/flow-state-dev/pull/3595#issuecomment-6307421456)). +- Second look: "The spec says Workforce's delegation board and FIX-2076's plan board are the only boards a task's session files on. I did not verify that against the code. … the implementer should confirm it first." +- FSD Architect, fix 8: "Cite: `endingOf` (`orchestration/src/tasks/collection/ending.ts:69-89`); the recorder seam (`internal.ts:1184-1188`); Workforce's start test `isStartable` (`workforce/src/conversation-board/board.ts:216`), where one open task per session lands; the busy refusal (`task-tools-capability.ts:554-607`); the recorded mark's write and release (`internal.ts:268-279`, `:867`; `TaskCollectionRef.dispatch`, `types.ts:866`); the step being removed (`cascade-skip-dependents.ts:43`)" ([comment](https://github.com/fixpoint-labs/flow-state-dev/pull/3595#issuecomment-6307497797)). +- FSD Architect, fix 6: "No collection method edits `deps` today (`collection/types.ts:582-845`). … confirm seeding goes through `addTasks` (`createSeedCollection`, `blocks/seed-collection.ts:36`)." Open: none. diff --git a/specs/issues/FIX-2080/SPEC.md b/specs/issues/FIX-2080/SPEC.md index 9a688c1a0f..13ea751f51 100644 --- a/specs/issues/FIX-2080/SPEC.md +++ b/specs/issues/FIX-2080/SPEC.md @@ -8,9 +8,9 @@ |---|---|---| | **files a follow-up to a worker that is still busy** | Is refused, and has to try again later | The follow-up waits, then starts in that session when the open task ends | | **files a task that must wait until they say go** | Moves it to *blocked*, and nothing ever unblocks it | Files it *held*; it starts when they release it, and not before | -| **names a dependency on another board** | The task stays pending for good | The filing is refused, naming the rule: cross boards with a wait or a held task | +| **names a dependency on another board, or one that loops** | The task stays pending for good | The filing is refused, naming the rule: cross boards with a wait or a held task | | **has a dependency fail or get cancelled** | The dependent waits for good, unless a pattern wired a cleanup step | The dependent is cancelled, and so are its own dependents | -| **cancels, retries or fails a task that filed work** | The filed work keeps running, unless the task was a split | Every open task it filed is cancelled within seconds, after a restart too ([D2](DECISIONS.md#d2)) | +| **cancels, retries or fails a task that filed work** | The filed work keeps running, unless the task was a split | Every open task it filed is cancelled within seconds ([D2](DECISIONS.md#d2)); after a crash, within seconds of its due time once FIX-2078 lands, on the next touch until then | | **wants a flaky task tried more often** | Gets 2 tries; a post gets 1 | Sets the attempts at filing; the default stays 2 | ## The goal, and how we'll know it's met @@ -23,8 +23,8 @@ filed it, and no busy session refuses a task.** |---|---| | **The real need** | *"Work runs in the order it needs, and nothing waits on work that will never finish"* (the issue). The epic's [ER-4](../../epics/FIX-2056/DECISIONS.md#who-owns-what) and [ER-6](../../epics/FIX-2056/DECISIONS.md#who-owns-what), owned here | | **Smaller, and rejected** | "Add the four settings." Settings alone leave a dependent of a failed task, and a filed task under a cancelled one, waiting or running for good, and FIX-2083's routed tasks need both cascades | -| **Bigger, and not this issue's** | The settings on `createTask` and `updateTask` (FIX-2081). Delivering a result to the conversation (FIX-2078, used by FIX-2083). A task held on questions (FIX-2058). Due times and the sweeper (FIX-2078) | -| **Not done if** | A row with a dead or foreign dependency stays pending · a filed task survives its parent's cancel, retry or failure, a restart included · `blocked` or the recorded mark is still written · a retired row is dropped or misread · a cascade needs a step a board wires | +| **Bigger, and not this issue's** | The settings on `createTask` and `updateTask` (FIX-2081). Delivering a result to the conversation (FIX-2078, used by FIX-2083). A task held on questions (FIX-2058). Due times, the sweeper and the wake that pays a cascade on time (FIX-2078) | +| **Not done if** | A row with a dead, foreign or looping dependency stays pending · a started row's settings change · a filed task survives its parent's cancel, retry or failure, a restart included · `blocked` or the recorded mark is still written · a retired row is dropped or misread · a cascade needs a step a board wires | ```mermaid flowchart LR @@ -48,7 +48,7 @@ dashed path is the same run with both cascades switched off, and it must fail. | How we verify | | |---|---| | **Goal check** | `goals/task-board/runs-by-its-filing-settings/` · no model · run by the implementer at completion · verdict in the implementation PR | -| **Signal** | a: a dependent starts after its dependency ends; a held task starts only on release; a dependency on another board is refused, filing nothing. b: a follow-up filed while its task runs waits, then runs in that task's session; an ongoing task runs in the delegate's session for this conversation; from a task's session both conversation settings are refused, as is a wait on a conversation-result task. c: attempts 3 fails after the third failure, each retry in the same session. d: a cancel, a retry and a final failure each cancel the open filed task; a failed and a cancelled dependency each cancel a two-deep chain; killed between a cancel and its cascade, the child is cancelled on the next touch. e: a seeded blocked row and recorded row read as held and start on release; the other entries read as today | +| **Signal** | a: a dependent starts after its dependency ends; a held task starts only on release; a dependency on another board, or one closing a loop, is refused, filing nothing; after a retry, the row's attempts and dependencies refuse an edit. b: a follow-up filed while its task runs waits, then runs in that task's session; an ongoing task runs in the delegate's session for this conversation; from a task's session both conversation settings are refused, as is a wait on a conversation-result task. c: attempts 3 fails after the third failure, each retry in the same session. d: a cancel, a retry and a final failure each cancel the open filed task; a failed and a cancelled dependency each cancel a two-deep chain; killed between an ending and its cascade, the filed child and the dependent are each cancelled on the next touch. e: a seeded blocked row and recorded row read as held and start on release; the other entries read as today | | **Input** | Deterministic workers. Another chain depth, attempt count or kill point must pass too | | **Anti-game** | No assertions on cascade calls or a stubbed collection: stored rows, and session ids from the request records | | **Control that must fail** | `GOAL_CONTROL=no-cascade` must FAIL leg d on *the open filed task is cancelled* and *the dependent chain is cancelled*. Today's `main` must also FAIL leg a on *refused and files nothing* and leg b on *the follow-up stays unstarted* | @@ -99,7 +99,7 @@ flowchart LR W -->|"done"| D["ending"] W -->|"fails · attempts left"| R["retry in the same session"] W -->|"fails · none left · or cancelled"| D - R --> C["cascade owed · paid in seconds"] + R --> C["cascade owed · its pass pays it · due in 2 s"] D --> C C --> K["its open filed tasks cancelled · a failed or cancelled row's dependents cancelled"] ``` @@ -116,6 +116,10 @@ Each ending records what it owes in the same write, so a crash leaves the cascad entries; this issue only builds those entries. - **How a retry re-enters its session**, and the attempts' default of 2 on Workforce boards. A plain collection's unset `maxAttempts` still means one try. +- **A lapsed lease's reclaim** re-pends the row with no ending and cascades nothing: the re-run in + the same session adopts its filed work. +- **The board's quiescence verdict `"blocked"`**, a drain's answer and not a row status, keeps its + name. ## What's already here, and the debt @@ -130,9 +134,9 @@ Each ending records what it owes in the same write, so a crash leaves the cascad | The debt | | |---|---| -| **Removes** | `blocked`, `block`, `unblock`, `blockTask` · the recorded-not-started mark · `createCascadeSkipDependents` · the busy-session refusal · the split-only cancel cascade · a dependency id that never resolves | +| **Removes** | `blocked`, `block`, `unblock`, `blockTask` · the recorded-not-started mark · `createCascadeSkipDependents` · the busy-session refusal · the split-only cancel cascade, whose code FIX-2077 deletes with its park · a dependency id that never resolves. Each public one is a [migration line](../../epics/FIX-2056/migration.md) the implementation changeset carries | | **Adds** | `held`, `hold` and `release` · the `session` and `resultTo` fields · a cascade debt on the ending · the retired-shape map, removed no earlier than FIX-2071 | -| **Leaves** | A cascade owed after a crash is paid on the next touch until FIX-2078's sweeper pays it on time · the refusal of a wait on a conversation-result task lives on today's wait, and moves with it to `getTask` (FIX-2082) | +| **Leaves** | A cascade owed past its due time is paid on the next touch until FIX-2078, which now lands after this issue, pays it on time with its wake · the refusal of a wait on a conversation-result task lives on today's wait, and moves with it to `getTask` (FIX-2082) | **Net: down.** A status, a mark, a cascade step and a refusal go; one status replaces two, and two fields arrive. The map is debt by design, with a removal date. diff --git a/specs/issues/FIX-2080/figures/d2-cascade-debt.svg b/specs/issues/FIX-2080/figures/d2-cascade-debt.svg index 085b5564f7..52aea06489 100644 --- a/specs/issues/FIX-2080/figures/d2-cascade-debt.svg +++ b/specs/issues/FIX-2080/figures/d2-cascade-debt.svg @@ -1,4 +1,4 @@ -