@openora/create 0.4.1-canary.108 → 0.4.1-canary.110

package/template/__dot__rulesync/hooks/guard-subagent.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 // PreToolUse(Task) guard: keep the orchestrator from spawning a GENERIC subagent
 // (general-purpose / claude) for work a roster agent is purpose-built for. The
-// Agent roster in AGENTS.md is prose the model sometimes skips out of habit; this
-// is the deterministic backstop.
+// Agent roster in the workflow rule is prose the model sometimes skips out of
+// habit; this is the deterministic backstop.
 //
 // Conservative by design: it acts ONLY when (a) the chosen subagent is generic AND
 // (b) the task text contains a HIGH-SIGNAL phrase that maps unambiguously to one
@@ -16,7 +16,9 @@ const ti = payload.tool_input ?? {};
 const sub = String(ti.subagent_type ?? '').toLowerCase();
 
 const GENERIC = new Set(['general-purpose', 'claude', '']);
-if (!GENERIC.has(sub)) process.exit(0);
+if (!GENERIC.has(sub)) {
+  process.exit(0);
+}
 
 const text = `${ti.description ?? ''}\n${ti.prompt ?? ''}`.toLowerCase();
 
@@ -40,14 +42,24 @@ const ROUTES = [
     agent: 'deployer',
     re: /\b(dockerfile|containerize|deploy pipeline|deploy to (ecs|kubernetes|fly|railway|render)|ci\/cd deploy|helm chart)\b/,
   },
+  {
+    agent: 'quality-reviewer',
+    re: /\b(quality review|code quality|over-engineer(ed|ing)?|simplification review|duplication review)\b|\breview (the )?(mr|pr|diff|changed files)\b/,
+  },
+  {
+    agent: 'security-reviewer',
+    re: /\bsecurity (review|audit)\b|\baudit\b[^.]*\bvulnerabilit|\b(authz|owasp)\b/,
+  },
 ];
 
 const hit = ROUTES.find((r) => r.re.test(text));
-if (!hit) process.exit(0);
+if (!hit) {
+  process.exit(0);
+}
 
 process.stderr.write(
   `Use the \`${hit.agent}\` subagent for this task, not \`${sub || 'general-purpose'}\`. ` +
-    `It is pre-scoped for this work (tools + model + brief) - see the Agent roster in AGENTS.md. ` +
+    `It is pre-scoped for this work (tools + model + brief) - see the Agents list in the workflow rule. ` +
     `Re-issue the Task with subagent_type: "${hit.agent}". ` +
     `If it genuinely does not fit ${hit.agent}, rephrase the description to say why.\n`,
 );

package/template/__dot__rulesync/hooks/post-edit.mjs.tpl

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// PostToolUse hook (Claude / Copilot CLI / Codex CLI / Gemini CLI).
+// Lint-fixes the edited file, then typechecks the app that owns it and reports
+// (exit 2) only if the error is in the file just edited. Output is capped so a
+// failure can't balloon the model context. Fail-open on anything unexpected.
+
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join, isAbsolute, relative } from 'node:path';
+import { extractFilePath, readPayload } from './_shared.mjs';
+
+const CAP_LINES = 40;
+const CAP_CHARS = 2000;
+
+const filePath = extractFilePath(readPayload());
+if (!filePath) {
+  process.exit(0);
+}
+if (!/\.(ts|tsx)$/.test(filePath) || filePath.endsWith('.d.ts')) {
+  process.exit(0);
+}
+if (filePath.includes('/templates/') || filePath.includes('/generated/')) {
+  process.exit(0);
+}
+
+// Lint-fix (best effort - never block on the linter).
+try {
+  execSync(`pnpm exec oxlint --fix "${filePath}"`, { stdio: 'pipe' });
+} catch {
+  /* oxlint unavailable or errored - fall through to the re-lint / typecheck */
+}
+
+// Re-lint WITHOUT --fix to surface UNFIXABLE errors the agent must resolve by
+// hand - import/no-cycle and the no-restricted-imports boundary rules (deep @openora
+// or {{scope}}/ui imports, app-to-app imports). oxlint exits non-zero on errors
+// only (warnings don't fail), so this blocks on a real boundary/cycle violation
+// in the edited file and feeds the message back. Fail-open on anything else.
+try {
+  execSync(`pnpm exec oxlint "${filePath}"`, { stdio: 'pipe' });
+} catch (e) {
+  const out = (e.stdout?.toString() ?? '') + (e.stderr?.toString() ?? '');
+  if (/\berror\b/.test(out)) {
+    process.stderr.write(
+      `Boundary/lint error in ${filePath} - fix before continuing:\n${cap(out)}`,
+    );
+    process.exit(2);
+  }
+}
+
+// Resolve the owning workspace app (apps/<x> or packages/<x>).
+function packageNameFor(fp) {
+  const m = fp.match(/(.*?\/(?:apps|packages)\/[^/]+)\//);
+  if (!m) {
+    return null;
+  }
+  try {
+    const pkg = JSON.parse(readFileSync(join(m[1], 'package.json'), 'utf8'));
+    if (!pkg.name || !pkg.scripts?.['check:types']) {
+      return null;
+    }
+    return pkg.name;
+  } catch {
+    return null;
+  }
+}
+
+const abs = isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
+const owner = packageNameFor(abs);
+if (!owner) {
+  process.exit(0);
+}
+
+function cap(text) {
+  const out = text.split('\n').slice(0, CAP_LINES).join('\n').slice(0, CAP_CHARS);
+  return out.length < text.length ? `${out}\n... (truncated)` : out;
+}
+
+try {
+  execSync(`pnpm --filter "${owner}" check:types`, { stdio: 'pipe' });
+  process.exit(0);
+} catch (e) {
+  const output = (e.stdout?.toString() ?? '') + (e.stderr?.toString() ?? '');
+  const basename =
+    (isAbsolute(filePath) ? relative(process.cwd(), filePath) : filePath).split('/').pop() ?? '';
+  if (basename && output.includes(basename)) {
+    process.stderr.write(
+      `Typecheck failed for ${owner} after editing ${basename}:\n${cap(output)}`,
+    );
+    process.exit(2);
+  }
+  process.exit(0);
+}

package/template/__dot__rulesync/hooks.json

@@ -2,10 +2,28 @@
   "version": 1,
   "hooks": {
     "preToolUse": [
-      { "type": "command", "command": "node .rulesync/hooks/guard-core.mjs" },
-      { "type": "command", "command": "node .rulesync/hooks/guard-generated.mjs" },
-      { "type": "command", "matcher": "Task", "command": "node .rulesync/hooks/guard-subagent.mjs" }
+      {
+        "type": "command",
+        "matcher": "Bash|Edit|Write|MultiEdit|NotebookEdit",
+        "command": "node \"${CLAUDE_PROJECT_DIR:-.}/.rulesync/hooks/guard-core.mjs\""
+      },
+      {
+        "type": "command",
+        "matcher": "Bash|Edit|Write|MultiEdit|NotebookEdit",
+        "command": "node \"${CLAUDE_PROJECT_DIR:-.}/.rulesync/hooks/guard-generated.mjs\""
+      },
+      {
+        "type": "command",
+        "matcher": "Task|Agent",
+        "command": "node \"${CLAUDE_PROJECT_DIR:-.}/.rulesync/hooks/guard-subagent.mjs\""
+      }
     ],
-    "postToolUse": [{ "type": "command", "command": "node .rulesync/hooks/post-edit.mjs" }]
+    "postToolUse": [
+      {
+        "type": "command",
+        "matcher": "Edit|Write|MultiEdit|NotebookEdit",
+        "command": "node \"${CLAUDE_PROJECT_DIR:-.}/.rulesync/hooks/post-edit.mjs\""
+      }
+    ]
   }
 }

package/template/__dot__rulesync/rules/conventions.md

@@ -12,7 +12,7 @@ description: Engineering code conventions (TS, DB, frontend, testing, git) - the
 The always-on core of the code standard: what you must obey while typing. Detail, examples, and
 rationale live in `docs/standards/` - read the one file that matches the change instead of
 carrying all of it. The enforced import graph lives in `oss-boundaries`; Playwright rules in
-`e2e-conventions`.
+`e2e-conventions`; the always-on UI and SQL cores in `frontend-conventions` and `db-conventions`.
 
 | Change you are making                 | Read first                           |
 | ------------------------------------- | ------------------------------------ |
@@ -44,7 +44,9 @@ above) if this repo has no UI apps.
 ## Never (lint-enforced unless noted)
 
 - `any` outside tests, `!` non-null assertions, `as` casts to silence the compiler (`as const` is
-  fine).
+  fine). Two sanctioned casts: test doubles through one `mock<T>()` helper (never inline in a
+  test), and a third-party inference boundary a library gives no honest way to satisfy (one cast,
+  one-line `// Library boundary:` note).
 - `interface`, TS `enum`, decorators, inheritance for reuse, default exports (exceptions:
   `*.config.*`, `plugin.ts`, Next.js App Router files).
 - Hand-written duplicates of an inferrable type, re-inferring an imported schema, re-typing
@@ -56,6 +58,13 @@ above) if this repo has no UI apps.
   internals, import cycles, deep `dist/`/`src/` paths into another package.
 - SQL anti-patterns (bare `timestamp()`, CamelCase identifiers, hand-edited migrations) - detail
   in `docs/standards/database.md`.
+- Silent catches - log with context and rethrow. `ORPCError.message` rendered to a player - UI copy
+  keys off `.code` + typed `.data` through `t()`.
+- Comments, unless one states a fact the code cannot contain (an external system's behaviour, a
+  spec constraint); a reason goes in the commit or PR, never inline. Never in tests. Detail:
+  `docs/standards/comments.md`.
+- An in-process test that mocks the database, a repository, or a sibling service - found one in
+  the diff, replace it with the API E2E, do not add to it.
 
 ## Always
 
@@ -63,7 +72,8 @@ above) if this repo has no UI apps.
   (`wallet.service.ts`, never `helpers.ts`); types `PascalCase`; values/functions `camelCase`;
   true global constants `SCREAMING_SNAKE_CASE`; Zod schemas `<Name>Schema` with inferred type
   `<Name>`; booleans read as predicates (`isActive`, `canEdit`); money is a decimal string plus a
-  `currency` field alongside it, never `amountCents`.
+  `currency` field alongside it, never `amountCents`; IO functions are verbs (`fetchInvoice`); names
+  carry units and intent (`delayMs`, `maxRetries`).
 - **One source of truth per shape** - infer, never hand-write: `z.infer<typeof XSchema>`,
   `typeof x.$inferSelect`. Full detail: `docs/standards/types.md`.
 - **Literal config arrays/objects (option lists, key sets) use `as const`**, not an explicit union
@@ -72,8 +82,9 @@ above) if this repo has no UI apps.
   the type after.
 - **Entity ids typed through their owning type** (`playerId: Player['id']`), never a bare
   `string`.
-- **Guard clauses first, main path last; more than 3 params -> one named object.** Detail:
-  `docs/standards/functions.md`.
+- **Guard clauses first, main path last; more than 3 params -> one named object** (a leading
+  `tx` handle may stay positional). Always brace control statements, even one-liners (lint:
+  `curly`). Detail: `docs/standards/functions.md`.
 - **Construct objects by spread + override**, never a hand-copied field list.
 - **Side effects at the edges**; money paths are transactional AND idempotent (a DB guard inside
   the transaction, not just an idempotency key). Detail: `docs/standards/errors.md`.
@@ -85,6 +96,16 @@ above) if this repo has no UI apps.
   route, an overlay, a vendor adapter, anything with SQL -> API E2E against real Postgres with the
   vendor stubbed at its HTTP boundary; a pure function -> a co-located unit test in `__tests__/`.
   Never fake a query builder and never let a spy assertion be the point of a test; always cover
-  authz negatives. Detail: `docs/standards/testing.md`.
-- **Green before review:** `pnpm verify` passes. Conventional commits, lowercase subject, one PR
-  per concern. Never push without explicit confirmation. Detail: `docs/standards/git-delivery.md`.
+  authz negatives. A new or changed route ships one API E2E spec
+  (`apps/e2e/tests/api/<domain>/<scenario>.spec.ts`): happy path plus one hostile path
+  (unauthorized, wrong owner, repeated call on a money path) - it is the acceptance artifact the
+  review's request trace reads as proof. Detail: `docs/standards/testing.md`.
+- **Green before review:** `/check` (typecheck + lint + unit tests) while iterating, `pnpm verify`
+  (adds format, boundaries, build) before the PR. Conventional commits, lowercase subject (PR
+  title too - a squash merge turns it into the commit), one PR per concern. Never push without
+  explicit confirmation. The description carries what / why / acceptance criteria / bare ticket
+  key - no test plan or CI checklist the pipeline already shows, no URLs, hostnames, secrets, or
+  PII. Detail: `docs/standards/git-delivery.md`.
+- **Fix the import, never work around a lint or boundary violation.** Agent rules are generated
+  from `.rulesync/` via `pnpm gen:agents` - never hand-edit a generated file. Detail:
+  `docs/standards/enforcement.md`.

package/template/__dot__rulesync/rules/db-conventions.md

@@ -0,0 +1,17 @@
+---
+root: false
+targets:
+  - '*'
+globs:
+  - 'apps/api/**'
+description: SQL / Drizzle conventions for tables an overlay or local add-on owns - the always-on core; full detail in docs/standards/database.md.
+---
+
+# Database conventions (SQL / Drizzle)
+
+Applies to every table an overlay or local add-on owns (`apps/api/src/extensions/<name>/src/schema/`). Platform-domain tables live in `@openora/*` core - never edit those. Identifiers, timestamps, keys, indexes, N+1, idempotency and migrations are specified in `docs/standards/database.md` - read it before touching a schema, query, migration, or seed. The rules below are the ones that file does not state.
+
+- Money: exact decimal, never float, never a scaled integer. Every money column is `decimal()` (Postgres `NUMERIC`) - never `real`/`float`, never an `integer` "cents" column. Pair it with a `currency` column; on the wire use `MoneyAmountSchema` (decimal string) + `currency`, never `z.number()`. Balance math runs in SQL, never JS float arithmetic.
+- `pgEnum` derives from a values + schema + type triple declared once (never an inline value array): `X_STATUSES = [...] as const` -> `XStatusSchema = z.enum(X_STATUSES)` -> `pgEnum('x_status', X_STATUSES)`.
+- Bound the fan-out: never `Promise.all(rows.map(fn))` when `rows` is a query result and `fn` calls out per row (a vendor adapter, another service) - it opens unbounded concurrent connections/requests and starves everything else at scale. Use `mapConcurrent(items, limit, fn)` (`@openora/core/server`).
+- Audit every mutation: each state-changing action emits a domain event the `audit` add-on subscribes to, or resolves `AUDIT_WRITER` and calls `record(...)`. A mutation with no audit trail is not done.

package/template/__dot__rulesync/rules/e2e-conventions.md

@@ -9,6 +9,8 @@ description: Playwright E2E conventions - specs run against the real stack; mock
 
 # E2E conventions (`apps/e2e`)
 
+Applies once this repo has an `apps/e2e` Playwright suite; a repo without one is not covered by this rule, and adding the suite is what turns it on.
+
 Two kinds of spec live here:
 
 - **Browser specs** (`tests/<app>/**`) - a player or admin journey through the UI.

package/template/__dot__rulesync/rules/frontend-conventions.md.tpl

@@ -0,0 +1,35 @@
+---
+root: false
+targets:
+  - '*'
+globs:
+  - 'apps/web/**'
+  - 'apps/backoffice/**'
+  - 'packages/ui/**'
+description: React/UI conventions (component library, theming, i18n, permission gating, modular architecture) for apps/web, apps/backoffice, packages/ui - applies once those apps exist; full detail in docs/standards/frontend.md.
+---
+
+# Frontend conventions
+
+Applies once this repo has UI apps (`apps/web`, `apps/backoffice`, `packages/ui`); an api-only repo has none of those paths and this rule is inert there.
+
+UI-specific rules for `apps/web`, `apps/backoffice`, and `packages/ui`. Stack-agnostic rules (naming, types, functions, comments, errors, testing, git) live in `conventions`. Styling, i18n, and the modular architecture are specified in `docs/standards/frontend.md` - read it before touching a component, page, or module. The rules below are the ones that file does not state.
+
+## Component library
+
+- `{{scope}}/ui` is the component library: compose from its primitives (`Button`, `Dialog`, `Select`, `Switch`, `Tabs`, `Badge`, ...) plus utility classes on the theme tokens. Don't hand-roll what a primitive already provides; a genuinely missing one is added to `packages/ui/src/primitives/`.
+- Theme tokens and CSS variables are declared once in `packages/ui/themes.css`; `cn()` and `registerTranslations()` come from the `{{scope}}/ui` barrel - never deep-import.
+- `{{scope}}/ui` is consumed pre-built, so the React Compiler exception in `docs/standards/frontend.md` applies to it.
+
+## Permission-gated UI
+
+A page, nav item, tab, panel, or write action gated on a permission must check the exact resource/level the backend route actually asserts (`adminGuard.assert(resource, action)`) - never a looser, unrelated, or merely-plausible resource, and never a coarse "is admin" shortcut. Confirm the check against the route/service being called, not against what reads correctly at a glance.
+
+- Gate at every layer the feature touches, and keep them in agreement: the nav entry, the route guard, the data-fetching hook's `enabled`, and the rendered branch. A mismatch between any two of these reopens the exact bug class this guards against - a request that fires (and 403s) before the UI hides itself, a control shown that fails on click, or a section rendering an empty/failed state instead of disappearing.
+- Thread the permission into the query hook itself (`enabled: Boolean(id) && useHasPermission(resource, level)`), not only into the component that renders it - a hook with no grant check still fires for any caller that forgets the wrapper, including ones added later.
+- A missing or denied permission hides the section outright - never a failed-to-load screen, an empty state standing in for "no access," or a disabled-but-visible control. See `conventions` > Testing: cover the authz-negative for every new gate as part of the same change.
+
+## Modular architecture
+
+- Outer composition code (`src/app/`, `src/routes/`) imports a module only as `@/modules/<name>`; files inside a module use relative paths to siblings.
+- Cross-module communication is query invalidation, never a direct import.

package/template/__dot__rulesync/rules/oss-boundaries.md.tpl

@@ -0,0 +1,60 @@
+---
+root: false
+targets:
+  - '*'
+globs:
+  - '**/*'
+description: OSS core is read-only; enforced import/module boundaries.
+---
+
+# OSS core + import boundaries
+
+## Never modify OSS core
+
+`@openora/*` is a third-party dependency - read it for reference, never write to it.
+
+- Do NOT edit `node_modules/**` or the linked OSS checkout (`{{ossDir}}`). Those paths are write-denied in `.claude/settings.json`; don't route around it with `sed`, redirection, or scripts. A patched dependency is lost on reinstall and diverges from the published package.
+- Extend from the OUTSIDE only: overlay plugins, adapter rebindings, UI plugins, config.
+- If something can only be fixed in core, STOP and report it upstream (problem, expected behavior, likely location).
+
+## Import boundaries (enforced)
+
+Enforced by `pnpm check:lint` (oxlint, per-edit), the pre-commit hook, CI, and the agent PostToolUse hook - plus `pnpm check:boundaries` (dependency-cruiser, one graph per app/package via turbo) and `pnpm check:shape` in repos that ship them. Fix the import, never work around a violation.
+
+### Across packages
+
+- No deep OSS imports: `@openora/*/src/*` or `/dist/*` - import only the package entrypoint (oxlint owns this one; every published entrypoint resolves into `dist/`, so the boundary graph cannot tell the two apart).
+- No deep `{{scope}}/ui` imports - only the barrel.
+- No app-to-app imports (`apps/web` <-> `apps/backoffice` <-> `apps/api`) - extract shared code to `packages/*`. Never reach across with a relative `../../apps/` path either.
+- No deep workspace-package imports - only the index entrypoint.
+- No import cycles.
+- A shared package (`packages/*`) must not import from an app.
+- `{{scope}}/ui` is renderer- and router-agnostic: no `next`, no router package. Take the capability through an injected adapter (see `navigation.tsx`).
+- No Node builtins in browser code (the Next instrumentation/proxy entries and `src/lib/api-server.*` are the declared exceptions).
+
+### Inside an app (ADR-0001)
+
+- No cross-module imports; a module is reached only through its barrel `index.ts`.
+- Layering inside a module: `pages/` is the leaf - `components/`, `hooks/`, `utils/` must not import it; `utils/` must not import `components/`, `hooks/` or `pages/`.
+- A file inside a module must not import its own barrel.
+- The shared kernel (`src/lib`, `src/hooks`, `src/utils`, `src/components`) must not import a feature module - dependencies point inwards.
+- Routes are leaves: nothing may import `src/app/**` (web) or `src/routes/**` / `routeTree.gen.ts` (backoffice, except `main.tsx`).
+- Transport clients (`@orpc/client`, `@orpc/openapi-client`, `@orpc/tanstack-query`) are constructed in `src/lib/` only.
+- A `'use client'` file must not import server-only code (`next/headers`, `src/lib/api-server.*`, `*.server.ts`).
+
+### Dependency manifest hygiene
+
+- Every import resolves; every npm package used is declared in that package's own `package.json`; no package sits in two dependency sections (a library's devDependency + peerDependency pair is the exception).
+- Production code imports no devDependency and no test/mock/fixture file.
+
+### Structure checks (`pnpm check:shape`, in repos that ship it)
+
+Runs the checks a dependency graph cannot make, because they are about files that do not exist or edges that do not exist:
+
+- Every module has `index.ts` and `AGENTS.md`.
+- The barrel re-exports only; the single side effect it may carry is `import './locales'`.
+- Every file under a module's `pages|components|hooks|utils` is reachable from the barrel, and every `packages/ui/src` file from the `{{scope}}/ui` barrel - otherwise it is dead code.
+
+Each app/package owns its own `.dependency-cruiser.cjs` (its own tsconfig for `@/*` alias resolution) built on the shared rule/option helpers in `.dependency-cruiser.shared.cjs`. Where the repo ships `pnpm gen:boundaries-graph`, it renders each package's graph (needs Graphviz).
+
+The shared options keep npm packages in the graph on purpose - a dependency-type rule can only judge a package that is a node - so build output is excluded per workspace path, never as a bare `/dist/`.

package/template/__dot__rulesync/rules/overview.md

@@ -23,6 +23,14 @@ Sibling rules (load on demand; don't reopen settled questions):
 - `conventions` - the always-on code standard (naming, types, functions, package structure, errors, testing, git, frontend, DB), with a table routing each kind of change to its deep-dive file in `docs/standards/`.
 - `oss-boundaries` - OSS core is read-only; enforced import/module boundaries.
 - `e2e-conventions` - dual-mode Playwright specs, fixtures, mocks, page objects.
+- `db-conventions` - SQL / Drizzle rules for the tables an overlay owns.
+- `frontend-conventions` - React/UI rules for the operator's apps and shared UI package.
+
+## Agent files: generated from the template, or owned here
+
+Most of `.rulesync/` (skills, subagents, commands, hooks, the shared rules) and `docs/standards/` are generated: `pnpm install` renders them from `@openora/create`'s consumer template at the pinned `@openora/*` version, using the variables in `.rulesync/sync.json`. They are gitignored via the managed `synced-agents` block in `.gitignore`, so they never appear in a diff and cannot drift - editing one locally is pointless, the next install overwrites it. Change it upstream in the template instead. This repo owns and tracks the rules and skills the template does not ship, plus the `consumerOwned` overrides in `.rulesync/sync.json`; operator-specific facts belong there or in `sync.json` vars.
+
+Most of `.rulesync/` (skills, subagents, commands, hooks, the shared rules) and `docs/standards/` are template-owned: rendered from `@openora/create`'s consumer template at the pinned `@openora/*` version with the variables in `.rulesync/sync.json`. `pnpm check:agents` fails on any drift, so never edit a synced file here - change it upstream in openora's `tools/templates/consumer/`, take the next canary, run `pnpm sync:agents`. Files this repo owns are listed under `consumerOwned` in `.rulesync/sync.json` plus anything the template does not ship; operator-specific facts go there or into `sync.json` vars, never into a synced file.
 
 ## Tickets and specs
 

package/template/__dot__rulesync/skills/add-feature/SKILL.md.tpl

@@ -0,0 +1,97 @@
+---
+name: add-feature
+targets: ['*']
+description: >
+  Deliver a feature end-to-end in this consumer repo. Aggregates context (Jira + Confluence + Slack +
+  Google Drive + Notion + local docs + past sessions + codebase), produces an approved plan, then drives
+  delivery by calling sibling skills - create-plugin (build), review (review), create-pr (MR) -
+  and create-task for ticket hygiene. Transitions Jira (no comments) and drafts a one-line Slack
+  notice. Use on "add feature", "plan {{trackerKey}}-XXX", "deliver {{trackerKey}}-XXX", or /add-feature [{{trackerKey}}-XXX].
+  Read-only until the plan is approved; never pushes, transitions Jira, or sends Slack without OK.
+---
+
+# add-feature ({{name}})
+
+Feature-delivery orchestrator for this consumer repo: one Jira key in; a delivered MR + updated ticket + drafted Slack notice out. You orchestrate and call sibling skills - you do not re-implement their work. The platform-core twin is the `/add-feature` skill in the platform OSS repo (`{{ossDir}}/.rulesync/skills/add-feature/`).
+
+## Coordinates
+
+- Jira: the **Atlassian** MCP, cloudId `{{jiraCloudId}}`, project `{{trackerKey}}` (ticket keys look like `{{trackerKey}}-XXX`). Request/render content as markdown (`contentFormat` + `responseContentFormat: "markdown"`).
+- Code forge: `{{gitRemotePath}}`, default target `{{mrTarget}}` - CLI and commands in `docs/agents/forge.md`.
+- Slack: `{{teamChannel}}`, draft only.
+- Repo: `apps/api` (Hono entry + extensions) consumes `@openora/*` upstream; UI apps, when present, sit beside it under `apps/`.
+- **Hard rule:** `{{ossDir}}` (the linked OSS checkout) is read-only (guard-core hook + permission deny). Extend from the outside; core changes hand off - see `handoff.md`.
+
+## The contract
+
+- **Read-only until the Step 3 plan is approved.** No edits, commits, pushes, Jira writes, or Slack sends before sign-off.
+- Reuse sibling skills, don't reinvent: **create-task** (ticket format), **create-plugin** (build an overlay), **review** (review), **create-pr** (MR). Delegate code to subagents.
+
+## Steps
+
+### 1. Resolve input + enhance the ask
+
+`{{trackerKey}}-XXX` from `$ARGUMENTS`; if absent, ask. Echo it back. Run the `enhance-prompt` pre-step on the ask before gathering context, so Step 2 pulls only what's relevant and Step 3 plans against a clear brief.
+
+### 2. Gather context in parallel (read-only)
+
+Run together; skip any source that returns nothing. Read `handoff.md` only on core-change signals.
+
+- Jira + Confluence: per `docs/agents/issue-tracker.md` - `{{trackerKey}}-XXX` whole: description, AC, every comment, every image viewed, parent epic, linked issues, and every linked Confluence page with its images and comments (`atlassian-read` for Jira + Confluence; the Atlassian MCP is for search and writes only - it returns no image bytes).
+- Slack MCP: search public/private, read threads + canvases.
+- Google Drive MCP: PRDs, specs.
+- Notion: `ntn` CLI per `notion-memory` skill - prior decisions, lessons.
+- Local docs: `{{ossDir}}/docs` (ADRs, `architecture.md`, `catalog.json`), repo READMEs, both `CLAUDE.md`.
+- Past sessions: grep `~/.claude/projects/**` and `~/.claude/plans` for the ticket key.
+- Codebase: `oss` MCP (read-only) + Explore - map touchpoints in `apps/*`.
+
+### 3. Plan + classify (the gate)
+
+Synthesize into a plan and present it. Do NOT edit yet.
+
+- **Goal** (1-2 lines) + **Acceptance criteria** (observable, testable). AC missing or vague in Jira? Draft them yourself and mark as proposed.
+- **Decisions found** - each with source (who/where/date), so they aren't relitigated.
+- **Edge cases + unknowns (grill)** - per AC, enumerate: empty/error states, authz negatives, concurrency/idempotency, jurisdiction/currency variants, migration impact. Each unknown becomes either an explicit assumption in the plan or a question below - none stay silent.
+- **Open questions** - ask before proceeding if any blocks design; batch them in one round, don't trickle.
+- **Implementation breakdown** - tasks mapped to files/packages + the owning subagent. Classify each:
+  - **downstream** -> overlay plugin / adapter swap / UI provider / config (build via `create-plugin`).
+  - **OSS-core** -> only fixable in `@openora/*`. Flag it; triggers `handoff.md`.
+- **Risks / dependencies** - external services, OSS handoff, data/migrations.
+
+Require explicit approval. Treat as plan mode even if the harness isn't.
+
+### 4. Build (delegate)
+
+After approval, for **downstream** work: run the **create-plugin** skill for each overlay/adapter/page slice - it scaffolds, wires `extensions.config.ts`, and enforces boundaries + audit + db rules. The owning subagent (`builder`) also writes unit + integration tests as part of the deliverable. `deployer` only if infra changes; `debugger` on demand for build/runtime failures.
+
+For **OSS-core** items: read `handoff.md`, write the work-order, STOP that slice, continue the rest. When implementation starts, transition Jira to In Progress (Step 7 - confirm first).
+
+### 5. Tests, then review
+
+Cheap gates first, prove it works, only then spend review on working code:
+
+1. `/check` (typecheck + lint + unit). Don't proceed on red.
+2. Derive an e2e checklist from the AC (happy path, edge cases, authz negatives, error states); `qa` writes/runs Playwright specs in `apps/e2e`, drives `chrome-devtools` on failure. E2e failures go back to `builder` BEFORE any review - don't review code that doesn't work.
+3. **review** on the change set, passing what the e2e run proved so reviewers dig where tests can't reach; loop `[BLOCK]`/`[WARN]` fixes back through `builder`.
+4. After fixes: re-run `/check` always; re-run the affected e2e specs if any fix changed behavior (not needed for pure convention/style fixes).
+
+### 6. Open the MR
+
+Run **create-pr**: it commits (`feat({{trackerKey}}-XXX): ...`), reports the SHA, asks for "yes push", pushes, and opens the pull request against `{{mrTarget}}` per `docs/agents/forge.md`, with the CODEOWNERS for the changed paths as reviewers. Never bypass its push-consent gate.
+
+### 7. Jira status transition (NOT comments)
+
+Use the **Atlassian** MCP - fetch the transitions -> show current status + options -> **confirm** -> apply the matching one (In Progress when build starts, In Review when the MR opens). **No MR-link or status comments.**
+
+### 8. Draft Slack notice (one line)
+
+Use the **Slack** MCP to draft a message to `{{teamChannel}}`: a single line - emoji + PR/task name as a link (e.g. `👉 <feature> - MR !NN`). **Draft only**, never direct-send.
+
+## Rules
+
+- Read-only until the Step 3 plan is approved.
+- Never push without an explicit per-action "yes push" (inherited from `create-pr`).
+- Never transition Jira without confirming; show status + options first. No Jira comments.
+- Slack is a one-line draft, never direct-send.
+- Never edit `{{ossDir}}`; hand off via `handoff.md`. Prefer overlay/plugin/adapter/config.
+- One MR = one concern. Split unrelated work.

package/template/__dot__rulesync/skills/add-feature/{handoff.md → handoff.md.tpl}

@@ -1,18 +1,12 @@
 # OSS core handoff
 
-When an `add-feature` work item can only be fixed in `@openora/*` core, this consumer repo cannot
-edit it (the `guard-core.mjs` hook and `permissions.deny` block the linked OSS checkout). Hand off to
-the platform-core twin skill instead of fighting the guard.
+When an `add-feature` work item can only be fixed in `@openora/*` core, this consumer repo cannot edit it (the `guard-core.mjs` hook and `permissions.deny` block `{{ossDir}}/**`). Hand off to the platform-core twin skill instead of fighting the guard.
 
 ## When to hand off
 
 - The fix requires changing a contract, schema, service, router, or platform seam in `@openora/*`.
-- An overlay plugin / adapter swap / UI provider override / config change genuinely cannot
-  express the behavior.
-- Default bias: try to extend from the outside first. Only hand off when you've confirmed the
-  outside-in path doesn't exist.
-
-If you're unsure, say so in the plan (Step 3) and let the user decide before writing the order.
+- An overlay plugin / adapter swap / UI provider override / config change genuinely cannot express the behavior.
+- Default bias: extend from the outside first; hand off only when you've confirmed the outside-in path doesn't exist. If unsure, say so in the plan (Step 3) and let the user decide before writing the order.
 
 ## Work-order template
 
@@ -27,7 +21,7 @@ Write to `~/.claude/plans/<ticket-key>-oss.md` so both repos and future sessions
 
 ## Unblocks
 
-consumer feature <ticket-key> - <which downstream slice depends on this>
+{{name}} feature <ticket-key> - <which downstream slice depends on this>
 
 ## Core surface to change
 
@@ -43,16 +37,12 @@ consumer feature <ticket-key> - <which downstream slice depends on this>
 
 ## Dependency
 
-consumer MR <url-or-TBD> stays in draft until this merges and a new @openora/core/\* version is consumed.
+{{name}} MR <url-or-TBD> stays in draft until this merges and a new @openora/core/\* version is consumed.
 ```
 
 ## Protocol
 
-1. The consumer repo writes the work-order and **stops** that slice (keep delivering independent
-   downstream slices meanwhile).
-2. The user runs `/add-feature` inside the platform OSS repo (separate cwd/session). It reads
-   the work-order, implements, and opens its own MR there.
-3. The consumer MR stays draft/blocked until the OSS MR merges and the consumer bumps the consumed
-   `@openora/*` version. Link the two by the work-order path and the ticket key.
-4. Note the handoff in the Jira ticket and the consumer MR description so the dependency is
-   visible.
+1. This consumer repo writes the work-order and **stops** that slice (keep delivering independent downstream slices meanwhile).
+2. The user runs `/add-feature` inside the platform OSS repo (`{{ossDir}}`, separate cwd/session). It reads the work-order, implements, and opens its own MR there.
+3. The consumer MR stays draft/blocked until the OSS MR merges and the consumer bumps the consumed `@openora/*` version. Link the two by the work-order path and the ticket key.
+4. Note the handoff in the Jira ticket and the consumer MR description so the dependency is visible.

package/template/__dot__rulesync/skills/create-plugin/{SKILL.md → SKILL.md.tpl}

@@ -1,19 +1,17 @@
 ---
 name: create-plugin
-
+targets: ['*']
 description: >
-  Guided creation of an extension - the right way to add behavior or swap a vendor without
+  Guided creation of a {{name}} extension - the right way to add behavior or swap a vendor without
   touching `@openora/*` core. Interviews for intent, classifies the seam (plugin / adapter /
   page / route), runs the matching scaffold command, wires extensions.config.ts, and enforces
   boundaries + audit + db rules. Use on "create plugin", "add an extension", "swap KYC/PSP",
   "mount a page", "/create-plugin <name>".
 ---
 
-# create-plugin
+# create-plugin ({{name}})
 
-The platform is extended from the **outside only** (overlay plugin / adapter rebind / UI page /
-config) - never by editing `@openora/*`. This skill picks the correct seam and scaffolds it.
-Domain questions go to `expert` first; review the result with `review`.
+The platform is extended from the **outside only** (overlay plugin / adapter rebind / UI page / config) - never by editing `@openora/*`. This skill picks the correct seam and scaffolds it. Domain questions go to `expert` first; review the result with `review`.
 
 ## 1. Classify the seam (ask if unclear)
 
@@ -24,23 +22,17 @@ Domain questions go to `expert` first; review the result with `review`.
 | Mount a react-sdk page on a route           | page    | `pnpm gen page <route>`                    |
 | Add one route to an existing add-on/overlay | route   | `/scaffold-route <add-on> <METHOD> <path>` |
 
-If the behavior genuinely cannot be expressed from the outside, STOP - it's an OSS-core change.
-Hand off via the `add-feature` skill's `handoff.md`. Do not patch the linked OSS checkout.
+If the behavior genuinely cannot be expressed from the outside, STOP - it's an OSS-core change. Hand off via the `add-feature` skill's `handoff.md`. Never patch `{{ossDir}}`.
 
 ## 2. Ground first
 
-- Read `.claude/rules/overview.md` (what you may and may not touch) and
-  `docs/standards/database.md` (if the extension owns tables).
-- Inspect what already exists with the `oss` MCP: `catalog-overview`, `list-adapters` (token +
-  default binding to swap), `list-routes` (collision check), `list-events`.
-- For a domain rule you can't safely assume (a limit, a KYC threshold, a jurisdiction behavior),
-  spawn `expert` before scaffolding.
+- Read `.claude/rules/overview.md` (what you may and may not touch), `.claude/rules/oss-boundaries.md`, and `.claude/rules/db-conventions.md` + `docs/standards/database.md` (if the extension owns tables).
+- Inspect what already exists with the `oss` MCP: `catalog-overview`, `list-adapters` (token + default binding to swap), `list-routes` (collision check), `list-slots`, `list-events`.
+- For a domain rule you can't safely assume (a limit, a KYC threshold, a jurisdiction behavior), spawn `expert` before scaffolding.
 
 ## 3. Scaffold + wire
 
-Run the command from step 1, then fill the `// AGENT: implement here` regions. Register the plugin
-in `apps/api/src/extensions.config.ts`. **Order matters for adapters** - last registration of a DI
-token wins, so list a swap AFTER the module that owns the default binding.
+Run the command from step 1, then fill the `// AGENT: implement here` regions. Register the plugin in `apps/api/src/extensions.config.ts`. **Order matters for adapters** - last registration of a DI token wins, so list a swap AFTER the module that owns the default binding.
 
 ```ts
 // good - swap binds after the owning module, so it replaces the default
@@ -52,12 +44,9 @@ plugins: [myCustomPspAdapter, walletModule];
 
 ## 4. Non-negotiables
 
-- **Boundaries**: import only package entrypoints (`@openora/core`, not `.../src` or `.../dist`).
-  No imports between extensions; cross-extension data goes through the oRPC client or a schema subpath.
-- **Tables**: live in the overlay's own `src/schema/index.ts`; follow `docs/standards/database.md`
-  (snake_case, `timestamp({ withTimezone: true })`). Run `pnpm db:migrate` after.
-- **Audit every mutation**: each state-changing action emits a domain event the `audit` add-on
-  subscribes to, or resolves `AUDIT_WRITER` and calls `record(...)`. A mutation with no audit is not done.
+- **Boundaries**: import only package entrypoints (`@openora/core`, not `.../src` or `.../dist`). No imports between extensions; cross-extension data goes through the oRPC client or a schema subpath.
+- **Tables**: live in the overlay's own `src/schema/index.ts`; follow `docs/standards/database.md` (snake_case, `timestamp({ withTimezone: true })`). Run `pnpm db:migrate` after.
+- **Audit every mutation**: each state-changing action emits a domain event the `audit` add-on subscribes to, or resolves `AUDIT_WRITER` and calls `record(...)`. A mutation with no audit is not done.
 - **Validate at the edge**: Zod schemas for every route input/output; no inline `fetch`/SQL in handlers.
 
 ## 5. Verify