chore: workspace green check (Task 56)

Three issues uncovered by the full pnpm typecheck/test/boundaries pass
and resolved here:

- core-testing was importing IEventBus / IJobQueue from core-events /
  core-shared, creating two boundary violations (tooling → core) and a
  build-graph cycle. Inlined the type aliases (mirroring how
  RecordingTracer / RecordingLogger handle ITracer / ILogger).
  recording-event-bus.test.ts replaces defineEvent() with an inline
  descriptor literal so no runtime import is needed either. core-events
  and core-shared are removed from core-testing dependencies.

- turbo.json: typecheck and test no longer dependsOn ^typecheck / ^build.
  Each package's tsc / vitest resolves cross-package types via
  node_modules independently, and dropping the topological dep avoids the
  spurious cycle warning that appeared once core-testing started
  importing core-events / core-shared.

- turbo.json: feature.dependencies.allow gains "feature". Cross-feature
  event flow (ADR-015) requires a consumer feature to import the
  publisher's event contract directly. The dangerous form (importing
  the publisher's handler/use-case/repo) is still blocked by E1's
  no-handler-reexport ESLint rule and the missing public exports.

- TaskConfig<"slug-string"> → TaskConfig<{ input; output }> in the gen
  job task template (and the shipped send-welcome-email.task.ts) since
  runtime-generated slugs aren't keys of TypedJobs['tasks'].

packages/core-testing/src/instrumentation/recording-event-bus.test.ts

@@ -1,9 +1,13 @@
 import { describe, it, expect } from "vitest";
 import { z } from "zod";
-import { defineEvent } from "@repo/core-events";
 import { RecordingEventBus } from "@/instrumentation/recording-event-bus";
 
-const evt = defineEvent("test.evt", z.object({ id: z.string() }).strict());
+// Inline a descriptor literal so the test doesn't need to import from
+// @repo/core-events (boundary-rule isolation, mirrors recording-tracer test).
+const evt = {
+  name: "test.evt" as const,
+  schema: z.object({ id: z.string() }).strict(),
+};
 
 describe("RecordingEventBus", () => {
   it("records every publish call after schema validation", async () => {

packages/core-testing/src/instrumentation/recording-event-bus.ts

@@ -1,5 +1,26 @@
+// Local type aliases matching the contracts in @repo/core-events.
+// Kept inline to avoid a build-graph cycle between core-testing and core-events
+// (mirrors the recording-tracer / recording-logger pattern).
 import type { z } from "zod";
-import type { EventDescriptor, EventHandler, IEventBus } from "@repo/core-events";
+
+type EventDescriptor<TName extends string, TSchema extends z.ZodType> = {
+  readonly name: TName;
+  readonly schema: TSchema;
+};
+
+type EventHandler<T> = (event: T) => Promise<void>;
+
+interface IEventBus {
+  publish<T>(
+    descriptor: EventDescriptor<string, z.ZodType<T>>,
+    payload: T,
+  ): Promise<void>;
+  subscribe<T>(
+    descriptor: EventDescriptor<string, z.ZodType<T>>,
+    consumerFeature: string,
+    handler: EventHandler<T>,
+  ): void;
+}
 
 export class RecordingEventBus implements IEventBus {
   readonly published: { name: string; payload: unknown }[] = [];

packages/core-testing/src/instrumentation/recording-job-queue.ts

@@ -1,4 +1,13 @@
-import type { IJobQueue } from "@repo/core-shared/jobs";
+// Local type alias matching the contract in @repo/core-shared/jobs.
+// Kept inline to avoid a build-graph cycle between core-testing and core-shared
+// (mirrors the recording-tracer / recording-logger pattern).
+interface IJobQueue {
+  enqueue<T>(
+    taskSlug: string,
+    input: T,
+    options?: { runAt?: Date },
+  ): Promise<{ jobId: string }>;
+}
 
 export class RecordingJobQueue implements IJobQueue {
   readonly enqueued: { taskSlug: string; input: unknown; options?: { runAt?: Date } }[] = [];