From 65d24fb88f8e1c974d56e34ca543b5cca5a2acf5 Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Fri, 20 Nov 2026 13:02:23 +0000 Subject: [PATCH] Record the party selection resume integration gap --- docs/roadmap/remediation.md | 100 +++++++++++++++++++++++++++++++++--- 1 file changed, 93 insertions(+), 7 deletions(-) diff --git a/docs/roadmap/remediation.md b/docs/roadmap/remediation.md index dfd1886..4d259a8 100644 --- a/docs/roadmap/remediation.md +++ b/docs/roadmap/remediation.md @@ -10,8 +10,10 @@ were treated as claims to verify rather than proof of completion. The native command boundary, actual ConfigKit inspection results, separate domain catalogs, independent selections, reporting, and cancellation architecture are -substantially implemented. The following three P2 findings require remediation. -This review makes no application changes. +substantially implemented. The initial pass identified findings 1–3. An +integration-focused follow-up at `8be65fd` adds finding 4; the application source +is unchanged from the initial review. All four P2 findings remain open. +These reviews make no application changes. ## 1. P2: Preserve campaign inheritance when materializing session documents @@ -125,6 +127,54 @@ do not change it to satisfy the obsolete wording. This is a documentation-only correction, separate from preserving inherited versus explicit fields during materialization in finding 1. +## 4. P2: Keep party-selection provenance out of prepare resume identity + +Stages: 4–7, 10–11, and 21. + +Locations: `internal/config/party_resolution.go:70–81`, +`internal/stage/semantic_contracts_initial.go:151–171`, +`internal/app/semantic_resume.go:44–45`, and +`internal/app/run_control.go:78–83`. + +The new explicit party selector labels its source `party_file`; campaign-default +selection labels the same roster `campaign_config`. Existing prepare semantic +evidence hashes that source label in `prepareStableInputSelection.Source`. +Selecting the very same file explicitly changes the semantic fingerprint even +when the canonical roster, players projection, derived catalog, and all prepared +file contents are unchanged. + +An end-to-end native-invocation diagnostic reproduced this sequence: + +1. Run `prepare` successfully using the campaign-default roster and record a + succeeded downstream `transcribe` stage. +2. Plan the same session with `--party-file` pointing to that same roster. The + planner reports `result-affecting configuration changed; rerun the stage`. +3. Execute that bounded prepare request without force. Prepare executes again, + and the previously succeeded transcription stage becomes stale. Every + prepared input path/checksum pair remains identical. + +The normal invalidation relation also applies to other succeeded downstream +stages. A subsequent full run can therefore schedule unnecessary downstream +processing solely because the operator made the source selection explicit. +The selector and existing semantic-resume implementation work independently, +but their integration turns provenance into result identity, contrary to the +roadmap's result-affecting evidence boundary. This is separate from finding 1: +the reproduction requires no serialization/reload or campaign-default change. + +Required remediation: + +- Keep the selected source label in appropriate provenance and inspection + records. Exclude or semantically normalize the provenance-only distinction in + prepare's reuse fingerprint. Review equivalent stable-input source labels + under the same result-affecting rule without weakening content validation. +- Continue detecting actual roster/players/input changes through existing + canonical payload checksums and stage/artifact evidence. Preserve the fixed + downstream invalidation relation when inputs really change. +- Add an integration regression covering native planning and execution with + default versus explicit selection of the same roster, unchanged prepared + bytes, and retained downstream success. Include changed roster contents as a + counterexample that must invalidate affected work. + ## Stage-by-stage coverage | Stage | Evidence reviewed and result | @@ -132,14 +182,14 @@ materialization in finding 1. | 1 | Released module selection, native application/process boundary, lazy construction, and outcome adapter; finding 2 covers classification gaps. | | 2 | Retained pipeline/campaign results, lifecycle normalization/validation, native metadata, and absence of replacement inspection results. | | 3 | Campaign defaults, explicit presence, session assertions, and resource bases; findings 1 and 2 cover materialization and native assertion outcomes. | -| 4 | Selected-party results/players, pure family expansion, collision/dependency checks, and separate publication rules. | +| 4 | Selected-party results/players, pure family expansion, collision/dependency checks, and separate publication rules; finding 4 covers resume integration. | | 5 | Concrete-catalog consumers in planning, analysis, semantic fingerprints, adapter composition, and runtime registration. | -| 6 | Preparation, publication, restore round trips, and semantic evidence; finding 1 covers inherited input serialization. | +| 6 | Preparation, publication, restore round trips, and semantic evidence; findings 1 and 4 cover serialization and provenance-sensitive reuse. | | 7 | Exact-file/local/remote acquisition, source labels, one-time bootstrap, retained errors, and resource cleanup; finding 2 covers typed input classification. | | 8 | Four native scopes, path/history/findings capabilities, aggregate behavior, and lazy acquisition. | | 9 | Independent comparison inputs/defaults, app-only overrides, native difference reports and status 3; finding 2 covers assertion failures. | | 10 | Native bounded run/regeneration wiring, force and artifact selection, and shared execution; finding 2 covers invalid domain configuration. | -| 11 | Shared read-only planning, publication actions, and configured artifact catalog reporting. | +| 11 | Shared read-only planning, publication actions, and configured artifact catalog reporting; finding 4 affects planned reuse. | | 12 | Structured validation/status/artifact inspection, partial findings, local/remote evidence, and read-only behavior. | | 13 | Initialization targets, authoring contexts, generated YAML, explicit lock commands, and conditional lock mutations; finding 1 covers inherited defaults. | | 14 | Restore and cleanup declarations, dry-run behavior, exact action reports, confinement, conflicts, and partial failure handling. | @@ -151,8 +201,8 @@ materialization in finding 1. | 20 | Canonical references, workflows, migration table, attribution, supported platforms, and preserved release history; findings 1 and 3 cover remaining documentation divergence. | | 21 | Full test/race suites, vet/build, assembled workflows, focused review reproductions, and remaining verification recorded below. | -No other actionable requirement strengthening was identified. The removed CLI -aliases, native flag conventions, inspection-only overrides, domain/native-view +The initial pass identified no other actionable requirement strengthening. +The removed CLI aliases, native flag conventions, inspection-only overrides, domain/native-view separation, and deferred workspace/downstream changes follow the agreed scope. ## Review validation @@ -174,3 +224,39 @@ Using official Go 1.27.4 against the reviewed application source: Only this remediation document changes the repository. No release, tag, push, CI polling, or live downstream service invocation was performed. + +## Integration follow-up coverage and validation + +The follow-up traversed the stages in order, emphasizing existing consumers: + +- Stages 1–3: process/CLI inputs into existing loaders, validation callers, + authoring-context initialization, and materialized input consumers. +- Stage 4: selected-party provenance and canonical roster/players derivation. +- Stage 5: concrete catalog/dependency consumers in planning, execution, + adapter composition, previous-session requirements, and runtime registration. +- Stage 6: semantic fingerprints, preparation comparisons, publication actions, + and restored input records. Finding 4 is an additional resume-integration gap. +- Stage 7: explicit/default source selection into existing identity checks, + local/remote acquisition, storage, and temporary-resource cleanup. +- Stages 8–9: native scope acquisition, independent comparison state, and + invocation-local overrides against the retained load results. +- Stages 10–11: bounded run/regeneration and plan decisions against existing + resume validation, analysis target closure, and dependent invalidation. +- Stages 12–14: inspection, initialization, locks, restore, and cleanup against + local manifests, pointer-selected remote declarations, conditional lock + updates, confinement, and existing action-report persistence. +- Stages 15–16: partial results and cancellation against speaker/artifact + checkpoints, terminal persistence, adapter contexts, and local lock release. +- Stages 17–19: progress/diagnostic delivery across existing concurrent workers + and captured subprocess logs; native lazy discovery and retired routing. +- Stages 20–21: current operator contracts and maintained workflow fixtures + against the assembled boundaries above. + +Application source remained unchanged. The initial full tests, race tests, vet, +build, module, and supported-target checks therefore remain applicable. This +pass additionally reran `go test` for `internal/app`, `internal/config`, +`internal/stage`, `internal/artifacts`, `internal/audio`, and `internal/manifest`; +all passed on Go 1.27.4. A new native-invocation Go-overlay diagnostic reproduced +finding 4 under `-race` and verified unchanged prepared input checksums. Its +files remained under `/tmp`. Documentation checks and whitespace validation +were repeated for this document update.