Context assembly derives label origin from resolved typed identity

[George-RD]

Parent

Spec: provenance labels with typed identity — #220 (wayfinder #193, map #182).

What to build

Have context assembly derive each label's origin from the resolved typed identity of its source, instead of leaving origin unrecorded. In kernel briefcase packing (provenance_from_sections and the pack path), each classified worker-visible section is labelled: an owner-origin section carries Owner(PrincipalId); a bound counterparty section carries Counterparty(IdentityRef); a section whose origin cannot be resolved (e.g. CounterpartyRef::Unresolved) fails closed for rated egress, reusing the existing unclassified-section error. No LLM judgment: origin comes from the kernel's identity resolution only (AD-032/AD-121).

Promise: Immune system. Users: Bell, Auditor.

Acceptance criteria

• Packing labels each classified worker-visible section with the ProvenanceOrigin resolved for its source.
• Owner sections -> Owner(PrincipalId); bound counterparty sections -> Counterparty(IdentityRef).
• A section with no resolvable origin fails closed for rated egress (existing unclassified-section error path).
• Origin is derived from kernel identity resolution, never from section text/LLM output.
• Existing briefcase pack tests stay green; new unit tests cover owner/counterparty/unresolved.

Blocked by

• Bind provenance label to typed-identity origin (generalize ProducedBy) #224 (Label carries typed-identity origin).

[coderabbitai]

Coding Plan

Summary

• Add an optional typed origin field to BriefcaseSection and populate it at every section-creation site (pack() and apply_top_up).
• Derive owner origin from state.owner_principal_id and counterparty origin from the resolved CounterpartyRef in the kernel pack entry points, with CounterpartyRef::Unresolved mapping to no origin.
• Carry the resolved origin into ClassifiedBriefcaseItem, and make provenance_from_sections fail closed with the existing DisclosureError::UnclassifiedSection when a policy-requiring worker-visible section has no resolvable origin.
• Add unit tests for owner, counterparty, and unresolved origin, and keep existing briefcase and disclosure tests green.

File-level change summary:

• crates/openspine-schemas/src/disclosure_policy.rs: add ProvenanceOrigin, PrincipalId, IdentityRef (if absent); add origin to ClassifiedBriefcaseItem.
• crates/openspine-schemas/src/briefcase.rs: add origin: Option<ProvenanceOrigin> to BriefcaseSection; add origins parameter to pack(); add the ProvenanceOrigin::from_counterparty helper (or place it kernel-side).
• crates/openspine-schemas/src/briefcase/ops.rs: add owner-origin parameter to apply_top_up and set it on the new section.
• crates/openspine-schemas/src/briefcase/tests.rs: update inline BriefcaseSection constructions; add owner/counterparty origin pack tests.
• crates/openspine-kernel/src/briefcase.rs: derive owner and counterparty origins in pack_for_pipeline/pack_for_task; thread into pack(); pass owner origin into apply_top_up.
• crates/openspine-kernel/src/disclosure.rs: update provenance_from_sections to record origin and fail closed on None via DisclosureError::UnclassifiedSection.
• crates/openspine-kernel/src/disclosure/disclosure_regression_tests.rs: add owner/counterparty/unresolved origin tests.

Follow-up notes for implementing agents:

• Confirm first whether #224 has landed ProvenanceOrigin/PrincipalId/IdentityRef and the label origin field. If yes, skip Task 1.1 and Task 3.1 type work and reuse the existing definitions.
• Do not add origin to DisclosurePolicyKey or DisclosurePolicy::covers; this ticket records origin, it does not change policy coverage rules.
• Do not inspect section payload text to derive origin. Use only CounterpartyRef and owner_principal_id (AD-032/AD-121).

Design Choices

Design Choice 1: Do the typed-identity origin types already exist from the blocking ticket `#224`?

Options Considered:

1. Assume #224 has landed the types and the origin field on the label; this ticket only derives and threads the values.
2. Define the types and the label field minimally inside this ticket in disclosure_policy.rs, so this ticket stays self-contained if #224 has not merged.

Chosen Option: 2

Rationale: The exploration confirmed that ProvenanceOrigin, PrincipalId, and IdentityRef do not exist anywhere in the current tree, and the ClassifiedBriefcaseItem label carries only disclosure_class. This ticket is blocked by #224 ("Label carries typed-identity origin"), which is expected to introduce these types and add the origin field to the label. Define ProvenanceOrigin, PrincipalId, and IdentityRef (and the label origin field) minimally in crates/openspine-schemas/src/disclosure_policy.rs if they are absent, so packing and provenance derivation compile and can be tested. If #224 has already added them, reuse the existing definitions and skip the type-definition task.

Design Choice 2: How should the origin values reach the pure `pack()` function, which lives in `openspine-schemas` and has no access to `owner_principal_id`?

Options Considered:

1. Add an origins bundle parameter to pack() (owner origin plus optional counterparty origin) and let the kernel derive both before the call.
2. Store owner and counterparty origin on TaskShape/Briefcase and let pack() read them.

Chosen Option: 1

Rationale: pack() builds every initial section, but TaskShape carries no owner principal id, and the owner principal id lives on kernel AppState. Pass a small origins bundle into pack(); the kernel is the single place that holds both owner_principal_id and the resolved CounterpartyRef, so it must own derivation, and a parameter keeps pack() deterministic and side-effect free.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Add typed origin to the section model and pack path

This phase adds a per-section origin field to the briefcase model and populates it in every place that creates a section. The goal is that every constructed BriefcaseSection carries either a resolved origin or an explicit "unresolved" marker. This phase does not yet enforce anything. It only records origin.

Task 1: Define the typed-origin types (skip if `#224` already provides them)

Provide the ProvenanceOrigin, PrincipalId, and IdentityRef types used by the label.

• Add the types to crates/openspine-schemas/src/disclosure_policy.rs, next to DisclosureClass and ClassifiedBriefcaseItem.
• Define PrincipalId and IdentityRef as newtype wrappers over ulid::Ulid, following the existing raw-Ulid identity model.
• Define ProvenanceOrigin as an enum with variants Owner(PrincipalId) and Counterparty(IdentityRef).
• Derive Debug, Clone, PartialEq, Eq, Serialize, and Deserialize, matching the derives on ClassifiedBriefcaseItem so equality-based binding checks keep working.
• If #224 already added these types and the label origin field, reuse them and do not redefine.

Task 2: Add an optional origin field to `BriefcaseSection`

Give each packed section a place to record its resolved origin.

• Update BriefcaseSection in crates/openspine-schemas/src/briefcase.rs to add origin: Option<ProvenanceOrigin>.
• Use #[serde(default)] so None is the legacy/unknown value, mirroring the existing disclosure_class fail-closed pattern.
• Document that None means the origin could not be resolved and must fail closed for rated egress.

Task 3: Populate origin in `pack()`

Set the origin at each section construction site inside pack().

• Update pack() in crates/openspine-schemas/src/briefcase.rs to accept an origins bundle (owner origin plus an optional counterparty origin).
• Set the grant section and every preference/skill section origin to the owner origin, because these come from the owner's grant and learned pool.
• Set the counterparty_slice section origin to the counterparty origin (which may be None when the counterparty is unresolved).
• Keep all other pack() logic (sorting, depth, disclosure_class) unchanged.

Task 4: Populate origin in `apply_top_up`

Set the origin for sections added after packing.

• Update apply_top_up in crates/openspine-schemas/src/briefcase/ops.rs to accept an owner origin and set it on the new section.
• Top-up content comes from the owner's learned pool, so top-up sections are always owner-origin.
• Update every inline BriefcaseSection { .. } construction in crates/openspine-schemas/src/briefcase/tests.rs and other schema doctests to populate the new origin field so existing tests compile.

🤖 Prompt for AI agents

Implement Phase 1: add a per-section origin field to the briefcase model and
populate it wherever a section is created. This phase only records origin; it
does not enforce anything yet.

- If types `ProvenanceOrigin`, `PrincipalId`, and `IdentityRef` do not already
exist (check whether ticket `#224` landed them first), add them to
`crates/openspine-schemas/src/disclosure_policy.rs`, next to `DisclosureClass`
and `ClassifiedBriefcaseItem`. Define `PrincipalId` and `IdentityRef` as newtype
wrappers over `ulid::Ulid`, following the existing raw-`Ulid` identity model.
Define `ProvenanceOrigin` as an enum with variants `Owner(PrincipalId)` and
`Counterparty(IdentityRef)`. Derive `Debug`, `Clone`, `PartialEq`, `Eq`,
`Serialize`, and `Deserialize`, matching the derives on
`ClassifiedBriefcaseItem`. If `#224` already added these, reuse them and skip this
step.

- Update `BriefcaseSection` in `crates/openspine-schemas/src/briefcase.rs` to
add a field `origin: Option<ProvenanceOrigin>`. Use `#[serde(default)]` so
`None` is the legacy/unknown value, mirroring the existing `disclosure_class`
fail-closed pattern. Document that `None` means the origin could not be resolved
and must fail closed for rated egress.

- Update `pack()` in `crates/openspine-schemas/src/briefcase.rs` to accept an
origins bundle (owner origin plus an optional counterparty origin). Set the
`grant` section and every `preference`/`skill` section origin to the owner
origin. Set the `counterparty_slice` section origin to the counterparty origin,
which may be `None` when the counterparty is unresolved. Keep all other `pack()`
logic (sorting, depth, `disclosure_class`) unchanged.

- Update `apply_top_up` in `crates/openspine-schemas/src/briefcase/ops.rs` to
accept an owner origin parameter and set it on the newly created section, since
top-up content always comes from the owner's learned pool.

- Update every inline `BriefcaseSection { .. }` construction in
`crates/openspine-schemas/src/briefcase/tests.rs` and other schema doctests to
populate the new `origin` field so existing tests compile.

Phase 2: Derive origin from resolved identity in the kernel

This phase makes the kernel derive owner and counterparty origins from its identity resolution and thread them into the pack path. This is the only source of origin. No section text is inspected.

Task 1: Add an origin derivation helper

Provide one deterministic mapping from resolved identity to ProvenanceOrigin.

• Add a helper (for example ProvenanceOrigin::from_counterparty(&CounterpartyRef, owner_principal_id)) near CounterpartyRef in crates/openspine-schemas/src/briefcase.rs, or as a small function in crates/openspine-kernel/src/briefcase.rs.
• Map CounterpartyRef::Bound { relationship: RelationshipKind::Owner, .. } to Some(ProvenanceOrigin::Owner(PrincipalId)).
• Map CounterpartyRef::Bound { identity_id, .. } (non-owner) to Some(ProvenanceOrigin::Counterparty(IdentityRef::from(identity_id))).
• Map CounterpartyRef::Unresolved { .. } to None.
• Model the exhaustive match on the existing relationship_slug() precedent in crates/openspine-kernel/src/disclosure.rs.

Task 2: Thread origins through the kernel pack entry points

Derive both origins where identity is known and pass them down.

• Update pack_for_pipeline in crates/openspine-kernel/src/briefcase.rs, immediately after counterparty is built, to derive the owner origin from state.owner_principal_id and the counterparty origin with the Task 2.1 helper.
• Pass the derived origins into pack_for_task and then into schemas::briefcase::pack().
• Update the kernel apply_top_up in crates/openspine-kernel/src/briefcase.rs to pass the owner origin (from state.owner_principal_id) into the schema apply_top_up.
• Do not add any LLM call or text inspection. Origin comes only from CounterpartyRef and owner_principal_id.

🤖 Prompt for AI agents

Implement Phase 2: make the kernel derive owner and counterparty origins from
its identity resolution and thread them into the pack path. Origin must come
only from resolved identity, never from section text.

- Add a helper, for example
`ProvenanceOrigin::from_counterparty(&CounterpartyRef, owner_principal_id)`,
near `CounterpartyRef` in `crates/openspine-schemas/src/briefcase.rs`, or as a
small function in `crates/openspine-kernel/src/briefcase.rs`. Map
`CounterpartyRef::Bound { relationship: RelationshipKind::Owner, .. }` to
`Some(ProvenanceOrigin::Owner(PrincipalId))`. Map `CounterpartyRef::Bound {
identity_id, .. }` for a non-owner relationship to
`Some(ProvenanceOrigin::Counterparty(IdentityRef::from(identity_id)))`. Map
`CounterpartyRef::Unresolved { .. }` to `None`. Model the exhaustive match on
the existing `relationship_slug()` precedent in
`crates/openspine-kernel/src/disclosure.rs`.

- Update `pack_for_pipeline` in `crates/openspine-kernel/src/briefcase.rs`,
immediately after `counterparty` is built, to derive the owner origin from
`state.owner_principal_id` and the counterparty origin using the new helper.
Pass the derived origins into `pack_for_task` and then into
`schemas::briefcase::pack()`.

- Update the kernel `apply_top_up` in `crates/openspine-kernel/src/briefcase.rs`
to pass the owner origin (from `state.owner_principal_id`) into the schema
`apply_top_up`.

- Do not add any LLM call or text inspection to derive origin. Use only
`CounterpartyRef` and `owner_principal_id` as the origin source.

Phase 3: Carry origin through provenance and fail closed

This phase makes rated egress record each section's origin and fail closed when origin is unresolved, reusing the existing unclassified-section error.

Task 1: Add origin to the classified label

Let the provenance item carry the resolved origin (skip if #224 already added it).

• Update ClassifiedBriefcaseItem in crates/openspine-schemas/src/disclosure_policy.rs to add an origin: ProvenanceOrigin field alongside disclosure_class.
• Keep #[serde(deny_unknown_fields)] and derived PartialEq, so the field participates in the PreparedQuery::binding_matches equality check automatically.
• Do not change DisclosurePolicyKey or DisclosurePolicy::covers. Policy coverage stays on (relationship, disclosure_class, egress_class). Origin is recorded for audit and binding, not for policy branching.

Task 2: Record and enforce origin in `provenance_from_sections`

Read each section's origin, fail closed when it is missing, and attach it otherwise.

• Update provenance_from_sections in crates/openspine-kernel/src/disclosure.rs.
• Keep the existing skips: VisibilityClass::KernelBound sections and non-policy (Public) sections are excluded.
• For each remaining policy-requiring worker-visible section, when section.origin is None, return Err(DisclosureError::UnclassifiedSection(section.key.clone())), reusing the existing fail-closed path.
• When section.origin is Some(origin), attach it to the ClassifiedBriefcaseItem.
• The catch-all Err(_) branch in crates/openspine-kernel/src/api/actions.rs already maps this to the generic "rated disclosure was blocked by kernel policy" denial, so no caller-facing change is needed and no detail leaks.

Task 3: Add unit tests for owner, counterparty, and unresolved origin

Cover the three origin outcomes and keep existing tests green.

• Add pack tests in crates/openspine-schemas/src/briefcase/tests.rs that assert the origin field per section key: grant and preference:*/skill:* carry Owner(PrincipalId), and counterparty_slice carries the expected counterparty origin. Mirror same_pool_stranger_and_owner_pack_preference_and_skill_depth.
• Add provenance tests in crates/openspine-kernel/src/disclosure/disclosure_regression_tests.rs: an owner-origin section and a bound-counterparty-origin section produce items with the correct origin; a policy-requiring worker-visible section with origin: None (unresolved counterparty) returns Err(DisclosureError::UnclassifiedSection(key)). Mirror unclassified_worker_visible_section_fails_closed and caller_omitted_class_is_still_enforced.
• Confirm existing pack and disclosure tests still pass after the origin field is added.

🤖 Prompt for AI agents

Implement Phase 3: make rated egress record each section's origin and fail
closed when origin is unresolved, reusing the existing unclassified-section
error.

- If not already present from `#224`, update `ClassifiedBriefcaseItem` in
`crates/openspine-schemas/src/disclosure_policy.rs` to add an `origin:
ProvenanceOrigin` field alongside `disclosure_class`. Keep
`#[serde(deny_unknown_fields)]` and derived `PartialEq`, so the field
participates in the `PreparedQuery::binding_matches` equality check
automatically. Do not change `DisclosurePolicyKey` or
`DisclosurePolicy::covers`. Policy coverage must stay on `(relationship,
disclosure_class, egress_class)`; origin is recorded for audit and binding, not
for policy branching.

- Update `provenance_from_sections` in
`crates/openspine-kernel/src/disclosure.rs`. Keep the existing skips:
`VisibilityClass::KernelBound` sections and non-policy (`Public`) sections stay
excluded. For each remaining policy-requiring worker-visible section, when
`section.origin` is `None`, return
`Err(DisclosureError::UnclassifiedSection(section.key.clone()))`, reusing the
existing fail-closed path. When `section.origin` is `Some(origin)`, attach it to
the `ClassifiedBriefcaseItem`. Note that the catch-all `Err(_)` branch in
`crates/openspine-kernel/src/api/actions.rs` already maps this to the generic
"rated disclosure was blocked by kernel policy" denial, so no caller-facing
change is needed and no detail leaks.

- Add pack tests in `crates/openspine-schemas/src/briefcase/tests.rs` asserting
the `origin` field per section key: `grant` and `preference:*`/`skill:*` carry
`Owner(PrincipalId)`, and `counterparty_slice` carries the expected counterparty
origin. Mirror the existing test
`same_pool_stranger_and_owner_pack_preference_and_skill_depth`.

- Add provenance tests in
`crates/openspine-kernel/src/disclosure/disclosure_regression_tests.rs`: verify
an owner-origin section and a bound-counterparty-origin section produce items
with the correct `origin`, and verify a policy-requiring worker-visible section
with `origin: None` (unresolved counterparty) returns
`Err(DisclosureError::UnclassifiedSection(key))`. Mirror the existing tests
`unclassified_worker_visible_section_fails_closed` and
`caller_omitted_class_is_still_enforced`.

- Confirm all existing pack and disclosure tests still pass after the `origin`
field is added.

Research

The briefcase model lives in crates/openspine-schemas/src/briefcase.rs. pack() builds BriefcaseSection values for the grant, preference/skill, and counterparty_slice kinds. crates/openspine-schemas/src/briefcase/ops.rs::apply_top_up adds sections after packing.

The kernel entry points pack_for_pipeline/pack_for_task in crates/openspine-kernel/src/briefcase.rs build the CounterpartyRef (Bound/Unresolved) and hold state.owner_identity_id and state.owner_principal_id.

Rated egress uses provenance_from_sections in crates/openspine-kernel/src/disclosure.rs, which reads each BriefcaseSection and builds a DisclosureProvenance of ClassifiedBriefcaseItem values (defined in crates/openspine-schemas/src/disclosure_policy.rs). A worker-visible, policy-requiring section without a disclosure_class already fails closed with DisclosureError::UnclassifiedSection.

Today no section carries any origin. ProvenanceOrigin, PrincipalId, and IdentityRef do not exist yet in the codebase.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement Phase 1: add a per-section origin field to the briefcase model and
populate it wherever a section is created. This phase only records origin; it
does not enforce anything yet.

- If types `ProvenanceOrigin`, `PrincipalId`, and `IdentityRef` do not already
exist (check whether ticket `#224` landed them first), add them to
`crates/openspine-schemas/src/disclosure_policy.rs`, next to `DisclosureClass`
and `ClassifiedBriefcaseItem`. Define `PrincipalId` and `IdentityRef` as newtype
wrappers over `ulid::Ulid`, following the existing raw-`Ulid` identity model.
Define `ProvenanceOrigin` as an enum with variants `Owner(PrincipalId)` and
`Counterparty(IdentityRef)`. Derive `Debug`, `Clone`, `PartialEq`, `Eq`,
`Serialize`, and `Deserialize`, matching the derives on
`ClassifiedBriefcaseItem`. If `#224` already added these, reuse them and skip this
step.

- Update `BriefcaseSection` in `crates/openspine-schemas/src/briefcase.rs` to
add a field `origin: Option<ProvenanceOrigin>`. Use `#[serde(default)]` so
`None` is the legacy/unknown value, mirroring the existing `disclosure_class`
fail-closed pattern. Document that `None` means the origin could not be resolved
and must fail closed for rated egress.

- Update `pack()` in `crates/openspine-schemas/src/briefcase.rs` to accept an
origins bundle (owner origin plus an optional counterparty origin). Set the
`grant` section and every `preference`/`skill` section origin to the owner
origin. Set the `counterparty_slice` section origin to the counterparty origin,
which may be `None` when the counterparty is unresolved. Keep all other `pack()`
logic (sorting, depth, `disclosure_class`) unchanged.

- Update `apply_top_up` in `crates/openspine-schemas/src/briefcase/ops.rs` to
accept an owner origin parameter and set it on the newly created section, since
top-up content always comes from the owner's learned pool.

- Update every inline `BriefcaseSection { .. }` construction in
`crates/openspine-schemas/src/briefcase/tests.rs` and other schema doctests to
populate the new `origin` field so existing tests compile.
===============================================================================

Task: 2

Implement Phase 2: make the kernel derive owner and counterparty origins from
its identity resolution and thread them into the pack path. Origin must come
only from resolved identity, never from section text.

- Add a helper, for example
`ProvenanceOrigin::from_counterparty(&CounterpartyRef, owner_principal_id)`,
near `CounterpartyRef` in `crates/openspine-schemas/src/briefcase.rs`, or as a
small function in `crates/openspine-kernel/src/briefcase.rs`. Map
`CounterpartyRef::Bound { relationship: RelationshipKind::Owner, .. }` to
`Some(ProvenanceOrigin::Owner(PrincipalId))`. Map `CounterpartyRef::Bound {
identity_id, .. }` for a non-owner relationship to
`Some(ProvenanceOrigin::Counterparty(IdentityRef::from(identity_id)))`. Map
`CounterpartyRef::Unresolved { .. }` to `None`. Model the exhaustive match on
the existing `relationship_slug()` precedent in
`crates/openspine-kernel/src/disclosure.rs`.

- Update `pack_for_pipeline` in `crates/openspine-kernel/src/briefcase.rs`,
immediately after `counterparty` is built, to derive the owner origin from
`state.owner_principal_id` and the counterparty origin using the new helper.
Pass the derived origins into `pack_for_task` and then into
`schemas::briefcase::pack()`.

- Update the kernel `apply_top_up` in `crates/openspine-kernel/src/briefcase.rs`
to pass the owner origin (from `state.owner_principal_id`) into the schema
`apply_top_up`.

- Do not add any LLM call or text inspection to derive origin. Use only
`CounterpartyRef` and `owner_principal_id` as the origin source.
===============================================================================

Task: 3

Implement Phase 3: make rated egress record each section's origin and fail
closed when origin is unresolved, reusing the existing unclassified-section
error.

- If not already present from `#224`, update `ClassifiedBriefcaseItem` in
`crates/openspine-schemas/src/disclosure_policy.rs` to add an `origin:
ProvenanceOrigin` field alongside `disclosure_class`. Keep
`#[serde(deny_unknown_fields)]` and derived `PartialEq`, so the field
participates in the `PreparedQuery::binding_matches` equality check
automatically. Do not change `DisclosurePolicyKey` or
`DisclosurePolicy::covers`. Policy coverage must stay on `(relationship,
disclosure_class, egress_class)`; origin is recorded for audit and binding, not
for policy branching.

- Update `provenance_from_sections` in
`crates/openspine-kernel/src/disclosure.rs`. Keep the existing skips:
`VisibilityClass::KernelBound` sections and non-policy (`Public`) sections stay
excluded. For each remaining policy-requiring worker-visible section, when
`section.origin` is `None`, return
`Err(DisclosureError::UnclassifiedSection(section.key.clone()))`, reusing the
existing fail-closed path. When `section.origin` is `Some(origin)`, attach it to
the `ClassifiedBriefcaseItem`. Note that the catch-all `Err(_)` branch in
`crates/openspine-kernel/src/api/actions.rs` already maps this to the generic
"rated disclosure was blocked by kernel policy" denial, so no caller-facing
change is needed and no detail leaks.

- Add pack tests in `crates/openspine-schemas/src/briefcase/tests.rs` asserting
the `origin` field per section key: `grant` and `preference:*`/`skill:*` carry
`Owner(PrincipalId)`, and `counterparty_slice` carries the expected counterparty
origin. Mirror the existing test
`same_pool_stranger_and_owner_pack_preference_and_skill_depth`.

- Add provenance tests in
`crates/openspine-kernel/src/disclosure/disclosure_regression_tests.rs`: verify
an owner-origin section and a bound-counterparty-origin section produce items
with the correct `origin`, and verify a policy-requiring worker-visible section
with `origin: None` (unresolved counterparty) returns
`Err(DisclosureError::UnclassifiedSection(key))`. Mirror the existing tests
`unclassified_worker_visible_section_fails_closed` and
`caller_omitted_class_is_still_enforced`.

- Confirm all existing pack and disclosure tests still pass after the `origin`
field is added.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!