Ship a side-effecting playbook module #153

Closed
opened 2026-10-27 13:35:10 +00:00 by sam · 2 comments
Owner

Goal

At least one module kind (notify a channel, or comment on the forge) runs end to end from a playbook with a visible result.

Evidence

internal/domain/eda/module/ contains only log.

Rules

Read CLAUDE.md. Do only what the Goal and Stop when need. File anything else you notice as a bead; do not fix it. Run task check once at the end; if it fails twice on the same problem, comment on this bead and stop.

Stop when

  • One module kind implemented and documented.
  • A playbook using it runs from a real trigger and its result shows in the run.
    Then commit (Conventional Commits, scoped by package), bd close this bead and stop.

Imported from beads archie-core-bdb5.7 · GitHub #1310 · type feature · priority P2 · created 2026-10-05

## Goal At least one module kind (notify a channel, or comment on the forge) runs end to end from a playbook with a visible result. ## Evidence internal/domain/eda/module/ contains only log. ## Rules Read CLAUDE.md. Do only what the Goal and Stop when need. File anything else you notice as a bead; do not fix it. Run `task check` once at the end; if it fails twice on the same problem, comment on this bead and stop. ## Stop when - [ ] One module kind implemented and documented. - [ ] A playbook using it runs from a real trigger and its result shows in the run. Then commit (Conventional Commits, scoped by package), `bd close` this bead and stop. --- _Imported from beads `archie-core-bdb5.7` · GitHub #1310 · type feature · priority P2 · created 2026-10-05_
sam added the mediumfeature labels 2026-10-27 13:35:10 +00:00
sam self-assigned this 2026-10-27 13:35:10 +00:00
Author
Owner

archie's PRD is ready -- awaiting your go/no-go.

PRD — Ship a side-effecting playbook module (kind: notify)

Read-only mission: nothing was built and no gate was run. Every claim below was read out of the tree; line numbers are from this checkout.

1. Problem

Action playbooks are fully wired but can only do something that has no effect. internal/domain/eda/module/module.go registers exactly one kind, log (side-effect free), so internal/domain/eda/module/ "contains only log" as the issue says. Everything around it is finished:

  • internal/domain/eda/playbook/playbook.go compiles a position: module action list, types actions.<id> by each kind's Result, and internal/infrastructure/controlplanestore/playbooks.go:39 validates a saved eda-playbooks document through the same Compile.
  • internal/domain/eda/playbook/run.go + coordinator.go run the actions in order, gated once per (playbook, version, event, action) by InvokeOnce against playbook_dispatches (internal/infrastructure/postgres/migrations/0002_edastore.sql:84).
  • internal/daemon/daemon.go:2266 calls runActionPlaybooks from pinDefinition, and playbookInput (daemon.go:2370) supplies event.{kind,labels,owner,repo,number,title,body,source}.
  • Both side-effect paths already exist in the daemon: messagingrpc.Client.Deliver(ctx, org, channel, chatID, text) (dialled at internal/app/archied/bootstrap.go:506, already exposed as a 4-arg interface at internal/app/archied/outcome_post.go:29) and forge.IssueForge.Comment (daemon.go:2658 forgeFor).
  • Live reload and the dashboard editor exist (playbooks_client.go, ui/src/settings/PlaybooksPage.vue).

So the product's accepted promise — "a trigger notifies someone" — is expressible and validated but does nothing. CHANGELOG.md:1157 still says "Action playbooks load but do not run yet."

The one real constraint. The registry is built in infrastructure, not the daemon's composition root: playbooks.go:58 does playbook.Compile(docs, module.New(log)), and that one function serves both the running daemon and the State Store's validation (playbooksDefinition().Validate, encodePlaybooks). An invoke with an effect therefore needs a dependency that validation must not need — otherwise the State Store would have to dial the Messaging Service to save a playbook. This PRD's plumbing is exactly that separation.

Verification constraint the reviewer must see. Action playbooks only run for a task that names no workflow (daemon.go:2336), and only issue intake creates such a task (EnqueueIssue writes no workflow). The default stacks cannot demonstrate the stop-when: deployments/dev.toml has no messaging service entry and no channel, e2e/seed.sh has no channel or forge, and channels are extensions, not built-ins. A Go-level test with a fake deliverer proves the seam, not the stop-when.

2. Proposed solution

One new kind, notify, sending text to a messaging channel the task's organisation owns.

Args reuse the message.send step's vocabulary (WORKFLOWS.md:229), so a playbook author learns one set of names:

trigger: {labels: [bug]}
actions:
  - id: ping
    position: module
    kind: notify
    args:
      channel: telegram
      chat_id: "12345"
      text: "New bug: " + event.title + " (" + event.owner + "/" + event.repo + "#" + string(event.number) + ")"
  - position: module
    kind: log
    args: {message: "notified", level: "info"}

notify.Args{Channel, ChatID, Text string} (all required), notify.Result{Delivered bool, Channel, ChatID string}.

Org comes from ctx, never from an arg. runActionPlaybooks runs inside pinDefinition, after workflowContext has put the task's org on the context (daemon.go:2236), so org.OrgFromContext(ctx) is the task's org. An org arg would let an operator-authored playbook address another org's channel; the messaging service already refuses a cross-org channel (internal/app/archiemessaging/compose.go:286, ErrNoChannel).

Effects are optional on the registry. module.New(log) keeps every kind's schema, so validation and package projection still accept a notify playbook without any dependency. A new module.Effects{Notify Notifier} — Notifier being the same Deliver(ctx, org, channel, chatID, text) error shape *messagingrpc.Client already has, so there is no adapter — supplies the run side. invoke returns a named error (module notify: no messaging service configured) when the effect is absent, which the daemon already turns into a warn (daemon.go:2339).

  • controlplanestore.CompilePlaybooks(c, log) keeps its signature and builds a schema-only registry (both validation call sites unchanged).
  • NewLivePlaybooks(client, log, modules playbook.Modules) gains the run-side registry, used at playbooks_client.go:96; bootstrap.livePlaybooks() (bootstrap.go:846) builds it from b.messaging, with the same nil check as the existing deliver closure at bootstrap.go:546.

"Result shows in the run" = a line in the task's log. There is no persisted per-action outcome (playbook_dispatches has no outcome column) and no dashboard view of playbook actions, so the cheapest honest surface is the task's own log, which the task page already renders generically:

  • the kind writes one line per action through the logger it is handed (component=playbook, e.g. playbook notify: delivered to telegram chat 12345);
  • Daemon.runActionPlaybooks passes a task-scoped logger instead of d.Log, via a nil-safe (*logging.TaskRegistry).Logger(taskID int64) *slog.Logger (~12 lines) that returns the open sink's logger;
  • to make that sink exist, defer d.openTaskLog(task)() moves above d.adoptWorkflowIdentity(ctx, task) in process() — today the playbook runs at daemon.go:1686, before the sink is opened at 1692, so a per-action line would otherwise be dropped. This is a one-line move and a side benefit: park reasons from a failed identity adoption (which recordPark already writes, but into no open sink) now land in the task log too.

Rejected alternatives, with reasons: a forge-comment kind (Invoke(ctx, kind, args) carries no task, so forgeFor(task)'s per-connection resolution — "never falls back to the root forge" — cannot be honoured without widening the playbook domain seam); a stored per-action record (migration + proto + UI, a second change); a new event kind plus a ui/src/tasks/timeline-event.ts case (plausible, but the action precedes the run, so the log is where an operator looks).

Failure tolerance, stated rather than fixed: InvokeOnce writes the ledger row before invoking, so a failed delivery is never retried for that event — the daemon warns, the task log records the error, the task proceeds. ErrNoChannel (messaging: no such channel, retrying cannot succeed) and ErrUnavailable (messaging: channel unavailable, retrying could) are therefore both terminal for that action. Changing that is at-least-once semantics and belongs to a separate change.

3. Files and components affected

File Change ~lines
internal/domain/eda/module/notify/notify.go new: Args, Result, SchemaVersion, doc +40
internal/domain/eda/module/module.go registry entry; Notifier + Effects; Effects on ModuleRegistry; runNotify; strict notify-args decode; New(log, effects) +70 / −0
internal/logging/registry.go Logger(taskID) *slog.Logger, nil when no sink is open +12
internal/daemon/daemon.go move the openTaskLog defer above adoptWorkflowIdentity; task-scoped logger in runActionPlaybooks +10 / −2
internal/infrastructure/controlplanestore/playbooks.go keep schema-only construction; add the run-side entry point +8
internal/infrastructure/controlplanestore/playbooks_client.go hold and use the run-side registry +8
internal/app/archied/bootstrap.go build module.Effects{Notify: …} from b.messaging, pass to NewLivePlaybooks +12
WORKFLOWS.md new "Playbooks" section: document shape, position/kind/when/args/actions.<id>, notify and log arg+result tables; fix the one-line stub at :327 +35
CHANGELOG.md [Unreleased] → ### archied entry (news:check skips Unreleased — tools/newsgen/changelog.go:50) +5
internal/domain/eda/module/module_test.go optional, recommended: table-driven invoke/decode over notify with a fake notifier — the one thing that catches an arg-name or result-field drift in a package with zero tests today +70

Net: ~155–190 lines of product code and docs, ~250 with the test. Above AGENTS.md's ~100-line checkpoint, which is why this PRD exists; it adds no RPC, process, binary, table, proto or config field.

4. Acceptance criteria

  1. A playbook with position: module, kind: notify saves through the control plane (dashboard /org/playbooks, package projection) and loads in the daemon; an unknown kind, an undeclared args key, a wrong-typed arg, or a notify action with no channel/chat_id/text is a load failure naming the playbook, action and key.
  2. With the effect available, the action delivers exactly once per (playbook, version, event, action): the message arrives in the named chat, and a second delivery of the same event delivers nothing (ledger).
  3. The task's log for the attempt contains one line per action that ran, component=playbook, naming the channel and chat; it is visible on the task page.
  4. A refused or unavailable delivery writes the messaging service's error text into the task log, warns in the daemon log, and neither fails nor parks the task.
  5. when: false skips the action: no delivery, no log line, no ledger row consumed.
  6. A notify action's Result is decodable, so a later action can read actions.ping.result.delivered.
  7. WORKFLOWS.md and the [Unreleased] changelog entry describe the kind; task check passes once at the end.
  8. A playbook using notify runs from a real trigger with the result visible (see §5).

5. Verification: what can be proven, and what needs the operator

Provable in-tree: the compile/validate path (fake Modules), the invoke path (fake notifier), and the ledger's at-most-once behaviour. internal/domain/eda has no tests at all today, so this would be its first.

Not provable in-tree: "runs from a real trigger and its result shows in the run". The only trigger reaching action playbooks is a task with no workflow — an issue discovered by the forge poll in a managed repo (daemon.go:1382 pollNATS → EnqueueIssue), or an equivalent envelope published on the task stream. The default stacks have no forge and no channel, and a channel is an installed extension. So the stop-when needs one of:

  • (a) recommended the operator's own install: configure the channel, save the playbook, open an issue that a managed repo's poll picks up, then confirm the message arrived and the task's log has the action's line;
  • (b) an in-tree stub channel, which means building a channel frontend the repo does not ship — a second change, not this one;
  • (c) accept the fake-deliverer test as evidence, which I do not recommend: it does not satisfy the stop-when the issue states.

6. Decisions for you

  1. Which kind — notify, or a forge comment? Recommend notify. The messaging path already takes exactly (org, channel, chatID, text) and *messagingrpc.Client satisfies it unchanged; the org is on the context at that point. A forge comment needs the task threaded into Modules.Invoke, because forgeFor(task) resolves per connection and must not silently fall back to the root forge (daemon.go:2658–2669) — a bigger change to a domain seam and a security-relevant one.
  2. How do we demonstrate the stop-when — your configured channel (a), or defer the demo to a stub-channel follow-up (b)? Recommend (a): it is outward-facing, which per AGENTS.md is exactly the kind of step that needs your say-so. If you want no outward traffic, this bead would land at criterion 1–7 with criterion 8 moved to a follow-up, and I would say so in the commit rather than claim the stop-when.

7. Explicit non-goals

  • No forge-comment / forge-write kind.
  • No persisted per-action outcome: no migration, no playbook_dispatches outcome column, no proto change, no dashboard action history.
  • No change to at-most-once semantics; the ledger is still written before the effect, so a failed side effect is not retried for that event.
  • No new event kind, no timeline UI, no ui/ change.
  • No new config field, service, binary or RPC; no CLI lint surface (there is none in the tree — cmd/archied has setup, update, release, status, prbench only, so CHANGELOG.md:876's archie-playbooks lint -eda-dir no longer exists).
  • No test-run/recording seam for module effects (a test run names a workflow, so it never reaches action playbooks).
  • Webhook/binding-triggered tasks stay unable to reach action playbooks (the binding supplies a workflow) — that gap is not fixed here.
  • No rewrite of released changelog entries.

8. Follow-ups to file as beads, not fix here

  • A failed side effect is never retried (InvokeOnce records first); decide whether record-then-retry is acceptable, which needs an outcome column.
  • CHANGELOG.md:1157 and :876 are stale about playbooks running and about the archie-playbooks CLI.
  • Webhook-driven tasks never reach action playbooks, so "notify, then dispatch" cannot be expressed from an event binding.
  • internal/domain/eda has no tests; the module contract is uncovered.
  • WORKFLOWS.md currently documents no playbook document shape at all (only the one-line stub at :327) — in scope here as "documented", but say if you want it split out.

Decide in chat or on the dashboard.

**archie's PRD is ready -- awaiting your go/no-go.** # PRD — Ship a side-effecting playbook module (`kind: notify`) Read-only mission: nothing was built and no gate was run. Every claim below was read out of the tree; line numbers are from this checkout. ## 1. Problem Action playbooks are fully wired but can only do something that has no effect. `internal/domain/eda/module/module.go` registers exactly one kind, `log` (side-effect free), so `internal/domain/eda/module/` "contains only log" as the issue says. Everything around it is finished: - `internal/domain/eda/playbook/playbook.go` compiles a `position: module` action list, types `actions.<id>` by each kind's `Result`, and `internal/infrastructure/controlplanestore/playbooks.go:39` validates a saved `eda-playbooks` document through the same `Compile`. - `internal/domain/eda/playbook/run.go` + `coordinator.go` run the actions in order, gated once per `(playbook, version, event, action)` by `InvokeOnce` against `playbook_dispatches` (`internal/infrastructure/postgres/migrations/0002_edastore.sql:84`). - `internal/daemon/daemon.go:2266` calls `runActionPlaybooks` from `pinDefinition`, and `playbookInput` (daemon.go:2370) supplies `event.{kind,labels,owner,repo,number,title,body,source}`. - Both side-effect paths already exist in the daemon: `messagingrpc.Client.Deliver(ctx, org, channel, chatID, text)` (dialled at `internal/app/archied/bootstrap.go:506`, already exposed as a 4-arg interface at `internal/app/archied/outcome_post.go:29`) and `forge.IssueForge.Comment` (daemon.go:2658 `forgeFor`). - Live reload and the dashboard editor exist (`playbooks_client.go`, `ui/src/settings/PlaybooksPage.vue`). So the product's accepted promise — "a trigger notifies someone" — is expressible and validated but does nothing. `CHANGELOG.md:1157` still says "Action playbooks load but do not run yet." **The one real constraint.** The registry is built in infrastructure, not the daemon's composition root: `playbooks.go:58` does `playbook.Compile(docs, module.New(log))`, and that one function serves both the running daemon and the State Store's validation (`playbooksDefinition().Validate`, `encodePlaybooks`). An invoke with an effect therefore needs a dependency that validation must not need — otherwise the State Store would have to dial the Messaging Service to save a playbook. This PRD's plumbing is exactly that separation. **Verification constraint the reviewer must see.** Action playbooks only run for a task that names no workflow (`daemon.go:2336`), and only issue intake creates such a task (`EnqueueIssue` writes no `workflow`). The default stacks cannot demonstrate the stop-when: `deployments/dev.toml` has no messaging service entry and no channel, `e2e/seed.sh` has no channel or forge, and channels are extensions, not built-ins. A Go-level test with a fake deliverer proves the seam, not the stop-when. ## 2. Proposed solution **One new kind, `notify`**, sending text to a messaging channel the task's organisation owns. Args reuse the `message.send` step's vocabulary (`WORKFLOWS.md:229`), so a playbook author learns one set of names: ```yaml trigger: {labels: [bug]} actions: - id: ping position: module kind: notify args: channel: telegram chat_id: "12345" text: "New bug: " + event.title + " (" + event.owner + "/" + event.repo + "#" + string(event.number) + ")" - position: module kind: log args: {message: "notified", level: "info"} ``` `notify.Args{Channel, ChatID, Text string}` (all required), `notify.Result{Delivered bool, Channel, ChatID string}`. **Org comes from ctx, never from an arg.** `runActionPlaybooks` runs inside `pinDefinition`, after `workflowContext` has put the task's org on the context (daemon.go:2236), so `org.OrgFromContext(ctx)` is the task's org. An `org` arg would let an operator-authored playbook address another org's channel; the messaging service already refuses a cross-org channel (`internal/app/archiemessaging/compose.go:286`, `ErrNoChannel`). **Effects are optional on the registry.** `module.New(log)` keeps every kind's *schema*, so validation and package projection still accept a `notify` playbook without any dependency. A new `module.Effects{Notify Notifier}` — `Notifier` being the same `Deliver(ctx, org, channel, chatID, text) error` shape `*messagingrpc.Client` already has, so there is no adapter — supplies the run side. `invoke` returns a named error (`module notify: no messaging service configured`) when the effect is absent, which the daemon already turns into a warn (daemon.go:2339). - `controlplanestore.CompilePlaybooks(c, log)` keeps its signature and builds a schema-only registry (both validation call sites unchanged). - `NewLivePlaybooks(client, log, modules playbook.Modules)` gains the run-side registry, used at `playbooks_client.go:96`; `bootstrap.livePlaybooks()` (bootstrap.go:846) builds it from `b.messaging`, with the same nil check as the existing deliver closure at bootstrap.go:546. **"Result shows in the run" = a line in the task's log.** There is no persisted per-action outcome (`playbook_dispatches` has no outcome column) and no dashboard view of playbook actions, so the cheapest honest surface is the task's own log, which the task page already renders generically: - the kind writes one line per action through the logger it is handed (`component=playbook`, e.g. `playbook notify: delivered to telegram chat 12345`); - `Daemon.runActionPlaybooks` passes a task-scoped logger instead of `d.Log`, via a nil-safe `(*logging.TaskRegistry).Logger(taskID int64) *slog.Logger` (~12 lines) that returns the open sink's logger; - to make that sink exist, `defer d.openTaskLog(task)()` moves above `d.adoptWorkflowIdentity(ctx, task)` in `process()` — today the playbook runs at daemon.go:1686, *before* the sink is opened at 1692, so a per-action line would otherwise be dropped. This is a one-line move and a side benefit: park reasons from a failed identity adoption (which `recordPark` already writes, but into no open sink) now land in the task log too. Rejected alternatives, with reasons: a forge-comment kind (`Invoke(ctx, kind, args)` carries no task, so `forgeFor(task)`'s per-connection resolution — "never falls back to the root forge" — cannot be honoured without widening the playbook domain seam); a stored per-action record (migration + proto + UI, a second change); a new event kind plus a `ui/src/tasks/timeline-event.ts` case (plausible, but the action precedes the run, so the log is where an operator looks). **Failure tolerance, stated rather than fixed:** `InvokeOnce` writes the ledger row *before* invoking, so a failed delivery is never retried for that event — the daemon warns, the task log records the error, the task proceeds. `ErrNoChannel` (`messaging: no such channel`, retrying cannot succeed) and `ErrUnavailable` (`messaging: channel unavailable`, retrying could) are therefore both terminal for that action. Changing that is at-least-once semantics and belongs to a separate change. ## 3. Files and components affected | File | Change | ~lines | |---|---|---| | `internal/domain/eda/module/notify/notify.go` | new: `Args`, `Result`, `SchemaVersion`, doc | +40 | | `internal/domain/eda/module/module.go` | registry entry; `Notifier` + `Effects`; `Effects` on `ModuleRegistry`; `runNotify`; strict notify-args decode; `New(log, effects)` | +70 / −0 | | `internal/logging/registry.go` | `Logger(taskID) *slog.Logger`, nil when no sink is open | +12 | | `internal/daemon/daemon.go` | move the `openTaskLog` defer above `adoptWorkflowIdentity`; task-scoped logger in `runActionPlaybooks` | +10 / −2 | | `internal/infrastructure/controlplanestore/playbooks.go` | keep schema-only construction; add the run-side entry point | +8 | | `internal/infrastructure/controlplanestore/playbooks_client.go` | hold and use the run-side registry | +8 | | `internal/app/archied/bootstrap.go` | build `module.Effects{Notify: …}` from `b.messaging`, pass to `NewLivePlaybooks` | +12 | | `WORKFLOWS.md` | new "Playbooks" section: document shape, `position`/`kind`/`when`/`args`/`actions.<id>`, `notify` and `log` arg+result tables; fix the one-line stub at :327 | +35 | | `CHANGELOG.md` | `[Unreleased]` → `### archied` entry (`news:check` skips Unreleased — `tools/newsgen/changelog.go:50`) | +5 | | `internal/domain/eda/module/module_test.go` | **optional, recommended**: table-driven invoke/decode over `notify` with a fake notifier — the one thing that catches an arg-name or result-field drift in a package with zero tests today | +70 | Net: **~155–190 lines** of product code and docs, ~250 with the test. Above AGENTS.md's ~100-line checkpoint, which is why this PRD exists; it adds no RPC, process, binary, table, proto or config field. ## 4. Acceptance criteria 1. A playbook with `position: module, kind: notify` saves through the control plane (dashboard `/org/playbooks`, package projection) and loads in the daemon; an unknown kind, an undeclared args key, a wrong-typed arg, or a `notify` action with no `channel`/`chat_id`/`text` is a **load** failure naming the playbook, action and key. 2. With the effect available, the action delivers exactly once per `(playbook, version, event, action)`: the message arrives in the named chat, and a second delivery of the same event delivers nothing (ledger). 3. The task's log for the attempt contains one line per action that ran, `component=playbook`, naming the channel and chat; it is visible on the task page. 4. A refused or unavailable delivery writes the messaging service's error text into the task log, warns in the daemon log, and neither fails nor parks the task. 5. `when: false` skips the action: no delivery, no log line, no ledger row consumed. 6. A `notify` action's `Result` is decodable, so a later action can read `actions.ping.result.delivered`. 7. `WORKFLOWS.md` and the `[Unreleased]` changelog entry describe the kind; `task check` passes once at the end. 8. A playbook using `notify` runs from a real trigger with the result visible (see §5). ## 5. Verification: what can be proven, and what needs the operator Provable in-tree: the compile/validate path (fake `Modules`), the invoke path (fake notifier), and the ledger's at-most-once behaviour. `internal/domain/eda` has no tests at all today, so this would be its first. **Not provable in-tree:** "runs from a real trigger and its result shows in the run". The only trigger reaching action playbooks is a task with no workflow — an issue discovered by the forge poll in a managed repo (`daemon.go:1382` `pollNATS` → `EnqueueIssue`), or an equivalent envelope published on the task stream. The default stacks have no forge and no channel, and a channel is an installed extension. So the stop-when needs one of: - **(a) recommended** the operator's own install: configure the channel, save the playbook, open an issue that a managed repo's poll picks up, then confirm the message arrived and the task's log has the action's line; - (b) an in-tree stub channel, which means building a channel frontend the repo does not ship — a second change, not this one; - (c) accept the fake-deliverer test as evidence, which I do not recommend: it does not satisfy the stop-when the issue states. ## 6. Decisions for you 1. **Which kind — `notify`, or a forge comment?** Recommend `notify`. The messaging path already takes exactly `(org, channel, chatID, text)` and `*messagingrpc.Client` satisfies it unchanged; the org is on the context at that point. A forge comment needs the task threaded into `Modules.Invoke`, because `forgeFor(task)` resolves per connection and must not silently fall back to the root forge (daemon.go:2658–2669) — a bigger change to a domain seam and a security-relevant one. 2. **How do we demonstrate the stop-when — your configured channel (a), or defer the demo to a stub-channel follow-up (b)?** Recommend (a): it is outward-facing, which per AGENTS.md is exactly the kind of step that needs your say-so. If you want no outward traffic, this bead would land at criterion 1–7 with criterion 8 moved to a follow-up, and I would say so in the commit rather than claim the stop-when. ## 7. Explicit non-goals - No forge-comment / forge-write kind. - No persisted per-action outcome: no migration, no `playbook_dispatches` outcome column, no proto change, no dashboard action history. - No change to at-most-once semantics; the ledger is still written before the effect, so a failed side effect is not retried for that event. - No new event kind, no timeline UI, no `ui/` change. - No new config field, service, binary or RPC; no CLI lint surface (there is none in the tree — `cmd/archied` has `setup, update, release, status, prbench` only, so `CHANGELOG.md:876`'s `archie-playbooks lint -eda-dir` no longer exists). - No test-run/recording seam for module effects (a test run names a workflow, so it never reaches action playbooks). - Webhook/binding-triggered tasks stay unable to reach action playbooks (the binding supplies a workflow) — that gap is not fixed here. - No rewrite of released changelog entries. ## 8. Follow-ups to file as beads, not fix here - A failed side effect is never retried (`InvokeOnce` records first); decide whether record-then-retry is acceptable, which needs an outcome column. - `CHANGELOG.md:1157` and `:876` are stale about playbooks running and about the `archie-playbooks` CLI. - Webhook-driven tasks never reach action playbooks, so "notify, then dispatch" cannot be expressed from an event binding. - `internal/domain/eda` has no tests; the module contract is uncovered. - `WORKFLOWS.md` currently documents no playbook document shape at all (only the one-line stub at :327) — in scope here as "documented", but say if you want it split out. </summary> _Decide in chat or on the dashboard._
Author
Owner

Closed: goes against the product plan in epic #1977. Playbooks are being removed; triggers replace bindings, mappings, issue routing and playbooks (#1978).

Closed: goes against the product plan in epic #1977. Playbooks are being removed; triggers replace bindings, mappings, issue routing and playbooks (#1978).
sam closed this issue 2026-11-14 14:45:06 +00:00
sam added a new dependency 2026-11-14 14:45:09 +00:00
Sign in to join this conversation.
1 Participants
Notifications
Due Date
No due date set.
Reference: sam/archie#153