@openora/create 0.4.1-canary.35 → 0.4.1-canary.351

package/template/tools/sync-agents.mjs

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+// Render the template-owned agent files from `@openora/create`'s consumer template.
+//
+// Source of truth: node_modules/@openora/create/template at the pinned @openora/* version
+// (with `pnpm link:oss`, ../openora/packages/create-openora's own tools/templates/consumer).
+// Runs on `pnpm install` via `prepare`, so these files are generated artifacts: they are
+// listed in the managed .gitignore block below and never committed. Only this repo's own
+// rules and skills - and the `consumerOwned` overrides in .rulesync/sync.json - are tracked.
+//
+// To change a synced file, edit openora's tools/templates/consumer and take the next bump.
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, join, relative, sep } from 'node:path';
+
+const ROOT = process.cwd();
+const SYNCED_ROOTS = [
+  '.rulesync/',
+  'docs/standards/',
+  'docs/agents/',
+  'tools/sync-agents.mjs',
+  'tools/oss-worktree.mjs',
+  'tools/review-precheck.mjs',
+];
+// This script bootstraps `prepare`, so it must stay tracked: ignoring it would leave a
+// fresh clone with no way to run the install that would have rendered it.
+// Tracked on purpose: `prepare` runs the script, and the Claude hooks in .claude/settings.json
+// import _shared.mjs, so both must exist in a fresh clone before the first install.
+const NEVER_IGNORED = new Set(['tools/sync-agents.mjs', '.rulesync/hooks/_shared.mjs']);
+const SKIPPED_BASENAMES = new Set();
+// Dropped before the manifest below existed. The first install after the bump runs the previous,
+// tracked copy of this script, which overwrites itself and the .gitignore block but deletes
+// nothing, so the next run has no record of these.
+const RETIRED = [
+  '.rulesync/skills/add-feature/SKILL.md',
+  '.rulesync/skills/add-feature/handoff.md',
+  '.rulesync/subagents/qa.md',
+];
+
+const die = (message) => {
+  console.error(`sync:agents - ${message}`);
+  process.exit(1);
+};
+
+const config = (() => {
+  const path = join(ROOT, '.rulesync/sync.json');
+  if (!existsSync(path)) {
+    die(`${path} is missing - it holds this repo's template variables and consumerOwned list.`);
+  }
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    return die(`${path} is not valid JSON: ${err.message}`);
+  }
+})();
+const vars = config.vars ?? {};
+const consumerOwned = new Set(config.consumerOwned ?? []);
+
+// The published package ships `template/`; a linked source checkout (pnpm link:oss, CI's
+// unbuilt clone) only has the source at tools/templates/consumer - read that directly.
+const templateRoot = (() => {
+  let pkgDir;
+  try {
+    pkgDir = dirname(createRequire(join(ROOT, '/')).resolve('@openora/create/package.json'));
+  } catch {
+    return die('@openora/create is not installed - add it as a devDependency and reinstall.');
+  }
+  const candidates = [
+    join(pkgDir, 'template'),
+    join(pkgDir, '..', '..', 'tools', 'templates', 'consumer'),
+  ];
+  const found = candidates.find((dir) => existsSync(dir));
+  if (!found) {
+    return die(`consumer template not found at ${candidates.join(' or ')}`);
+  }
+  return found;
+})();
+
+const walk = (dir) =>
+  readdirSync(dir).flatMap((entry) => {
+    const full = join(dir, entry);
+    return statSync(full).isDirectory() ? walk(full) : [full];
+  });
+
+const undot = (segment) => (segment.startsWith('__dot__') ? `.${segment.slice(7)}` : segment);
+
+const gitTracked = (paths) => {
+  try {
+    return execFileSync('git', ['ls-files', '-z', '--', ...paths], {
+      cwd: ROOT,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .split('\0')
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+};
+
+const substitute = (content) =>
+  content.replace(/\{\{(\w+)\}\}/g, (match, key) => vars[key] ?? match);
+
+const render = (file) => {
+  const rel = relative(templateRoot, file).split(sep).map(undot).join('/');
+  const isTpl = rel.endsWith('.tpl');
+  const raw = readFileSync(file, 'utf8');
+  return { path: isTpl ? rel.slice(0, -4) : rel, content: isTpl ? substitute(raw) : raw };
+};
+
+const rendered = walk(templateRoot)
+  .filter((file) => !SKIPPED_BASENAMES.has(file.split(sep).at(-1)))
+  .map(render)
+  .filter(({ path }) => SYNCED_ROOTS.some((root) => path.startsWith(root)))
+  .filter(({ path }) => !consumerOwned.has(path));
+
+// A new template variable must not brick `pnpm install` (which is also how the bump MR that
+// would add it gets built) - leave the placeholder in place and say what to add.
+const unresolved = rendered.filter(({ content }) => /\{\{\w+\}\}/.test(content));
+if (unresolved.length > 0) {
+  console.warn(
+    'sync:agents - unresolved template variables, add them to .rulesync/sync.json vars:',
+  );
+  for (const { path, content } of unresolved) {
+    console.warn(`  ${path}: ${[...new Set(content.match(/\{\{\w+\}\}/g))].join(' ')}`);
+  }
+}
+
+// Tracking a path is how this repo says "mine": .gitignore does not apply to it, so writing
+// would replace the committed content and leave a permanently dirty file. Skip those and
+// name them - opting one into being generated is a deliberate `git rm --cached`.
+const trackedPaths = new Set(gitTracked(rendered.map(({ path }) => path)));
+const owned = rendered.filter(({ path }) => trackedPaths.has(path) && !NEVER_IGNORED.has(path));
+
+for (const { path, content } of rendered) {
+  if (trackedPaths.has(path) && !NEVER_IGNORED.has(path)) {
+    continue;
+  }
+  const target = join(ROOT, path);
+  mkdirSync(dirname(target), { recursive: true });
+  if (!existsSync(target) || readFileSync(target, 'utf8') !== content) {
+    writeFileSync(target, content);
+  }
+}
+
+// Git must ignore exactly what this script writes, so a template that gains or loses a
+// file cannot leave an untracked stray behind. The block is rewritten in place; anything
+// outside the markers is left alone.
+const BEGIN = '# BEGIN synced-agents (generated by tools/sync-agents.mjs - do not edit)';
+const END = '# END synced-agents';
+const gitignore = join(ROOT, '.gitignore');
+// A tracked path is never ignored by git anyway - listing it would only mislead.
+const ignored = rendered.filter(({ path }) => !NEVER_IGNORED.has(path) && !trackedPaths.has(path));
+const block = [BEGIN, ...ignored.map(({ path }) => `/${path}`).sort(), END].join('\n');
+const current = existsSync(gitignore) ? readFileSync(gitignore, 'utf8') : '';
+const start = current.indexOf(BEGIN);
+// Search for END after BEGIN: a stray END earlier in the file (hand-edit, bad merge) would
+// otherwise splice at a negative offset and duplicate the whole block.
+const end = start === -1 ? -1 : current.indexOf(END, start + BEGIN.length);
+if (start !== -1 && end === -1) {
+  die(`${gitignore} has a ${BEGIN} marker with no matching ${END} - repair or delete the block.`);
+}
+// A file the template dropped or renamed is still on disk from the last render, untracked and
+// no longer ignored: delete what fell out of it. The old block lists what was rendered then,
+// but after a branch switch the committed block already names the new set, so the manifest
+// (outside git, per checkout) remembers what this checkout actually has on disk.
+const manifest = join(ROOT, 'node_modules/.cache/sync-agents.json');
+const lastRendered = (() => {
+  try {
+    const paths = JSON.parse(readFileSync(manifest, 'utf8'));
+    return Array.isArray(paths) ? paths.filter((path) => typeof path === 'string') : [];
+  } catch {
+    return [];
+  }
+})();
+const lastBlock =
+  start === -1
+    ? []
+    : current
+        .slice(start + BEGIN.length, end)
+        .split('\n')
+        .filter((line) => line.startsWith('/'))
+        .map((line) => line.slice(1));
+// The block and the manifest are plain text anyone can edit: a symlinked directory on the way
+// would point the delete outside the checkout, so every parent must resolve to itself.
+const realRoot = realpathSync(ROOT);
+const parentIsReal = (path) => {
+  try {
+    return realpathSync(dirname(join(ROOT, path))) === join(realRoot, dirname(path));
+  } catch {
+    return false;
+  }
+};
+const stale = [...new Set([...lastBlock, ...lastRendered, ...RETIRED])]
+  .filter((path) => SYNCED_ROOTS.some((root) => path.startsWith(root)) && !path.includes('..'))
+  .filter((path) => !ignored.some((file) => file.path === path) && !consumerOwned.has(path))
+  .filter(parentIsReal);
+// Never one this repo has since started tracking. (No paths: ls-files would list them all.)
+const staleTracked = new Set(stale.length > 0 ? gitTracked(stale) : []);
+for (const path of stale.filter((path) => !staleTracked.has(path))) {
+  const target = join(ROOT, path);
+  if (existsSync(target)) {
+    unlinkSync(target);
+    for (
+      let dir = dirname(target);
+      dir !== ROOT && readdirSync(dir).length === 0;
+      dir = dirname(dir)
+    ) {
+      rmdirSync(dir);
+    }
+  }
+}
+const updated =
+  start === -1
+    ? `${current.trimEnd()}\n\n${block}\n`.trimStart()
+    : current.slice(0, start) + block + current.slice(end + END.length);
+if (updated !== current) {
+  writeFileSync(gitignore, updated);
+}
+mkdirSync(dirname(manifest), { recursive: true });
+writeFileSync(manifest, JSON.stringify(ignored.map(({ path }) => path)));
+
+console.log(`sync:agents - ${rendered.length - owned.length} template-owned file(s) rendered.`);
+if (owned.length > 0) {
+  console.warn(
+    `  ${owned.length} kept as-is because this repo tracks them: ${owned.map(({ path }) => path).join(', ')}\n` +
+      `  To let the template own one, untrack it: git rm --cached <path>`,
+  );
+}
+
+// Both files are tracked by every consumer, so a template bump cannot wire the verify gate in.
+const missingWiring = [
+  ['.claude/settings.json', 'guard-mr.mjs', 'a PreToolUse "Bash" hook running guard-mr.mjs'],
+  [
+    'package.json',
+    'guard-mr.mjs --stamp',
+    'end "verify" with `&& node .rulesync/hooks/guard-mr.mjs --stamp`',
+  ],
+].filter(([path, marker]) => {
+  const target = join(ROOT, path);
+  return existsSync(target) && !readFileSync(target, 'utf8').includes(marker);
+});
+for (const [path, , fix] of missingWiring) {
+  console.warn(
+    `sync:agents - ${path} is missing the verify gate: ${fix} (see the template's copy).`,
+  );
+}

package/dist/generated/core-version.d.ts

@@ -1,2 +0,0 @@
-export declare const CORE_VERSION = "^0.4.1-canary.35";
-//# sourceMappingURL=core-version.d.ts.map

package/dist/generated/core-version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-version.d.ts","sourceRoot":"","sources":["../../src/generated/core-version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,qBAAqB,CAAC"}

package/dist/generated/core-version.js

@@ -1,2 +0,0 @@
-export const CORE_VERSION = "^0.4.1-canary.35";
-//# sourceMappingURL=core-version.js.map

package/dist/generated/core-version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-version.js","sourceRoot":"","sources":["../../src/generated/core-version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,kBAAkB,CAAC"}

package/template/__dot__rulesync/commands/doctor.md

@@ -1,16 +0,0 @@
----
-targets:
-  - '*'
-description: Diagnose the local dev environment - linked ../oss, node, postgres, ports, caches. Read-only; reports findings + the fix command for each.
----
-
-Run these checks and report a pass/fail line per item with the fix command for failures. Read-only - never apply fixes without being asked.
-
-1. **Node version**: `node -v` matches `.nvmrc` (26). Fix: `nvm use`.
-2. **Core resolves**: `node --input-type=module -e "import {createRequire} from 'node:module'; console.log(createRequire(process.cwd()+'/').resolve('@openora/core/react'))"` prints a path. Fix: `pnpm install`.
-3. **Database**: postgres reachable on :5432 (`nc -z localhost 5432`). Fix: `dev:infra` MCP tool (server `oss`) or the compose stack.
-4. **Services**: ports 3001 (api), 3000 (web), 3002 (backoffice) - report which are up. Fix: `pnpm dev`.
-5. **Stale bundler cache**: if a build error persists after a fix, `rm -rf apps/*/.next` and rebuild (Turbopack caches across the link boundary).
-6. **Generated agent files**: `pnpm gen:agents` runs clean (regenerates from `.rulesync/`).
-
-If everything passes but a build still fails, hand off to the `debugger` agent with the verbatim error - it owns the deeper resolution table (turbopack.root, symlinked tsconfig, externalDir).

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

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-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) || /\.d\.ts$/.test(filePath)) 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 typecheck */
-}
-
-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?.typecheck) 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}" typecheck`, { 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/rules/oss-boundaries.md

@@ -1,31 +0,0 @@
----
-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 a linked OSS checkout. 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), `pnpm check:boundaries` (dependency-cruiser, whole graph), the pre-commit hook, CI, and the agent PostToolUse hook. Fix the import, never work around a violation.
-
-- No deep OSS imports: `@openora/*/src/*` or `/dist/*` - import only the published entrypoint or subpath export.
-- No deep imports into your own shared packages - only the barrel/index entrypoint.
-- No app-to-app imports (`apps/api` <-> `apps/web` <-> `apps/backoffice`) - extract shared code to `packages/*`.
-- No cross-module imports inside an app - go through the module barrel, a query invalidation, or a domain event.
-- No overlay-to-overlay imports - couple via a command port, a domain event, or a shared contract.
-- No import cycles.
-
-`pnpm check:boundaries:graph` renders the graph (needs Graphviz).

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

@@ -1,113 +0,0 @@
----
-name: add-feature
-
-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, 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 <KEY>-XXX", "deliver <KEY>-XXX", or /add-feature [<KEY>-XXX].
-  Read-only until the plan is approved; never pushes, transitions Jira, or sends Slack without OK.
----
-
-# add-feature
-
-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.
-
-## Coordinates
-
-- Jira: the **Atlassian** MCP, cloudId `<your-jira-cloud-id>`,
-  project `<your-project-key>` (ticket keys look like `<KEY>-XXX`). Pass `contentFormat` +
-  `responseContentFormat: "markdown"`.
-- GitLab: `<your-gitlab-project>`, MR target `dev`, `glab` CLI.
-- Slack: `<your-team-channel>`, draft only.
-- Repo: `apps/api` (Hono entry + extensions) consumes `@openora/*` upstream. This is a headless
-  API consumer; build your frontend in its own repo and consume the API over HTTP.
-- **Hard rule:** 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
-
-`<KEY>-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.
-
-| Source        | How                                                                                             |
-| ------------- | ----------------------------------------------------------------------------------------------- |
-| Jira          | the **Atlassian** MCP - read `<KEY>-XXX`: description, AC, comments, parent epic, linked issues |
-| Confluence    | the **Atlassian** (Confluence) MCP - search the space + read pages                              |
-| Slack         | the **Slack** MCP - search public/private, read threads, read canvases                          |
-| Google Drive  | the **Google Drive** MCP - PRDs, specs                                                          |
-| Notion        | `ntn` CLI per `notion-memory` skill - prior decisions, lessons                                  |
-| Local docs    | the OSS checkout's `docs` (ADRs, `architecture.md`, `catalog.json`), repo READMEs, `CLAUDE.md`  |
-| Past sessions | grep `~/.claude/projects/**` and `~/.claude/plans` for the ticket key                           |
-| Codebase      | `oss` MCP (read-only) + Explore - map touchpoints in `apps/api`                                 |
-
-### 3. Plan + classify (the gate)
-
-Synthesize into a plan and present it. Do NOT edit yet.
-
-- **Goal** (1-2 lines) + **Acceptance criteria** (observable, testable).
-- **Decisions found** - each with source (who/where/date), so they aren't relitigated.
-- **Open questions** - ask before proceeding if any blocks design.
-- **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. Review + tests
-
-- Run **review** on the change set; loop `[BLOCK]`/`[WARN]` fixes back through `builder`.
-- Run `/check` (typecheck + lint). Don't proceed on red.
-- Derive an e2e checklist from the AC (happy path, edge cases, authz negatives, error states), then
-  `qa`: write/run the E2E specs, drive `chrome-devtools` on failure.
-
-### 6. Open the MR
-
-Run **create-pr**: it commits (`feat(<KEY>-XXX): ...`), reports the SHA, asks for "yes push", pushes,
-and `glab mr create`s targeting `dev` with the CODEOWNERS for the changed paths as reviewers. Don't
-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 `<your-team-channel>`: 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 the linked OSS checkout; 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

@@ -1,58 +0,0 @@
-# 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 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.
-
-## Work-order template
-
-Write to `~/.claude/plans/<ticket-key>-oss.md` so both repos and future sessions can read it:
-
-```markdown
-# OSS work order - <ticket-key>: <title>
-
-## Goal
-
-<what core must do, 1-2 lines>
-
-## Unblocks
-
-consumer feature <ticket-key> - <which downstream slice depends on this>
-
-## Core surface to change
-
-- <package / module / contract / adapter token, as specific as possible>
-
-## Contract / schema impact
-
-- <new or changed oRPC contracts, Drizzle tables, events; or "none">
-
-## Acceptance
-
-- <observable outcomes that prove the core change is correct>
-
-## Dependency
-
-consumer 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.

package/template/__dot__rulesync/skills/create-pr/SKILL.md

@@ -1,55 +0,0 @@
----
-name: create-pr
-
-description: Commit, push, and open a GitLab Merge Request following this repo's promotion chain (dev -> stage -> prod). Use on "create pr", "create mr", "open a pr/mr", "/create-pr", or "promote <branch>".
----
-
-# create-pr
-
-This repo is on **GitLab** (`<your-gitlab-project>`). "PR" = Merge Request. Use the `glab` CLI
-(already installed). Environment branches are promoted along a fixed chain - never open an MR
-straight to `prod` from a feature/dev branch.
-
-## Promotion chain
-
-| Source (current) branch            | MR target | Notes                                       |
-| ---------------------------------- | --------- | ------------------------------------------- |
-| `dev` (default working)            | `stage`   | Promote accumulated work to the staging env |
-| `stage`                            | `prod`    | Promote staging -> production               |
-| any `feat/*` / `fix/*` / `<KEY>-*` | `dev`     | Feature/ticket work merges into dev first   |
-
-If the current branch isn't in the table, target `dev`.
-
-## Steps
-
-1. **Determine source + target.** `git branch --show-current` -> look it up in the
-   table above to get the target.
-2. **Scope the commit.** `git status -s`. Commit ONLY changes that belong to this
-   unit of work. If unrelated/pre-existing edits are present, do NOT bundle them -
-   stage your files explicitly and tell the user what you left out. Never
-   `git add -A` blindly when foreign changes are in the tree.
-3. **Commit.** Conventional-commit message (`feat:`, `fix:`, `docs:`, `refactor:`,
-   `chore:`); for ticket work prefix the ticket key (e.g. `feat(<KEY>-123): ...`).
-4. **Verify before pushing** (cheap insurance): run the repo's check (e.g.
-   `pnpm check:types && pnpm check:lint`). Don't push a red tree.
-5. **Push** the current branch - but STOP and get an explicit per-action "yes push"
-   from the user FIRST. Report the commit SHA, then ask. Invoking this skill is NOT
-   push authorization. Pushing to a shared/env branch (`dev`, `stage`, `prod`)
-   without that explicit yes is forbidden. Only after the yes: `git push -u origin <current>`.
-6. **Open the MR** with glab (only after the push is confirmed + done):
-   ```
-   glab mr create --source-branch <current> --target-branch <target> \
-     --title "<type>: <summary>" --description "<body>" --yes --remove-source-branch=false
-   ```
-   For a long-lived env branch (`dev`, `stage`, `prod`) NEVER pass
-   `--remove-source-branch`. Reuse an existing open MR for the same source->target
-   instead of creating a duplicate
-   (`glab mr list --source-branch <current> --target-branch <target>`).
-7. **Report** the MR URL back to the user.
-
-## Rules
-
-- NEVER push without an explicit per-action "yes push" from the user. Invoking this
-  skill does NOT authorize a push. Report the commit SHA, ask, then push only on yes.
-- The repo check must pass before the push.
-- Keep the MR scoped to one concern; split unrelated changes into separate MRs.