@pattern-stack/codegen 0.2.0 → 0.3.0

package/templates/subsystem/bridge-config/prompt.js

@@ -0,0 +1,20 @@
+/**
+ * Hygen prompt.js — BRIDGE-9 bridge config-block scaffold.
+ *
+ * Split from `templates/subsystem/bridge/` so the CLI can invoke the
+ * config-block inject step independently. `subsystem install bridge --force`
+ * preserves an existing `bridge:` block by skipping this action;
+ * `--force-config` opts into regenerating it (mirrors EVT-8 / SYNC-7 +
+ * #121 / F13 precedent).
+ *
+ * Invoked via:
+ *   bunx hygen subsystem bridge-config --configPath <abs>
+ */
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      configPath: args.configPath ?? "codegen.config.yaml",
+    };
+  },
+};

package/templates/subsystem/events/domain-events.schema.ejs.t

@@ -0,0 +1,81 @@
+---
+to: "<%= schemaPath %>"
+force: true
+---
+/**
+ * Drizzle schema for the domain_events outbox table.
+ *
+ * This table backs the DrizzleEventBus. Events are inserted within the
+ * same database transaction as the domain write (outbox pattern). A
+ * polling process reads unprocessed rows and dispatches to subscribers.
+ *
+ * First-class routing columns (EVT-1):
+ *   - `pool`       — populated by DrizzleEventBus.publish() (EVT-4); enables
+ *                    pool-filtered drain queries without unpacking metadata JSON.
+ *   - `direction`  — `inbound` | `change` | `outbound`; mirrors the routing
+ *                    dimension used by jobs' reserved `events_inbound` /
+ *                    `events_change` / `events_outbound` pools.
+ *   - `tenant_id`  — scaffold-time conditional: emitted only when
+ *                    `events.multi_tenant: true` in `codegen.config.yaml`.
+ *                    See EVT-8 and the JOB-6 precedent for the same pattern.
+ *
+ * The `metadata` JSON column continues to carry these values for protocol
+ * stability; the first-class columns are an optimization for drain filtering.
+ *
+ * Indexes (declared below in the index callback):
+ *   - (status, occurred_at)             — polling drain filter
+ *   - (aggregate_id, aggregate_type)    — event replay per aggregate
+ *   - (pool, status, occurred_at)       — per-pool drain filter (EVT-1)
+ */
+import {
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from 'drizzle-orm/pg-core';
+import type { InferSelectModel } from 'drizzle-orm';
+
+export const domainEvents = pgTable(
+  'domain_events',
+  {
+    id: uuid('id').primaryKey(),
+    type: text('type').notNull(),
+    aggregateId: text('aggregate_id').notNull(),
+    aggregateType: text('aggregate_type').notNull(),
+    payload: jsonb('payload').notNull().$type<Record<string, unknown>>(),
+    occurredAt: timestamp('occurred_at', { withTimezone: true }).notNull(),
+    processedAt: timestamp('processed_at', { withTimezone: true }),
+    /** Lifecycle status: pending | processed | failed */
+    status: text('status').notNull().default('pending'),
+    /** Error message from the last failed dispatch attempt. */
+    error: text('error'),
+    metadata: jsonb('metadata').$type<Record<string, unknown>>(),
+    /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. */
+    pool: text('pool'),
+    /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. */
+    direction: text('direction'),
+<% if (multiTenant) { -%>
+    tenantId: text('tenant_id'),                // scaffold-time conditional — see EVT-8
+<% } -%>
+  },
+  (t) => ({
+    /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */
+    idxDomainEventsStatusOccurredAt: index('idx_domain_events_status_occurred_at').on(
+      t.status,
+      t.occurredAt,
+    ),
+    /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */
+    idxDomainEventsAggregate: index('idx_domain_events_aggregate').on(
+      t.aggregateId,
+      t.aggregateType,
+    ),
+    /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */
+    idxDomainEventsPoolStatusOccurredAt: index(
+      'idx_domain_events_pool_status_occurred_at',
+    ).on(t.pool, t.status, t.occurredAt),
+  }),
+);
+
+export type DomainEventRecord = InferSelectModel<typeof domainEvents>;

package/templates/subsystem/events/generated-keep.ejs.t

@@ -0,0 +1,4 @@
+---
+to: "<%= generatedKeepPath %>"
+unless_exists: true
+---

package/templates/subsystem/events/prompt.js

@@ -0,0 +1,39 @@
+/**
+ * Hygen prompt.js — EVT-8 events subsystem scaffold.
+ *
+ * All locals are resolved by the CLI (src/cli/shared/events-scaffold-locals.ts)
+ * and forwarded as CLI args. This prompt.js coerces boolean-ish strings back
+ * into JS booleans so template `<% if (multiTenant) { %>` gates work — Hygen
+ * args arrive as strings, and `if ("false")` would render truthy in EJS.
+ *
+ * Invoked via:
+ *   bunx hygen subsystem events \
+ *     --configPath <abs> --schemaPath <abs> --generatedKeepPath <abs> \
+ *     --multiTenant <'true'|'false'> --appName <string>
+ *
+ * Unlike jobs, events has no separate worker process — the outbox drain loop
+ * runs inside the NestJS app context wherever `EventsModule.forRoot(...)` is
+ * imported. So no workerPath / workerMode / mainTsPath locals here.
+ */
+
+function coerceBool(raw) {
+  if (raw === true) return true;
+  if (raw === false) return false;
+  if (typeof raw === "string") return raw.toLowerCase() === "true";
+  return false;
+}
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      appName: args.appName ?? "",
+      multiTenant: coerceBool(args.multiTenant),
+      configPath: args.configPath ?? "codegen.config.yaml",
+      schemaPath:
+        args.schemaPath ?? "shared/subsystems/events/domain-events.schema.ts",
+      generatedKeepPath:
+        args.generatedKeepPath ??
+        "shared/subsystems/events/generated/.gitkeep",
+    };
+  },
+};

package/templates/subsystem/events-config/codegen-config-events-block.ejs.t

@@ -0,0 +1,26 @@
+---
+to: "<%= configPath %>"
+inject: true
+append: true
+skip_if: "events:"
+---
+
+events:
+  # ── Backend selection (core/extension model — see CLAUDE.md) ──
+  # 'drizzle' is the production backend (transactional outbox). 'memory'
+  # is the synchronous test backend. Future backends (e.g. 'redis',
+  # 'nats') implement the same core IEventBus contract.
+  backend: drizzle
+
+  # ── Multi-tenancy (EVT-6 / ADR-024) ──
+  # When true the generated schema gains a `tenant_id` column and
+  # `TypedEventBus.publish` throws `MissingTenantIdError` when the caller
+  # forgets `metadata.tenantId`. Enabling post-install requires a
+  # reinstall (`subsystem install events`) plus an Atlas migration.
+  multi_tenant: false
+
+  # ── Optional drain-loop pool filter ──
+  # Restrict this process to specific lanes. Leave commented to drain
+  # all pending rows. Typical split is one process per lane so a slow
+  # outbound handler cannot stall change-event propagation.
+  # pools: []  # e.g. [events_inbound] | [events_change] | [events_outbound]

package/templates/subsystem/events-config/prompt.js

@@ -0,0 +1,20 @@
+/**
+ * Hygen prompt.js — #121 (F13) events config-block scaffold.
+ *
+ * Split from `templates/subsystem/events/` so the CLI can invoke the
+ * config-block inject step independently of the rest of the events scaffold.
+ * This lets `subsystem install events --force` preserve an existing `events:`
+ * block by skipping this action entirely, while `--force-config` opts in
+ * to regenerating it.
+ *
+ * Invoked via:
+ *   bunx hygen subsystem events-config --configPath <abs>
+ */
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      configPath: args.configPath ?? "codegen.config.yaml",
+    };
+  },
+};

package/templates/subsystem/jobs/job-orchestration.schema.ejs.t

@@ -0,0 +1,221 @@
+---
+to: "<%= schemaPath %>"
+force: true
+---
+/**
+ * Drizzle schema for the job orchestration domain (ADR-022).
+ *
+ * Three tables model the lifecycle of a durable job:
+ *   - `job`       — definitions keyed by handler type (e.g. 'onboarding').
+ *   - `job_run`   — one row per attempt to execute a job; worker claims
+ *                   rows directly via SELECT ... FOR UPDATE SKIP LOCKED.
+ *   - `job_step`  — individual steps within a run; memoises output for replay.
+ *
+ * Phase 1 ships only this layer. There is no `job_queue` table, no executor
+ * port — see ADR-022 and `.claude/skills/jobs/SKILL.md` for the rationale.
+ */
+import {
+  pgEnum,
+  pgTable,
+  uuid,
+  text,
+  jsonb,
+  integer,
+  timestamp,
+  index,
+  uniqueIndex,
+} from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+import type { InferSelectModel } from 'drizzle-orm';
+
+// ─── Internal $type<> helpers ───────────────────────────────────────────────
+// Annotation types for jsonb columns only. JOB-2 defines the public protocol
+// types; these remain private to this file.
+
+type RetryPolicy = {
+  attempts: number;
+  backoff: 'fixed' | 'exponential';
+  baseMs: number;
+  nonRetryableErrors?: string[];
+};
+
+type JobRunError = {
+  message: string;
+  stack?: string;
+  retryable: boolean;
+  attempt: number;
+};
+
+// ─── Enums ──────────────────────────────────────────────────────────────────
+
+export const jobRunStatusEnum = pgEnum('job_run_status', [
+  'pending',
+  'running',
+  'waiting',
+  'completed',
+  'failed',
+  'timed_out',
+  'canceled',
+]);
+
+// extended in ADR-027: tool_call | llm_call | wait | checkpoint | message
+export const jobStepKindEnum = pgEnum('job_step_kind', ['task']);
+
+export const jobStepStatusEnum = pgEnum('job_step_status', [
+  'pending',
+  'running',
+  'completed',
+  'failed',
+  'skipped',
+]);
+
+export const collisionModeEnum = pgEnum('job_collision_mode', [
+  'queue',
+  'reject',
+  'replace',
+]);
+
+export const replayFromEnum = pgEnum('job_replay_from', [
+  'scratch',
+  'last_step',
+  'last_checkpoint',
+]);
+
+export const parentClosePolicyEnum = pgEnum('job_parent_close_policy', [
+  'terminate',
+  'cancel',
+  'abandon',
+]);
+
+// Phase 3 placeholder — see ADR-025
+export const waitKindEnum = pgEnum('job_wait_kind', ['signal']);
+
+// Phase 2 may add more sources; requires Atlas migration
+export const triggerSourceEnum = pgEnum('job_trigger_source', [
+  'manual',
+  'schedule',
+  'event',
+  'parent',
+]);
+
+// ─── job ────────────────────────────────────────────────────────────────────
+
+export const jobs = pgTable('job', {
+  type: text('type').primaryKey(),
+  version: integer('version').notNull().default(1),
+  pool: text('pool').notNull(),
+  scopeEntityType: text('scope_entity_type'),
+  retryPolicy: jsonb('retry_policy').notNull().$type<RetryPolicy>(),
+  timeoutMs: integer('timeout_ms'),
+  concurrencyKeyTemplate: text('concurrency_key_template'),
+  collisionMode: collisionModeEnum('collision_mode').notNull().default('queue'),
+  dedupeKeyTemplate: text('dedupe_key_template'),
+  dedupeWindowMs: integer('dedupe_window_ms'),
+  priorityDefault: integer('priority_default').notNull().default(0),
+  replayFrom: replayFromEnum('replay_from').notNull().default('last_checkpoint'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export type JobDefinitionRow = InferSelectModel<typeof jobs>;
+
+// ─── job_run ────────────────────────────────────────────────────────────────
+
+export const jobRuns = pgTable(
+  'job_run',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+    jobType: text('job_type').notNull().references(() => jobs.type),
+    jobVersion: integer('job_version').notNull(),
+    parentRunId: uuid('parent_run_id').references((): any => jobRuns.id),
+    /**
+     * Service generates `id` client-side via randomUUID() and sets
+     * root_run_id = id for root runs (single INSERT, no self-FK race).
+     */
+    rootRunId: uuid('root_run_id').notNull(),
+    parentClosePolicy: parentClosePolicyEnum('parent_close_policy')
+      .notNull()
+      .default('terminate'),
+    scopeEntityType: text('scope_entity_type'),
+    scopeEntityId: text('scope_entity_id'),
+    tenantId: text('tenant_id'),                // F9: always emitted (nullable) — runtime enforces on boundary via JOBS_MULTI_TENANT
+    tags: jsonb('tags').notNull().default({}).$type<Record<string, string>>(),
+    pool: text('pool').notNull(),
+    priority: integer('priority').notNull().default(0),
+    concurrencyKey: text('concurrency_key'),
+    dedupeKey: text('dedupe_key'),
+    status: jobRunStatusEnum('status').notNull().default('pending'),
+    input: jsonb('input').notNull().$type<Record<string, unknown>>(),
+    output: jsonb('output').$type<Record<string, unknown>>(),
+    error: jsonb('error').$type<JobRunError>(),
+    triggerSource: triggerSourceEnum('trigger_source').notNull(),
+    triggerRef: text('trigger_ref'),
+    runAt: timestamp('run_at', { withTimezone: true }).notNull().defaultNow(),
+    startedAt: timestamp('started_at', { withTimezone: true }),
+    finishedAt: timestamp('finished_at', { withTimezone: true }),
+    claimedAt: timestamp('claimed_at', { withTimezone: true }),
+    attempts: integer('attempts').notNull().default(0),
+    // Phase 3 placeholder — see ADR-025
+    waitKind: waitKindEnum('wait_kind'),
+    // Phase 3 placeholder — see ADR-025
+    resumeToken: text('resume_token'),
+    // Phase 3 placeholder — see ADR-025
+    waitDeadline: timestamp('wait_deadline', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => ({
+    /** Claim query: ORDER BY priority DESC, run_at ASC. */
+    idxJobRunClaim: index('idx_job_run_claim').on(t.status, t.pool, t.runAt),
+    /** Tree traversal / cascade cancel. */
+    idxJobRunRoot: index('idx_job_run_root').on(t.rootRunId),
+    /** listForScope query. */
+    idxJobRunScope: index('idx_job_run_scope').on(t.scopeEntityType, t.scopeEntityId),
+    /** Idempotency collapse — partial index. */
+    idxJobRunDedupe: index('idx_job_run_dedupe')
+      .on(t.jobType, t.dedupeKey)
+      .where(sql`${t.dedupeKey} IS NOT NULL`),
+    /** Collision check — partial index. */
+    idxJobRunConcurrency: index('idx_job_run_concurrency')
+      .on(t.concurrencyKey)
+      .where(
+        sql`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`,
+      ),
+  }),
+);
+
+export type JobRunRow = InferSelectModel<typeof jobRuns>;
+
+// ─── job_step ───────────────────────────────────────────────────────────────
+
+export const jobSteps = pgTable(
+  'job_step',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+    jobRunId: uuid('job_run_id').notNull().references(() => jobRuns.id),
+    stepId: text('step_id').notNull(),
+    kind: jobStepKindEnum('kind').notNull().default('task'),
+    /**
+     * Monotonic within run. integer (max ~2B per run) is sufficient —
+     * downgraded from ADR-022's bigint; revisit only if a single run
+     * ever exceeds 2 billion steps.
+     */
+    seq: integer('seq').notNull(),
+    status: jobStepStatusEnum('status').notNull().default('pending'),
+    input: jsonb('input').$type<Record<string, unknown>>(),
+    /** Memoised on success for replay. */
+    output: jsonb('output').$type<Record<string, unknown>>(),
+    error: jsonb('error').$type<JobRunError>(),
+    attempts: integer('attempts').notNull().default(0),
+    startedAt: timestamp('started_at', { withTimezone: true }),
+    finishedAt: timestamp('finished_at', { withTimezone: true }),
+  },
+  (t) => ({
+    /** No duplicate step IDs per run. */
+    idxJobStepRunStep: uniqueIndex('idx_job_step_run_step').on(t.jobRunId, t.stepId),
+    /** Ordered timeline reads. */
+    idxJobStepTimeline: index('idx_job_step_timeline').on(t.jobRunId, t.seq),
+  }),
+);
+
+export type JobStepRow = InferSelectModel<typeof jobSteps>;

package/templates/subsystem/jobs/main-hook.ejs.t

@@ -0,0 +1,11 @@
+---
+to: "<%= mainTsPath %>"
+inject: true
+after: "NestFactory.create"
+skip_if: "<%= mainHookInjected %>"
+---
+  // JOBS — Embedded worker mode (optional)
+  // To run the job worker in-process (single-process deploy), add to AppModule imports:
+  //   JobWorkerModule.forRoot({ mode: 'embedded' })
+  // For standalone worker (separate process), use worker.ts at the project root.
+  // See codegen.config.yaml jobs.worker_mode to toggle the documented default.

package/templates/subsystem/jobs/prompt.js

@@ -0,0 +1,40 @@
+/**
+ * Hygen prompt.js — JOB-6 jobs subsystem scaffold.
+ *
+ * All locals are resolved by the CLI (src/cli/shared/jobs-scaffold-locals.ts)
+ * and forwarded as CLI args. This prompt.js coerces boolean-ish strings back
+ * into JS booleans so template `<% if (multiTenant) { %>` gates work — Hygen
+ * args arrive as strings, and `if ("false")` would render truthy in EJS.
+ *
+ * Invoked via:
+ *   bunx hygen subsystem jobs \
+ *     --workerPath <abs> --workerExists <'true'|''> \
+ *     --mainTsPath <abs> --configPath <abs> --schemaPath <abs> \
+ *     --multiTenant <'true'|'false'> --workerMode <embedded|standalone> \
+ *     --appName <string>
+ */
+
+function coerceBool(raw) {
+  if (raw === true) return true;
+  if (raw === false) return false;
+  if (typeof raw === "string") return raw.toLowerCase() === "true";
+  return false;
+}
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      appName: args.appName ?? "",
+      workerMode: args.workerMode === "standalone" ? "standalone" : "embedded",
+      multiTenant: coerceBool(args.multiTenant),
+      mainTsPath: args.mainTsPath ?? "src/main.ts",
+      configPath: args.configPath ?? "codegen.config.yaml",
+      // Hygen's skip_if treats any non-empty string as truthy, so we send an
+      // empty string when the file doesn't exist (CLI already does this).
+      workerExists: args.workerExists ?? "",
+      workerPath: args.workerPath ?? "worker.ts",
+      schemaPath:
+        args.schemaPath ?? "shared/subsystems/jobs/job-orchestration.schema.ts",
+    };
+  },
+};

package/templates/subsystem/jobs/worker.ejs.t

@@ -0,0 +1,82 @@
+---
+to: "<%= workerPath %>"
+unless_exists: true
+---
+/**
+ * Standalone job worker entrypoint — emitted by `codegen subsystem install jobs`.
+ *
+ * Boots a Nest application context (NO HTTP listener) wiring the jobs domain
+ * module plus JobWorkerModule in `standalone` mode. Run with:
+ *
+ *   bun worker.ts
+ *
+ * Embedded mode (single-process) is configured by importing
+ * JobWorkerModule.forRoot({ mode: 'embedded' }) inside AppModule instead —
+ * see the commented guidance injected into `src/main.ts`.
+ *
+ * SIGTERM triggers graceful shutdown bounded by SHUTDOWN_TIMEOUT_MS; after the
+ * timeout the process exits hard so orchestrators (systemd, Kubernetes) can
+ * reclaim the slot.
+ */
+import 'reflect-metadata';
+import { Logger, Module } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+import { DatabaseModule } from '@shared/database/database.module';
+import { JobsDomainModule } from '@shared/subsystems/jobs/jobs-domain.module';
+import { JobWorkerModule } from '@shared/subsystems/jobs/job-worker.module';
+
+const SHUTDOWN_TIMEOUT_MS = 30_000;
+
+@Module({
+  imports: [
+    DatabaseModule,
+    JobsDomainModule.forRoot({ backend: 'drizzle' }),
+    JobWorkerModule.forRoot({ mode: 'standalone' }),
+  ],
+})
+class WorkerAppModule {}
+
+async function bootstrap(): Promise<void> {
+  const logger = new Logger('JobWorker');
+  const app = await NestFactory.createApplicationContext(WorkerAppModule, {
+    bufferLogs: false,
+  });
+
+  let shuttingDown = false;
+  const shutdown = async (signal: string): Promise<void> => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    logger.log(`${signal} received — shutting down (timeout ${SHUTDOWN_TIMEOUT_MS}ms)`);
+
+    const forceExit = setTimeout(() => {
+      logger.error(`shutdown exceeded ${SHUTDOWN_TIMEOUT_MS}ms — forcing exit`);
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    forceExit.unref();
+
+    try {
+      await app.close();
+      logger.log('shutdown complete');
+      process.exit(0);
+    } catch (err) {
+      logger.error('error during shutdown', err as Error);
+      process.exit(1);
+    }
+  };
+
+  process.on('SIGTERM', () => {
+    void shutdown('SIGTERM');
+  });
+  process.on('SIGINT', () => {
+    void shutdown('SIGINT');
+  });
+
+  logger.log('job worker started (standalone mode)');
+}
+
+bootstrap().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error('failed to bootstrap job worker', err);
+  process.exit(1);
+});

package/templates/subsystem/jobs-config/codegen-config-jobs-block.ejs.t

@@ -0,0 +1,55 @@
+---
+to: "<%= configPath %>"
+inject: true
+append: true
+skip_if: "jobs:"
+---
+
+jobs:
+  # ── Backend selection (core/extension model — see CLAUDE.md) ──
+  # 'drizzle' is the only Phase 1 backend. Future backends ('bullmq', etc.)
+  # implement the same core IJobOrchestrator contract but expose their own
+  # native features as opt-in extensions below.
+  backend: drizzle
+
+  # ── Backend-specific extensions (typed per backend) ──
+  # Each backend may publish its own extension keys. Unrecognised keys for
+  # the active backend produce a config validation warning at boot.
+  extensions:
+    drizzle:
+      # listen_notify: true        # use Postgres LISTEN/NOTIFY to wake the
+      #                            # polling loop instead of (or alongside)
+      #                            # interval polling. Disabled by default.
+      poll_interval_ms: 1000
+    # bullmq:                      # Example shape for Phase 6+ BullMQ backend.
+    #   bull_board:                # Mount Bull Board admin UI.
+    #     enabled: true
+    #     mount_path: /admin/queues
+    #   redis_url: redis://...
+
+  # ── Multi-tenancy (JOB-8) ──
+  multi_tenant: false              # true → enforce tenantId on all calls
+
+  # ── Worker topology ──
+  worker_mode: embedded            # embedded | standalone
+
+  # ── Pools (logical lanes; one worker per pool) ──
+  pools:
+    events_inbound:
+      queue: jobs-events-inbound
+      concurrency: 20
+      reserved: true               # framework-only; user @JobHandler cannot target
+    events_change:
+      queue: jobs-events-change
+      concurrency: 30
+      reserved: true
+    events_outbound:
+      queue: jobs-events-outbound
+      concurrency: 10
+      reserved: true
+    interactive:
+      queue: jobs-interactive
+      concurrency: 20
+    batch:
+      queue: jobs-batch
+      concurrency: 5

package/templates/subsystem/jobs-config/prompt.js

@@ -0,0 +1,20 @@
+/**
+ * Hygen prompt.js — #121 (F13) jobs config-block scaffold.
+ *
+ * Split from `templates/subsystem/jobs/` so the CLI can invoke the
+ * config-block inject step independently of the rest of the jobs scaffold.
+ * This lets `subsystem install jobs --force` preserve an existing `jobs:`
+ * block by skipping this action entirely, while `--force-config` opts in
+ * to regenerating it.
+ *
+ * Invoked via:
+ *   bunx hygen subsystem jobs-config --configPath <abs>
+ */
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      configPath: args.configPath ?? "codegen.config.yaml",
+    };
+  },
+};

package/templates/subsystem/sync/prompt.js

@@ -0,0 +1,43 @@
+/**
+ * Hygen prompt.js — SYNC-7 sync subsystem scaffold.
+ *
+ * All locals are resolved by the CLI (src/cli/shared/sync-scaffold-locals.ts)
+ * and forwarded as CLI args. This prompt.js coerces boolean-ish strings back
+ * into JS booleans so template `<% if (multiTenant) { %>` gates work — Hygen
+ * args arrive as strings, and `if ("false")` would render truthy in EJS.
+ *
+ * Invoked via:
+ *   bunx hygen subsystem sync \
+ *     --configPath <abs> --schemaPath <abs> \
+ *     --multiTenant <'true'|'false'> --appName <string>
+ *
+ * Unlike events, sync has NO codegen-emitted artifacts (no generated/ dir,
+ * no typed bus facade). So no `generatedKeepPath` local. Consumers that
+ * want a typed layer above the orchestrator build it themselves — the
+ * subsystem ships the substrate.
+ *
+ * Intentionally no starter entity YAMLs (sync_subscription, sync_run,
+ * sync_run_item). The subsystem owns those tables directly via SYNC-1's
+ * sync-audit.schema.ts; shipping entity YAMLs would generate redundant
+ * repositories/services that shadow the subsystem. Matches the epic's
+ * Phase 2 timing for `examples/sync/`.
+ */
+
+function coerceBool(raw) {
+  if (raw === true) return true;
+  if (raw === false) return false;
+  if (typeof raw === "string") return raw.toLowerCase() === "true";
+  return false;
+}
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      appName: args.appName ?? "",
+      multiTenant: coerceBool(args.multiTenant),
+      configPath: args.configPath ?? "codegen.config.yaml",
+      schemaPath:
+        args.schemaPath ?? "shared/subsystems/sync/sync-audit.schema.ts",
+    };
+  },
+};