@bovinphang/craft-common 1.0.0 → 2.0.0

package/skills/cc-go-concurrency/references/common/engineering-practices.sources.json

@@ -0,0 +1,377 @@
+{
+  "schemaVersion": 1,
+  "sources": [
+    {
+      "id": "google-review",
+      "publisher": "Google",
+      "title": "Code review standard",
+      "url": "https://google.github.io/eng-practices/review/reviewer/standard.html",
+      "section": "Engineering principles and code health",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living public guidance; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Use evidence and project standards; personal preference alone is not a blocker."
+    },
+    {
+      "id": "ms-playbook",
+      "publisher": "Microsoft ISE",
+      "title": "Test planning",
+      "url": "https://microsoft.github.io/code-with-engineering-playbook/automated-testing/test-planning/",
+      "section": "Risk, test scope and responsibilities",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living ISE playbook; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Team practice, not a company-wide mandate; retain existing tools."
+    },
+    {
+      "id": "ms-faults",
+      "publisher": "Microsoft ISE",
+      "title": "Fault injection testing",
+      "url": "https://microsoft.github.io/code-with-engineering-playbook/automated-testing/fault-injection-testing/",
+      "section": "Controlled failure and observations",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living ISE playbook; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Run scoped, controlled failures; do not infer production reliability from a small example."
+    },
+    {
+      "id": "google-ts",
+      "publisher": "Google",
+      "title": "TS/JS style guide",
+      "url": "https://google.github.io/styleguide/tsguide.html",
+      "section": "Environment caveat; types and exceptions",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Public guide; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Google explicitly notes internal constraints differ; no blanket ban overriding a justified project convention."
+    },
+    {
+      "id": "typescript-publishing",
+      "publisher": "TypeScript",
+      "title": "Publishing declaration files",
+      "url": "https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html",
+      "section": "Types and declaration dependencies",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living handbook; check installed compiler/module resolution",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Validate the actual packed consumer; do not upgrade compiler or module mode on this basis."
+    },
+    {
+      "id": "rust-api",
+      "publisher": "Rust library team",
+      "title": "Rust API Guidelines",
+      "url": "https://rust-lang.github.io/api-guidelines/",
+      "section": "Type safety, dependability and future proofing",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living recommendations; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Guidance rather than language law; preserve edition and MSRV."
+    },
+    {
+      "id": "tokio-join",
+      "publisher": "Tokio project",
+      "title": "JoinHandle",
+      "url": "https://docs.rs/tokio/latest/tokio/task/struct.JoinHandle.html",
+      "section": "Drop, abort and completion",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Page observed 1.54.1; project runtime/version determines applicability",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Tokio-specific mechanics only when Tokio is already used; no new runtime dependency."
+    },
+    {
+      "id": "uber-go",
+      "publisher": "Uber",
+      "title": "Go Style Guide",
+      "url": "https://github.com/uber-go/guide/blob/master/style.md",
+      "section": "Errors, interfaces and goroutine lifetime",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living master; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Do not import Uber dependencies or turn buffer-size style into a correctness theorem."
+    },
+    {
+      "id": "go-context",
+      "publisher": "Go project",
+      "title": "context package",
+      "url": "https://pkg.go.dev/context",
+      "section": "Cancellation propagation and ownership",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Standard library; check owning go.mod/toolchain",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "A cancellation signal alone does not confirm worker exit."
+    },
+    {
+      "id": "google-java",
+      "publisher": "Google",
+      "title": "Java Style Guide",
+      "url": "https://google.github.io/styleguide/javaguide.html",
+      "section": "Source structure and exception handling",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living public style; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Naming/layout follows local standard; style is distinct from runtime correctness."
+    },
+    {
+      "id": "oracle-resources",
+      "publisher": "Oracle",
+      "title": "Try-with-resources",
+      "url": "https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html",
+      "section": "Closing resources and suppressed exceptions",
+      "checkedAt": "2026-11-08",
+      "versionScope": "JDK8 tutorial; not a source for newer runtime features",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Preserve primary cause and borrowed-resource ownership; check actual API contract."
+    },
+    {
+      "id": "java-executor",
+      "publisher": "Oracle",
+      "title": "ExecutorService",
+      "url": "https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/ExecutorService.html",
+      "section": "Shutdown, termination and awaitTermination",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Java SE17 documentation",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Check target JDK; no automatic virtual-thread or JDK migration."
+    },
+    {
+      "id": "google-python",
+      "publisher": "Google",
+      "title": "Python Style Guide",
+      "url": "https://google.github.io/styleguide/pyguide.html",
+      "section": "Imports, exceptions and mutable state",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living public guide; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Keep current formatter/type checker and library responsibilities."
+    },
+    {
+      "id": "python-asyncio",
+      "publisher": "Python project",
+      "title": "Coroutines and tasks",
+      "url": "https://docs.python.org/3/library/asyncio-task.html",
+      "section": "Cancellation and task ownership",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Page observed 3.15.2; feature availability follows project Python",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Newer TaskGroup/timeout features require a supported project version; no upgrade implied."
+    },
+    {
+      "id": "cert-c",
+      "publisher": "CMU SEI",
+      "title": "MEM00-C allocation and release",
+      "url": "https://cmu-sei.github.io/secure-coding-standards/sei-cert-c-coding-standard/recommendations/memory-management-mem/mem00-c/",
+      "section": "MEM00-C memory responsibility",
+      "checkedAt": "2026-11-08",
+      "versionScope": "2016-edition standard family; MEM00-C is a recommendation",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Do not label recommendations as mandatory CERT rules or apply C++ ownership machinery to pure C."
+    },
+    {
+      "id": "cpp-core",
+      "publisher": "C++ Core Guidelines editors",
+      "title": "C++ Core Guidelines",
+      "url": "https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines",
+      "section": "Resource and lifetime interfaces",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Page dated 2026-06-14, living release0.8",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Adapt to existing exception policy and compiler; borrowing does not imply ownership."
+    },
+    {
+      "id": "google-cpp",
+      "publisher": "Google",
+      "title": "C++ Style Guide",
+      "url": "https://google.github.io/styleguide/cppguide.html",
+      "section": "Exceptions and project consistency",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living public guide; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Its exception/standard policy is not universal; preserve the owning project policy and C ABI."
+    },
+    {
+      "id": "ms-sal",
+      "publisher": "Microsoft",
+      "title": "Understanding SAL",
+      "url": "https://learn.microsoft.com/en-us/cpp/code-quality/understanding-sal?view=msvc-170",
+      "section": "Parameter preconditions and output guarantees",
+      "checkedAt": "2026-11-08",
+      "versionScope": "MSVC170 documentation view",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "SAL is an optional toolchain-specific expression, not a portable mandatory annotation."
+    },
+    {
+      "id": "aws-retry",
+      "publisher": "AWS",
+      "title": "Timeouts, retries and backoff with jitter",
+      "url": "https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/",
+      "section": "Timeouts, bounded retries and retry amplification",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Article dated 2019-12-05; official Builder Center redirect",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Retry only semantically safe operations within a total budget; failure classes alone do not grant write replay."
+    },
+    {
+      "id": "aws-idempotency",
+      "publisher": "AWS",
+      "title": "Making retries safe with idempotent APIs",
+      "url": "https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/",
+      "section": "Caller intent, duplicate requests and atomic recording",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Builders Library; revision unknown",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "A process-local example does not establish database/multi-process exactly-once."
+    },
+    {
+      "id": "react-effects",
+      "publisher": "React project",
+      "title": "useEffect",
+      "url": "https://react.dev/reference/react/useEffect",
+      "section": "Cleanup and fetching race conditions",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Page observed React19.3; use installed project API",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "Abort and stale-result checks complement each other; no React upgrade implied."
+    },
+    {
+      "id": "react-act",
+      "publisher": "React project",
+      "title": "act",
+      "url": "https://react.dev/reference/react/act",
+      "section": "Applying updates before assertions",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Page observed React19.3; verify sample versions",
+      "licenseStatus": "unknown",
+      "adoption": "adopt",
+      "limits": "DOM simulation is not browser E2E or native desktop execution."
+    },
+    {
+      "id": "vue-watchers",
+      "publisher": "Vue project",
+      "title": "Watchers",
+      "url": "https://vuejs.org/guide/essentials/watchers.html",
+      "section": "Side-effect cleanup",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Vue3; onWatcherCleanup requires3.5+ and synchronous registration",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Use supported callback cleanup on older Vue3; no framework migration."
+    },
+    {
+      "id": "tauri-permissions",
+      "publisher": "Tauri project",
+      "title": "Permissions",
+      "url": "https://v2.tauri.app/security/permissions/",
+      "section": "Command allow/deny and capability scope",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Tauri2 docs; check installed version/configuration",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Rust command-unit tests do not activate webview permissions or prove packaged GUI security."
+    },
+    {
+      "id": "electron-security",
+      "publisher": "Electron project",
+      "title": "Security",
+      "url": "https://www.electronjs.org/docs/latest/tutorial/security",
+      "section": "IPC sender checks and renderer trust",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living docs; match installed Electron",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Handler tests do not prove sandbox/context isolation is active in a packaged app."
+    },
+    {
+      "id": "spring-tests",
+      "publisher": "Spring project",
+      "title": "Testing Spring Boot applications",
+      "url": "https://docs.spring.io/spring-boot/3.5/reference/testing/spring-boot-applications.html",
+      "section": "Test slices and application tests",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Boot3.5 docs observed3.5.16; preserve sample/project versions",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Test scope matters; MVC tests do not establish live DB/transaction or deployment behavior."
+    },
+    {
+      "id": "fastapi-lifespan",
+      "publisher": "FastAPI project",
+      "title": "Lifespan events",
+      "url": "https://fastapi.tiangolo.com/advanced/events/",
+      "section": "Acquire and release application resources",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living FastAPI documentation; match pinned dependencies",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Use actual lifespan execution in tests; import does not own a live connection."
+    },
+    {
+      "id": "gin-binding",
+      "publisher": "Gin project",
+      "title": "Binding",
+      "url": "https://gin-gonic.com/en/docs/binding/",
+      "section": "Binding errors and validation",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living Gin documentation; match pinned module",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Writing/aborting a response does not replace explicit control-flow return in the current handler."
+    },
+    {
+      "id": "axum-extractors",
+      "publisher": "Axum project",
+      "title": "Extractors",
+      "url": "https://docs.rs/axum/latest/axum/extract/",
+      "section": "Extractor order and rejections",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Latest route observed0.8.9; fixed0.8.9 route unavailable via browser tool",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Pinned existing example is authoritative for compilation; do not assume source signatures across releases."
+    },
+    {
+      "id": "drogon-filters",
+      "publisher": "Drogon project",
+      "title": "Middleware and Filter",
+      "url": "https://github.com/drogonframework/drogon/wiki/ENG-05-Middleware-and-Filter",
+      "section": "Filter callbacks and continuation",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Living wiki; match compiled example version",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Synthetic role headers are not authentication; callback lifetime must follow actual ownership."
+    },
+    {
+      "id": "node-typescript",
+      "publisher": "Node.js project",
+      "title": "Modules: TypeScript",
+      "url": "https://nodejs.org/api/typescript.html",
+      "section": "Type-stripping history, enabling, and separate type checking",
+      "checkedAt": "2026-11-08",
+      "versionScope": "Page observed26.13.0; sample>=22.18, actual24.14.1 tested; product Node>=22 unchanged",
+      "licenseStatus": "unknown",
+      "adoption": "conditional",
+      "limits": "Native stripping is not type checking and ignores tsconfig. Missing sample capability is MISSING, not a product runtime upgrade."
+    }
+  ]
+}

package/skills/cc-go-concurrency/references/engineering-practices.md

@@ -0,0 +1,73 @@
+---
+practiceCards:
+  - id: "cc-go-concurrency:shutdown-wait"
+    level: "required"
+    sourceIds: ["go-context","uber-go"]
+    caseIds: ["EP-GO-01"]
+    evidence: "review-only"
+  - id: "cc-go-concurrency:channel-ownership"
+    level: "conditional"
+    sourceIds: ["uber-go","go-context"]
+    caseIds: ["EP-GO-01"]
+    evidence: "review-only"
+---
+
+# Local engineering decisions
+
+Locate the actual role, toolchain and existing conventions, then read relevant [shared principles](common/engineering-practices.md). These conditions apply to this entry, not every project. Structure checks do not prove all semantics or execution.
+
+<a id="cc-go-concurrency:shutdown-wait"></a>
+## Shutdown includes confirmation of worker exit
+
+Level: required
+
+### Risk
+Cancel-and-return can release files while goroutines still access them.
+
+### Applies
+For goroutines this component starts in any application role; borrowed workers stay with their declared owner.
+
+### Decision
+Keep completion accounting, stop admission, propagate cancellation at blocking points and wait before releasing shared resources. Define an explicit deadline and incomplete outcome.
+
+### Exceptions
+A buffered channel may change capacity, not ownership or termination. Fire-and-forget requires an application lifetime owner and bounded error reporting.
+
+### Examples
+Better: the local pipeline observes both workers exiting. Worse: cancel is called and a successful shutdown is reported immediately.
+
+### Verification
+Use start/finish events and saturation, early-consumer-exit and repeated-stop cases. The local watchdog is a failure bound; race checking is additional.
+
+### Sources
+go-context, uber-go — [registry and limits](common/engineering-practices.sources.json).
+
+Evidence IDs: EP-GO-01; review-only.  Execution status and scope require actual records; a related ID does not prove every decision on this card.
+
+<a id="cc-go-concurrency:channel-ownership"></a>
+## Closing is a protocol owned by the sender side
+
+Level: conditional
+
+### Risk
+Concurrent send and close can panic even when individual accesses look guarded.
+
+### Applies
+When consumers depend on channel closure or multiple producers share a channel.
+
+### Decision
+Assign one closing coordinator, confirm all sends ended before close, and define receiver behavior. Cancellation and completion must unblock both directions without a recover-based disguise.
+
+### Exceptions
+Not every channel needs closing; if completion is signaled elsewhere and nobody ranges until close, preserve that protocol. Channel capacity is not a universal correctness rule.
+
+### Examples
+Better: producer coordinator waits then closes once. Worse: each receiver closes the shared channel on cancellation.
+
+### Verification
+Arrange competing send/close and receiver-exit events deterministically; separately run supported race checks. The pipeline case validates cancellation, not every closing topology.
+
+### Sources
+uber-go, go-context — [registry and limits](common/engineering-practices.sources.json).
+
+Evidence IDs: EP-GO-01; review-only.  Execution status and scope require actual records; a related ID does not prove every decision on this card.

package/skills/cc-go-concurrency/references/practice.md

@@ -0,0 +1,37 @@
+# Go concurrency lifecycle
+
+## Specialist checks
+
+1. List goroutine starters, stop signals, blocking operations and the party that waits for completion. A caller completion does not prove worker exit.
+
+2. Use context-aware blocking points and bounded concurrency. A sender must have a path out when the receiver leaves.
+
+3. Give channel closure to a clear owner; for multiple senders coordinate completion before close. Do not use recover to conceal send/close races.
+
+4. Choose synchronization from shared-state invariants and happens-before needs. Locks, channels and atomics have different correctness responsibilities.
+
+5. Cover cancellation, early consumer exit, queue saturation and concurrent shutdown with barriers or controllable events.
+
+6. Run available race tests and inspect repeated-run worker/stack evidence. Passing a finite test cannot prove all interleavings safe.
+
+<a id="scope"></a>
+## Scope and examples
+
+Use for:
+- Stop Go workers blocked on channel sends
+- Define who closes a shared Go channel
+- Bound goroutines and propagate request cancellation
+- Reproduce and test a Go data race
+
+Use broader Go engineering guidance for module/package organization; buffering alone does not establish a safe lifecycle.
+
+## Evidence to deliver
+
+- Repository/contract evidence and the exact affected scope.
+- Chosen approach, invariants, resource/error or failure boundaries.
+- Commands actually run and results, unrun checks and unproven claims.
+- Compatibility, recovery/rollback or follow-up limits; review findings need verified locations.
+
+## Primary reference
+
+[Relevant official/project documentation](https://go.dev/ref/mem) (checked 2026-11-06). Match the actual project version before applying version-sensitive details; the page version does not authorize an upgrade.

package/skills/cc-go-project-standard/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: cc-go-project-standard
+description: "Use when Go module/workspace organization, package ownership, error and context conventions, dependency boundaries or engineering validation need design or review."
+---
+
+# Go project engineering
+
+Apply to libraries, CLI tools, desktop cores and services. Determine the application role from the actual project; a frontend/backend product name does not constrain the language.
+
+Locate go.work and the nearest go.mod; preserve module import paths and dependency versions. Do not run a root-level go get simply because the task is in a submodule.
+
+## Apply the workflow
+
+1. Locate the actual project, task boundary and existing contracts; load only the language and domain material needed now.
+2. Apply the [specialist checks](references/practice.md), establishing the input evidence before selecting the smallest change.
+3. Verify affected behavior with existing repository tools. Explicitly report missing tools, environments or execution; a plan is not a passing result.
+4. Deliver scope, specialist decisions, actual verification and remaining risk. A review-only task stays read-only.
+
+## Task boundary
+
+A focused goroutine/channel lifecycle defect belongs to the concurrency specialty.
+
+## Engineering practices
+
+Read the [local engineering decisions](references/engineering-practices.md) for this task and follow their links to relevant shared principles. Apply levels and exceptions against actual project contracts; product frontend/backend labels do not constrain language or role.

package/skills/cc-go-project-standard/examples/engineering/README.md

@@ -0,0 +1,7 @@
+# Cancellation and completion — EP-GO-01
+
+Copy this standalone Go module to a writable directory. No downloaded modules are needed. With the declared Go1.20+ toolchain, first `go test -run=^$ ./...` (preparation/compilation, not behavior evidence). Then run `go test -json -count=1 -timeout=15s ./...` with `CRAFT_ENGINEERING_DEFECTIVE=1` and again with `=0` (default). PowerShell: set `$env:CRAFT_ENGINEERING_DEFECTIVE` before the same command; POSIX: prefix the command with the assignment. For offline runs set `GOPROXY=off GOTOOLCHAIN=local GOSUMDB=off`.
+
+An event confirms a worker acquired a value. With no output receiver, the defect blocks both worker paths despite cancellation; its named assertion fails at the five-second watchdog. This timeout bounds failure rather than establishing ordering by sleeping. The protected path observes context at both blocking boundaries and Stop waits for both workers. The intentionally stalled defective test process terminates after reporting failure; it is not production shutdown code.
+
+This does not prove every schedule or race freedom. Run the project's scoped race checks separately where supported. No parent source, database or HTTP stack is involved.

package/skills/cc-go-project-standard/examples/engineering/go.mod

@@ -0,0 +1,3 @@
+module example.invalid/engineering-pipeline
+
+go 1.20

package/skills/cc-go-project-standard/examples/engineering/lifecycle.go

@@ -0,0 +1,71 @@
+package pipeline
+
+import (
+	"context"
+	"os"
+	"sync"
+	"sync/atomic"
+)
+
+// Pipeline owns both workers. Its caller owns deciding when to stop.
+type Pipeline struct {
+	cancel  context.CancelFunc
+	workers sync.WaitGroup
+	entered chan struct{}
+	output  chan int
+	exited  atomic.Int32
+}
+
+func NewPipeline(parent context.Context) *Pipeline {
+	ctx, cancel := context.WithCancel(parent)
+	p := &Pipeline{cancel: cancel, entered: make(chan struct{}), output: make(chan int)}
+	jobs := make(chan int)
+	defective := os.Getenv("CRAFT_ENGINEERING_DEFECTIVE") == "1"
+	p.workers.Add(2)
+	go func() {
+		defer p.workers.Done()
+		defer p.exited.Add(1)
+		for n := 1; ; n++ {
+			if defective {
+				jobs <- n
+				continue
+			} // Deliberately cannot observe cancellation while blocked.
+			select {
+			case <-ctx.Done():
+				return
+			case jobs <- n:
+			}
+		}
+	}()
+	go func() {
+		defer p.workers.Done()
+		defer p.exited.Add(1)
+		var once sync.Once
+		for {
+			var value int
+			if defective {
+				value = <-jobs
+			} else {
+				select {
+				case <-ctx.Done():
+					return
+				case value = <-jobs:
+				}
+			}
+			once.Do(func() { close(p.entered) })
+			if defective {
+				p.output <- value
+				continue
+			}
+			select {
+			case <-ctx.Done():
+				return
+			case p.output <- value:
+			}
+		}
+	}()
+	return p
+}
+
+// Stop cancels and confirms termination, rather than merely signaling interest ended.
+func (p *Pipeline) Stop() { p.cancel(); p.workers.Wait() }

package/skills/cc-go-project-standard/examples/engineering/lifecycle_test.go

@@ -0,0 +1,22 @@
+package pipeline
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestCancellationWaitsForBoth(t *testing.T) {
+	p := NewPipeline(context.Background())
+	<-p.entered // The worker owns a value; output deliberately has no receiver.
+	done := make(chan struct{})
+	go func() { p.Stop(); close(done) }()
+	select {
+	case <-done:
+		if p.exited.Load() != 2 {
+			t.Fatalf("EP-GO-01 expected both workers exited, got %d", p.exited.Load())
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("EP-GO-01 cancellation must unblock and finish both workers")
+	}
+}