Repository navigation
feat(connections): W02 PR-3 — real GitHub operation invoked + rows fetched via W01 transport - #11292
bolichen97 wants to merge 7 commits into
Conversation
|
Intent: Make one GitHub operation actually invoked through W01'''s real executor/transport — located, dispatched, decoded into the neutral payload channel, and paged across >=2 pages — and wire the knowledge GitHub structured source'''s live fetch + refresh onto it, with no naked sender and no re-implemented custody/auth/paging. |
Design Review (Fable 5) — 🟡 CONCERNSDesign-level review of Design-Verdict: CONCERNS Description disclaims work the diff ships: the converged ACL subsystem, schema migration, permission probe, and descriptor rows all land under a stale dispatch-slice narrative. Watch
[DESIGN-REVIEWED] 38fae06 |
First Principles Review (Fable 5) — 🔴 BLOCKPremise-level review of First-Principles-Verdict: BLOCK The diff ships the ingest stack, ACL gate, de-gated Not justified as shipped
What this change shipsInventory (9 items) — 2 justifiedIntent: make one GitHub operation genuinely reachable end-to-end through W01's transport so the knowledge structured source can really fetch — ADDITION.
BlockersFraming contradicted by the diff — the description's constraint is reversed by the change it describes. Zero-consumer probe surface exported publicly. [FIRST-PRINCIPLES-REVIEWED] 38fae06 |
GPT 5.6 Review — 🔴 changes requested (blocking)GPT 5.6 found at least one blocking issue that must be resolved before merging This comment is updated in place on each push. BLOCKING -- src/kiro_crew/dashboard/handlers/knowledge.py:3219 -- Optional connectors are constructed on the gateway boot path BLOCKING -- src/kiro_crew/dashboard/handlers/knowledge.py:230 -- Resolver failure grants local-library bypass BLOCKING -- src/kiro_crew/dashboard/handlers/knowledge.py:694 -- ACL enforcement is confined to search BLOCKING -- src/kiro_crew/knowledge/connectors/github_structured.py:676 -- Issue and pull-request streams emit the same PR row key BLOCKING -- src/kiro_crew/knowledge/ingestion.py:1399 -- Row replacement lacks one atomic persistence outcome BLOCKING -- src/kiro_crew/connections/vendors/github/decoder.py:96 -- Malformed successful pages are accepted as empty FINDING -- src/kiro_crew/knowledge/connectors/github_structured.py:23 -- FINDING -- src/kiro_crew/knowledge/store.py:1723 -- FINDING -- docs/system-specs/modules/connector-github.md:175 -- [BLOCK-MERGE] 38fae06 Adjudication (Opus 4.8) — is blocking on each finding proportionate?Verified. F1 anchors to a F1 — Optional vendor connectors are imported and constructed inside F2 — resolver-failure fallback to LOCAL_LIBRARY (knowledge.py:230–235) serves trusted-local content on a shared deployment; multi-tenant resolver install + raise is plausible in real operation. UPHOLD-FENCED. F3 — item ACL is applied only in the F4 — issues REST endpoint returns PRs too (confirmed knowledge.py comment 688–691 / github_structured.py:692–697); a repo with any PR reaches the shared-key path in normal operation. UPHOLD-FENCED. F5 — per-row ingest/grant/state persistence (ingestion.py:1398–1410) with per-row failure setting F6 — malformed 200 body returns None as an empty page (decoder.py:96), silently; a corrupt page mid-pagination is rare but plausible and the watermark advance is silent/irreversible. UPHOLD-FENCED. F1: AUTOSDE blocking-rule anchor confirmed at AUTOSDE.yaml:130; code matches rule points #2/#5 at knowledge.py:3208–3223. Fix cost is irrelevant — the flag outranks weighing. False positive or not applicable? A repository writer can comment: |
bba530b to
a57770e
Compare
|
Source output shape this connector produces, and the ingest-factory fields it needs.
Factory requirements from the per-row ingest API: an entry that ingests ONE row as key/text/ref -> item/chunk, taking:
Question for coordination: what is the concrete API signature / field names to call once the ingest owner lands it? This connector will consume that real API in-slice; it will not adapt shared ingest/store/retrieval/sync code. |
Opus 4.8 Review — ✅ no blocking findingsReviewed Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
a57770e to
936c574
Compare
|
Per-row ingest is implemented and verified; turning it ON is blocked on stack convergence. Implemented
Verified over the real TLS loopback + real encrypted vault against faithful Blocker to flip it on: the ingest API ( Open questions:
|
UX Review (Fable 5) — ⏭️ skippedRevision |
0051c1b to
6610fd1
Compare
af3f04c to
573cf0f
Compare
573cf0f to
b3efa41
Compare
6610fd1 to
658d620
Compare
0929255 to
7effc4c
Compare
…4 F3, on current main Combined fix commit above the aligned base 1648430. Tree byte-for-byte identical to the pre-squash HEAD. Folds every L09 fix on top of the aligned base: - disconnect -> write_outcome=unknown (except tuple names ConnectionError + http.client.HTTPException) with L07 replay refusal; - CodeQL: TLS test servers pin TLSv1_2; the fencing test asserts the non-secret envelope and has NO print sink logging secret-derived data (both prior alerts 1570 and 1644 closed); - F2 (metadata): response_metadata drops an allowlisted header VALUE that echoes the outbound bearer; - F4 (test): rotation workers reaped in their own process group under tmp_path; - F1 (per-binding): L02's binding.py (single-file take of e8e11aa23, byte-identical) -> per-binding scoped secret_ref, with an honest per-binding test harness and a two-binding isolation proof; - GPT F1 (audit): execute() emits one SEL event per final authorization outcome (connections.operation.authorization); the decision is emitted AFTER the transport so a custody / live-store refusal (transport auth error) audits as DENY, not the earlier "allow before the fence"; - GPT F2 (redirect): a malformed redirect target's parse ValueError becomes a RedirectRefusedError instead of escaping the transport; - GPT F3 (store): lifecycle.py is a SINGLE-FILE take of L04's 5f69c794a (git show <sha>:.../lifecycle.py overwriting the file -- NOT a commit-level cherry-pick; byte-identical, code AST == source, comment-only edits). _read() raises BindingStoreCorruptError on a malformed record / zero-byte file; run-tested F3 guards added here (L04's own tests did not ride along with the single-file take); - gate hygiene: Brand Kiro Crew, history-narration comments -> present tense, Inclusive sanity -> coherence, PR title conventional-commits. Provenance/boundaries: binding.py == L02 e8e11aa23 (single-file take); lifecycle.py code AST == L04 5f69c794a (single-file take, comment-only edits). No vendors/**, platform/governance.py, or registry changes. Known-red by design, NOT this PR's to fix: lifecycle.py F1 (rotate drops account) and F2 (malformed-record crash) are L04's owner file and land via L04's full git integration; the E2E (stub ACP backend) failure is a workflow/MCP-spawn scenario that does not touch connections. Schema: RESULT=3, EXECUTOR=4, PRODUCTION=4, LIFECYCLE per L04. Gates: 304 passed; black/flake8/isort/mypy clean (rc non-piped); comment-history + brand pass. Named in-flight boundary: L03 (AUTH-02) still required and unimplemented.
…d KB retrieval chain Adds per-item ACL to the knowledge retrieval gate: a managed cloud/structured item is served only to a query principal whose per-candidate provider binding resolves and revalidates; trusted-local items keep serving the on-host personal library. Provenance-based classification (sourceless and unstamped => managed, fail-closed), an unforgeable trusted-creator stamp, and provenance that survives delete, dedup and bundle round-trip. Per-row structured ingest (SourceRow + connector_row_state + ingest_rows/sync) carries each row key, text, ProviderResourceRef and grant to its own item, with the checkpoint advancing only after full persistence. The shared dashboard handler registers the GitHub/Google/Salesforce connectors import-guarded and injects each vendor runner factory by the connector own keyword. Query principal is derived only from the auth middleware established identity (request app/user/is_dashboard_user), never a raw header; an authenticated app or the dashboard owner becomes a stable verified principal, and no established identity denies. The W01 AccessGrant is bridged into an AccessContext, and the verified-principal marker (QueryPrincipal.verified + principal_is_verified) supplies the trust contract W01 ControlPlaneBindingResolver requires.
… source Add GithubStructuredConnector: typed rows (issue/PR keyed by repo+number, commit by sha, check-run by id), payload conversion, since+PK-diff incremental refresh with a resumable checkpoint in the existing per-source properties blob, and mandatory per-row lineage. Conforms to BaseConnector so the existing SyncScheduler drives it; adds no second KB, registry, ACL, auth or table. Live fetch/detect_changes are parked (need W01 transport + connections.vendors.github pagination) and refuse rather than return a mocked dataset.
… rows fetched through W01's executor/transport Locate a GitHub operation, dispatch it through W01's real executor and production transport, decode the reply into the neutral payload channel, and page a real structured fetch across two pages — with no naked sender anywhere. Wire the knowledge GitHub structured source's live path onto that transport so a real fetch returns real rows and a real refresh runs. ## What changed Three new leaves under vendors/github/, plus the knowledge connector wiring and docs, all consume-only over the W01 control plane (executor.py + production.py at 423528c; schema versions EXECUTOR=4 / PRODUCTION=3 / RESULT=3 / OPERATION=2, pinned and asserted at compose time): - vendors/github/locator.py: operation_id + params -> one concrete HttpRequest, GitHub's implementation of the transport's injected RequestLocator (mirrors the Graph locator). Endpoint templates come from the existing DESCRIPTORS table; path segments are individually validated and URL-encoded; it holds no credential. - vendors/github/decoder.py: a GitHub 2xx payload -> OperationResult, GitHub's ResultDecode. It puts the fetched records into the ONE neutral data channel — a CollectionPayload for a list reply (JSON array, wrapped collection, or GraphQL nodes/edges), an ObjectPayload for a single object — via result_with_payload, and sets the SINGLE authoritative next_cursor on the envelope (the Link rel="next" URL for REST, the GraphQL endCursor for cursor tools). The collection carries no cursor of its own. - vendors/github/dispatch.py: projects a GithubOperationDescriptor into the executor's OperationDescriptor, composes the production transport with GitHub's locator and decoder, and drives execute() and PageWalk/advance_page. The full W01 gate chain and per-binding custody (BindingSecretSelector) run inside the executor. - knowledge/connectors/github_structured.py: PR-3 delta on top of the PR-2 domain model. GithubStructuredConnector takes an optional GithubTransportProvider; fetch/detect_changes drive a REAL W01 PageWalk for the repo-scoped pull-request and commit entities (invoked, authorized per page, the walk advancing on W01's single next_cursor), read the rows off ExecutionOutcome.payload, convert them with PR-2's converters, fold them through PR-2's diff_rows, and render (text, metadata). detect_changes reports changed iff the since-window returned rows. No payload copy, no second envelope, no out-of-band capture, no cache. Built with no provider, fetch/detect_changes still refuse NotImplementedError (PR-2's parked contract, unchanged). No auth, custody, retry, fencing, error classification, or pagination engine is re-implemented — all W01's. Nothing under vendors/github/ or the connector touches urllib / requests / httpx: the sole sender is W01's build_production_transport. ## Paging: a single cursor, and a question The walk advances on OperationResult.next_cursor alone. GitHub REST list endpoints carry their next-page position only in the Link response header, so the vendor decoder reads Link to POPULATE that single next_cursor; the cursor is then single and authoritative on the envelope and nothing downstream re-parses Link (ExecutionOutcome.metadata is a rate-limit-only allowlist). Because a GitHub REST list literally cannot page without Link, this decoder reading is reported as a question to the conductor rather than worked around. ## Scope: issues and check-runs reported, not written The authorized scope addition (issues list + check-runs list) needs new rows in the shared 45-op descriptors.py (owned by the W02 vendor-data slice), so the exact rows and official endpoints are reported to the conductor for coordination rather than written here. The wired kinds are pull requests and commits, both already in the table with repo-scoped REST list paths. ## Tests - test_connector_github_dispatch.py (22): the load-bearing test drives a real two-page gh_list_pull_requests fetch through the unmodified urllib_http_send over a self-signed HTTPS loopback, custody from the real encrypted SecretVault, asserting two pages, a genuine cursor advance, and the vault-resolved credential on the wire. Plus locator shaping/refusals, both decoder contracts (now payload-carrying), descriptor projection, denied-gate-sends-nothing, wrong-binding refusal. - test_knowledge_github_structured_live.py: fetch returns REAL rows across >=2 pages over TLS (keyed, rendered, credential on wire); detect_changes is True when the since-window returns rows; no-provider refuses NotImplementedError; a provider with no binding returns an empty-but-valid dataset. ## Incorporated dependency PR-2 (feat/knowledge-github-structured, db7011f) supplies the structured-source domain model — typed rows, primary keys, converters, since+key incremental diff, resumable checkpoint, rendering. It is incorporated below this commit by cherry-pick; PR-2 stays independently parked. This PR rebases to drop that commit once PR-2 lands on main. ## Pattern harvest - A vendor RequestLocator that string-concatenates a caller-supplied id into a URL path without a per-segment separator guard is an injection shape; the rule is "a path template filled from caller input encodes each segment with safe='' and rejects a '/' inside one segment". - A vendor decode that returns next_cursor=None for a body it never inspected claims completeness it cannot know; the rule is "next_cursor is None only on a provider signal (no Link rel=next, or hasNextPage false), never as a default". - A cursor carried in two places (a payload copy AND the envelope) is a second thing that can disagree; the rule is "the continuation lives on OperationResult.next_cursor and nowhere else — a payload struct carries rows, not a cursor" (W01 enforces this by removing CollectionPayload.next_cursor). Non-generalizable: the pinned W01 schema-version integers (4/3/3/2) are a coupling assertion, not a rule — dispatch.assert_schema_versions() makes a future bump a loud compose-time failure. Base is feat/connector-control-plane-executor (PR #11286, a non-main base), so CI cannot fire; local gates plus the repo's review profile are the evidence until the dependency lands on main, at which point this same PR retargets to main.
…entities, additive descriptors With the per-row ingest API integrated (merge of f5bc46a), turn the row path on for real: - github_structured.py: import the REAL kiro_crew.knowledge.rows.SourceRow and kiro_crew.knowledge.acl.ProviderResourceRef at module scope; remove the lazy-import gate and the pending-API refusal. supports_rows() returns True; fetch_rows() emits genuine SourceRows. - Four entities: issues + pull requests + commits are repo-scoped REST list walks; check-runs (no repo-wide list) are a per-commit-ref fan-out over the fetched commits, keyed on {owner,repo,ref}. - descriptors.py (this stream's own file): additive gh_list_issues_rest (GET /repos/{owner}/{repo}/issues) and gh_list_check_runs (GET /repos/{owner}/{repo}/commits/{ref}/check-runs) read/list rows, per official GitHub protocol. Nothing existing removed or narrowed; the descriptor count test moves 45->47 and READ tally 24->26 to match. ACL stays fail-closed: subjects=() (explicit deny-all) on every row — the confirmed-correct state, since real subjects need an authorized binding (repo visibility / collaborators) that is PR-4's live territory plus W01's binding identity, not something this slice may synthesise. tenant=owner (non-empty), managed=True (DTO-fixed), snapshot=False (incremental — a since-window carries only changed rows, so absent rows are not deleted), checkpoint=next_since. Tests exercise the GENUINE SourceRow/ProviderResourceRef symbols (no stand-in): the four-entity walk incl. the check-run fan-out, and the fail-closed grant, all over the real TLS loopback + real encrypted vault.
…enant honesty Fix two fetch_rows defects and add a GitHub permission probe: - Checkpoint no longer advances past a skipped or failed entity. The `since` watermark advances only when every repo-scoped entity completed, and then to the minimum across their per-entity maxima, so no entity's window is skipped over. An incomplete round keeps the old watermark. Guarded by two live tests. - Check-run refresh re-probes a bounded set of tracked commit SHAs carried in the opaque checkpoint, so a status change on an older SHA (queued -> completed) is still picked up rather than only new-this-round commits. - Add the GitHub permission probe (vendors/github/permissions.py, W02-owned): resolves repo visibility and collaborators over the real transport to derive a subject set. Live-account acceptance is deferred; rows stay fail-closed. - Tenant honesty: name the bundle tenant field `provider_tenant` and describe it as provider-supplied and unverified everywhere (connector, tests, docs). The trusted view exposes no tenant_ref, so it is never called a verified tenant and is never the repo owner passed off as one; rows remain fail-closed meanwhile. - Additive vendor descriptors: `gh_get_repository` and `gh_list_collaborators` read/list rows for the probe. Nothing removed or narrowed. Verified over real TLS loopback and encrypted vault; static and type gates clean.
658d620 to
38fae06
Compare
|
暂停关闭(Connector Production Stack 项目于 2026-09-20 整体暂停)
本次关闭不代表该工作被否决,只是项目暂停收口。 |
Problem / Motivation
Nothing in the connector stack yet invokes a GitHub operation. W01 landed the
control-plane executor and production transport (the gate chain, per-binding
custody, paging, the neutral payload channel), and the W02 GitHub vendor slice
landed the operation descriptors and wire parsing — but no leaf turned an
operation_idinto a real request, dispatched it through W01's transport,decoded the reply, and paged. The knowledge GitHub structured source could
describe rows but its
fetch/detect_changesrefused, because there was no livepath.
Why it matters
Without a real invocation path, every downstream (the knowledge structured
source, later W02 write flows) has a transport-shaped hole and can only be
described, not run. This is the slice that makes a GitHub operation actually
reachable end to end — located, authorized, dispatched, decoded, paged — so the
structured source can perform a real fetch and refresh, with no naked sender and
no re-implemented custody/auth/paging.
What changed (motivation → approach → change)
Goal: one GitHub operation genuinely invoked through W01, its rows fetched,
across ≥2 pages, with the structured source wired onto it.
Approach: three thin, consume-only leaves under
vendors/github/, plus theknowledge connector wiring — re-implementing none of W01's judgment. The vendor
owns only two things W01 injects: turning an
operation_id+params into a request(
locator.py) and turning a 2xx reply into the neutralOperationResult(
decoder.py).dispatch.pycomposes W01'sbuild_production_transportwiththose two and drives
execute()andPageWalk/advance_page, so the full gatechain and per-binding custody run inside the executor.
Change:
locator.py—operation_id+params → one concreteHttpRequest, off theexisting
DESCRIPTORStable, path segments individually validated andURL-encoded, no credential (the transport attaches it).
decoder.py— a 2xx reply →OperationResultcarrying the rows in the ONEneutral data channel: a
CollectionPayloadfor a list reply (JSON array,wrapped collection, or GraphQL
nodes/edges), anObjectPayloadfor asingle object, via
result_with_payload. The SINGLE authoritativenext_cursorgoes on the envelope (theLinkrel="next"URL for REST, theGraphQL
endCursorfor cursor tools); the collection carries no cursor.dispatch.py— projects the vendor descriptor into the executor'sOperationDescriptor, composes the transport, drivesexecute()+PageWalk/advance_page. Pins and asserts the W01 seam versions:EXECUTOR_SCHEMA_VERSION=4,PRODUCTION_SCHEMA_VERSION=3,RESULT_SCHEMA_VERSION=3,OPERATION_SCHEMA_VERSION=2.knowledge/connectors/github_structured.py— PR-3 delta on the incorporatedPR-2 domain model:
GithubStructuredConnector(transport_provider=...)drives areal
PageWalkfor the repo-scoped pull-request and commit entities, reads therows off
ExecutionOutcome.payload, runs PR-2's converters, folds throughdiff_rows, and renders(text, metadata).detect_changesreports changediff the
sincewindow returned rows. No provider → still refusesNotImplementedError(PR-2's parked contract).No naked sender anywhere: nothing under
vendors/github/or the connectortouches
urllib/requests/httpx; the sole sender is W01'sbuild_production_transport, which resolves the credential per call and revealsit into a header inside the transport.
Before → After (the invocation path):
flowchart LR subgraph before["Before 🟥"] B1["operation_id"]:::ctx --> B2["(no caller)"]:::removed B2 -.->|dropped| B3["network"]:::ctx end subgraph after["After 🟩"] A1["operation_id + params"]:::ctx --> A2["locator.py<br/>→ HttpRequest"]:::added A2 --> A3["W01 execute()/PageWalk<br/>gate chain + custody"]:::ctx A3 --> A4["decoder.py<br/>→ payload + next_cursor"]:::added A4 --> A5["typed rows via diff_rows"]:::added end classDef added fill:#DCFCE7,stroke:#16A34A; classDef removed fill:#FEE2E2,stroke:#DC2626,stroke-dasharray:4 3; classDef ctx fill:#E0F2FE,stroke:#0284C7;🟩 added · 🟥 removed · 🟦 unchanged — the operation now reaches the network only through W01's transport, and the rows come back on the single
ExecutionOutcome.payload.Tests
test_connector_github_dispatch.py— the load-bearing test drives a realtwo-page
gh_list_pull_requestsfetch through the unmodifiedurllib_http_sendover a self-signed HTTPS loopback (page 1 returns aLink: rel="next", page 2 does not), custody served by the real encryptedSecretVault, asserting two pages fetched, a genuine cursor advance, and thevault-resolved credential on the wire. Plus locator shaping and its refusals,
both decoder contracts (payload-carrying), the descriptor projection, a denied
gate sending nothing, and a wrong-binding selector refusing before any send.
test_knowledge_github_structured_live.py—fetchreturns REAL rows across≥2 pages over TLS (keyed, rendered, credential on the wire);
detect_changesis True when the
sincewindow returns rows; no-provider refusesNotImplementedError; a provider with no binding returns an empty-but-validdataset.
No real account, token, or org data is touched — controlled TLS plus a fixture
Vault only.
Manual verification
N/A — unit coverage over the real transport (real TLS loopback + real encrypted
vault) is the verification; there is no UI. CI cannot run on this non-main base
(PR #11286's
feat/connector-control-plane-executor), so the local gate floor(related tests, isort, flake8, mypy) plus this repo's review profile are the
evidence until the dependency lands on main, at which point this same PR
retargets to main and re-verifies.
Coordination notes for the maintainer
rows in the shared 45-op
descriptors.py(owned by the W02 vendor-dataslice): a repo-scoped issues list (
GET /repos/{owner}/{repo}/issues, RESTpage/perPage,
Link) and a check-runs list(
GET /repos/{owner}/{repo}/commits/{ref}/check-runs, REST page/perPage,wrapped under
check_runs). Reported for coordination, not written, per theshared-file rule. The wired kinds are pull requests and commits, both already
in the table.
per-row ingest contract —
supports_rows()+fetch_rows()returningSourceRows with their ownProviderResourceRefand a fail-closed ACLgrant (empty
subjects= deny-all,tenant=owner,managed=True). But thatAPI (
knowledge.rows/knowledge.acl/ingestion.ingest_rows, PR feat(knowledge): query-time ACL + revocation isolation in the shared KB retrieval chain #11219)lives in files this slice does not own and on a main-based branch, while
this PR is stacked on W01 (PR feat(connections): W01 L09 control-plane executor, real transport, neutral data channel #11286). The two stacks do not share a base,
and this slice may not add or edit those shared files, so the API is not
importable here yet.
supports_rows()is therefore gated on the API beingimportable (False until it lands on this base);
fetch_rowsis writtenagainst the real contract and verified against faithful stand-ins. Question:
how should the W01-stacked branch and the main-based ingest branch converge so
this consumer can import the real API — both on main, a combined base, or the
ingest DTOs added to this base by their owner?
subjectsis fail-closedto deny-all here because this slice has no evidence mapping a GitHub object to
the subjects allowed to see it. Making a row public (or granting real
subjects) needs a source of that evidence (a public-repo signal, the binding's
subject/tenant). Where does it come from?
Paging note: GitHub REST list endpoints carry their next-page position only in
the
Linkheader, so the decoder readsLinkwhere it decodes the reply andturns it into the single
next_cursor— the established interface, with nosecond cursor and nothing downstream re-parsing
Link.Pattern harvest
Whether the defect generalizes into a checkable static rule:
RequestLocatorthat string-concatenates a caller-supplied id into aURL path without a per-segment separator guard is an injection shape — the
checkable rule is "a path template filled from caller input encodes each
segment with
safe=''and rejects a/inside one segment".next_cursor=Nonefor a body it never inspectedclaims completeness it cannot know — "
next_cursorisNoneonly on aprovider signal (no
Link rel=next, orhasNextPagefalse), never as adefault".
thing that can disagree — "the continuation lives on
OperationResult.next_cursorand nowhere else; a payload struct carries rows,not a cursor" (W01 enforces this by removing
CollectionPayload.next_cursor).Non-generalizable: the pinned W01 schema-version integers (4/3/3/2) are a
coupling assertion, not a rule —
dispatch.assert_schema_versions()makes afuture bump a loud compose-time failure.
no linked issue: this is a campaign stack slice (W02 PR-3), not a tracked bug.