@lifeaitools/rdc-skills 0.37.7 → 0.37.9

package/skills/open/SKILL.md

@@ -56,9 +56,14 @@ That is a **scoped grant**, not a readout: `permittedActions` and
 to "which checkout do I work in" — it already knows pooled repos want a lane.
 
 **Unresolved is a result, not an error.** `open regen-root` returns
-`weDoNotHold: ["product_class"]`; `open fsm` returns `unknown_slug`. Register the
-target, then open it again — never guess a default and never fall back to
-hand-rolled git.
+`weDoNotHold: ["product_class"]`; `open fsm` returns `unknown_slug`. An
+`unknown_slug` — nothing registered at all — means `rdc:new` next: it
+scaffolds and registers a product of the declared class, then hands back to
+this skill to confirm. A `weDoNotHold` entry on an otherwise-known slug is
+narrower — `rdc-harness new <slug> --environment ...` (also wrapped by
+`rdc:new`) fills in just the missing piece. Either way: register the target,
+then open it again — never guess a default and never fall back to hand-rolled
+git.
 
 **Two targets at once is two calls.** Each returns its own `bindingId` and its
 own `sourceBoundary`; nothing is exclusive. Working `clauth` and `rdc-harness`
@@ -156,14 +161,46 @@ Downstream verbs re-resolve from the registry by slug.
 2. **Target.** Read `productClass`, `workModel`, `delivery` and `weDoNotHold`
    from the same result. `monorepo_path` NULL means a standalone repo, not in
    this tree. Do not re-query the registry for facts the handle already carries.
-3. **Harness.** Name the shape the target's class implies:
-
-   | class | build | dev | prod |
-   |---|---|---|---|
-   | `apps/<name>` | `pnpm --filter @regen/<name> build` | PM2 @ Vultr | Coolify |
-   | `packages/<name>` | `pnpm --filter @regen/<name> build` | imported | `npm publish` |
-   | `sites/`, `models/` | static/vite | PM2 @ Vultr | Coolify |
-   | standalone | its own tooling | — | Coolify |
+3. **Harness.** Name the shape the target's class implies. The routes come
+   from the RPMS kind registry (`rpms_kinds` → `rpms_usages`); this table is
+   **generated from `rpms_kinds`** and never hand-edited. A new kind is one
+   row via `register_rpms_kind`, then (in rdc-skills)
+   `node scripts/gen-rpms-kind-tables.mjs --from <dump.json>`. Full guide to
+   every level, not just product classes: `docs/architecture/KINDS.md` in
+   regen-root.
+
+   <!-- BEGIN GENERATED: rpms-kinds -->
+   _Generated from `rpms_kinds` + `rpms_usages` (schema `rpms.kinds.v1`) by `scripts/gen-rpms-kind-tables.mjs` — do not hand-edit. Product-level kinds only; every other level is in `select rpms_kinds_snapshot()`._
+
+   | kind | home | build · dev (`ship_route`) | runtime | prod (`deploy_route`) |
+   |---|---|---|---|---|
+   | `app` | `apps/<slug>/` | `pm2-development` | `next` | `declared-promotion` |
+   | `artifact` | `artifacts/<slug>/` | `artifact-export` | — | — (no-production-target) |
+   | `bpmn-process` | `docs/systems/<system>/bpmn/` | `flowable-dev-release` | `java` | `flowable-release` |
+   | `city-tool` | `apps/<slug>/` | `pm2-development` | `next` | `declared-promotion` |
+   | `corpus` | `$CORPUS_ROOT/<CO>/docs/` | `content-write` | — | — (content-not-code) |
+   | `dmn-decision` _(proposed)_ | `docs/systems/<system>/dmn/` | `dmn-test-cases` | `java` | `flowable-dmn-release` |
+   | `documentation` | `docs/<slug>/` | `artifact-export` | — | — (no-production-target) |
+   | `dsl` _(proposed)_ | `packages/<pkg>/src/dsl/` | `grammar-suite` | — | — (production-is-registry) |
+   | `education-piece` | `artifacts/<slug>/` | `artifact-export` | — | — (no-production-target) |
+   | `grammar` | `packages/<pkg>/src/grammar/` | `grammar-suite` | — | — (production-is-registry) |
+   | `mcp` | `mcp-servers/<slug>/` | `plugin-registration` | `ts-server` | `declared-service-route` |
+   | `model` | `models/<slug>/` | `pm2-development` | `next` | `declared-promotion` |
+   | `ontology` | `packages/planetary-ontology/src/` | `grammar-suite` | — | — (production-is-registry) |
+   | `package` | `packages/<slug>/` | `registry-release` | — | — (production-is-registry) |
+   | `prototype` | `artifacts/<slug>/` | — | — | — (no-production-target) |
+   | `share-app` | `apps/<slug>/` | `pm2-development` | `next` | `declared-promotion` |
+   | `site-html` | `sites/<slug>/` | `static-development` | `static-html` | `declared-promotion` |
+   | `site-ts` | `sites/<slug>/` | `static-development` | `static-html` | `declared-promotion` |
+   | `skill` | `skills/<slug>/` | `local-install` | — | `release-tag` |
+   | `theme` | — | `content-write` | — | — (content-not-code) |
+   | `vendor` | `vendor/<slug>/` | `registry-release` | — | — (production-is-registry) |
+   | `worker` | `workers/<slug>/` | `edge-dev` | — | `edge-deploy` |
+   <!-- END GENERATED -->
+
+   The concrete build command is the target's own (`pnpm --filter <pkg>
+   build` in a monorepo, its own tooling standalone); the route names what
+   kind of ship and deploy it owes.
 
 4. **Visual-test contract (for an app/site with UI work).** Read the target
    `package.json` and name its `test:ui` command and Playwright config. A
@@ -216,6 +253,8 @@ Downstream verbs re-resolve from the registry by slug.
 
 ## Related
 
+- `rdc:new` — an `unknown_slug` or a `weDoNotHold` gap routes here: scaffold and
+  register a product, or just its deployment environment, then re-open.
 - `guides/work-contract.md` — the contract this skill opens: rows, tiers, proving,
   staleness, and what Stop checks.
 - `rdc:flow` — declares what KIND of work this is. `rdc-work start --type` sets it

package/skills/regen-media/SKILL.md

@@ -36,38 +36,143 @@ codex login status
 codex features list
 ```
 
-Requirements for size to apply:
-
-1. Use `--enable image_generation`.
-2. Use `-c model=gpt-5.5`.
-3. Instruct Codex: `use the built-in image_gen tool DIRECTLY; do not write API keys, scripts, or MCP`.
-4. Name the target size in the instruction, such as `2048x1152`, `2048x2048`, or `3840x2160`.
+### Parameters are not interchangeable
+
+Checked 2026-09-26 against official documentation, installed Codex 0.153.4,
+the bundled imagegen CLI, and regen-media's `generateLocalSchema`.
+
+| Input | Keyless Codex / `generate_local` | Bundled API script |
+|---|---|---|
+| Description | `prompt`; describe the requested change for edits | `--prompt` or `--prompt-file` |
+| Style, tones, lighting | Named sections inside `prompt` | `--style`, `--palette`, `--lighting`; these augment the prompt |
+| Corpus information | Read selected authorized sources first; include relevant facts and source references in the brief | Same; `--prompt-file` can contain the assembled brief. No automatic corpus retrieval flag |
+| Image to update | `mode: "edit"`, `source_image`; direct Codex uses `-i` | `edit --image <path>`; repeat for additional references |
+| Size | `size` currently becomes a prompt request, NOT a guaranteed native tool parameter | `--size 3840x2160` is sent as an API parameter |
+| Quality / output format | Only pass native fields if the current built-in tool schema exposes them; do not invent flags | `--quality high --output-format png` |
+| Output location | `generate_local` has `out_name`, not `output_dir`; direct Codex copies its generated artifact to the requested destination | `--out <file>` or `--out-dir <directory>` |
+| Model | `model` / `-m` selects the Codex reasoning model, not an image-model parameter | `--model gpt-image-2` selects the image model |
+
+The CLI's `--enable image_generation`, `-m`, `-i`, and `--cd` enable the tool,
+select the reasoning model, attach input images, and choose the workspace.
+They do not establish output dimensions. `--output-last-message` saves text,
+not an image. Do not invent `codex exec --size`, `--quality`, or a TOML image-size
+setting: use only fields exposed by the installed command/tool schema.
+
+The former four-step recipe was not a size guarantee. On 2026-09-26, two local
+media calls and a direct `gpt-5.5` call with those exact instructions requested
+3840x2160 but produced 1672x941. The available built-in schema exposed a prompt
+and reference images, not a native `size` field. Treat this as observed behavior
+of that environment, not a permanent limit of all Codex versions.
+
+Retain the user's requested dimensions in the brief, inspect the current tool
+schema, then measure the saved output. If a hard size requirement is missed,
+report it as unmet; do not repeat identical requests, silently resample, or
+silently switch to a paid API. A re-render can change composition and is not a
+lossless upscale.
 
 Text to image:
 
 ```bash
-echo "Use the built-in image_gen tool DIRECTLY at size 3840x2160 (4K). No API keys/scripts/MCP. Copy the PNG to output/imagegen/<name>.png and reply with only that path + pixel dims. Prompt: <dense art-directed prompt>." | codex exec --enable image_generation --dangerously-bypass-approvals-and-sandbox --cd "$PWD" -c model=gpt-5.5
+echo 'Use $imagegen and the built-in image_gen tool directly. Generate the described image, requested size 3840x2160. No API or MCP fallback. Use native size only if exposed by the tool schema. Copy the full-resolution output from this run to .rdc/tmp/imagegen/hero-v2.png. Measure and report actual dimensions; report any size mismatch without resizing. Brief: <description, style, palette, lighting, composition, constraints>.' | codex exec --enable image_generation --cd "$PWD" -m gpt-5.5 -
 ```
 
 Image edit, re-render, or upscale:
 
 ```bash
-echo "Use the built-in image_gen tool DIRECTLY to re-render the ATTACHED image at size 3840x2160 (4K), preserving its composition, subject, palette, and lighting. No API keys/scripts/MCP. Save to output/imagegen/<name>-4k.png and reply with only the path + dims." | codex exec -i "input/source.png" --enable image_generation --dangerously-bypass-approvals-and-sandbox --cd "$PWD" -c model=gpt-5.5
+echo 'Use $imagegen and the built-in image_gen tool directly to edit the attached image. Change: <requested change>. Preserve: <invariants>. Request 3840x2160; do not claim that size unless measured. No API or MCP fallback. Copy the output to .rdc/tmp/imagegen/hero-v2.png; report path and actual dimensions, without resizing.' | codex exec -i "input/source.png" --enable image_generation --cd "$PWD" -m gpt-5.5 -
 ```
 
 Notes:
 
-- The keyless path uses the local ChatGPT Pro OAuth in the Codex install, not `OPENAI_API_KEY`.
-- Output may land both in the requested path and under `~/.codex/generated_images/<session-id>/ig_*.png`.
+- These examples retain configured approval and sandbox settings. Do not disable safeguards merely to generate an image. `gpt-5.5` is an example previously used locally, not a documented requirement for all Codex versions.
+- The keyless path uses the local ChatGPT login, not `OPENAI_API_KEY`, and consumes included Codex usage limits.
+- Built-in output lands under `$CODEX_HOME/generated_images/`; copy the specific output belonging to this run. Never recover the newest image across unrelated sessions.
 - Use a long timeout or background session; generation commonly takes 2-5 minutes.
-- Valid `gpt-image-2` sizes include `1024x1024`, `1536x1024`, `1024x1536`, `2048x2048`, `2048x1152`, `3840x2160`, `2160x3840`, and `auto`, subject to model constraints.
+- API-supported sizes do not prove that Codex exposes matching controls.
+
+## Calling regen-media-local
+
+Use its MCP `generate_local` when the caller requested that service. Discover
+its current tool schema rather than assuming local and remote servers expose
+the same tools. The inspected implementation accepts this shape:
+
+```json
+{
+  "prompt": "Purpose: RDC masthead. Change: replace the boy with a community square. Style: cinematic landscape. Palette: warm amber and deep forest green. Composition: elevated valley view, distant mountains, quiet upper-left copy area. Preserve: river and overall lighting. Context: selected authorized place facts from the brief; do not invent measured outcomes.",
+  "mode": "edit",
+  "source_image": "C:/path/to/original.png",
+  "size": "3840x2160",
+  "out_name": "rdc-masthead-town-square-v2",
+  "model": "gpt-5.5",
+  "auto_upload": false
+}
+```
+
+This is the tool's argument object, not a shell command. For a fresh image use
+`mode: "text_to_image"` and omit `source_image`. The current service resolves
+output beneath `<CODEX_CD>/output/imagegen/<prefix>/<out_name>.png`; it does not
+accept a per-call output directory. Do not silently change shared `CODEX_CD`.
+Copy a selected result to the caller's authorized project destination afterward.
+Its returned `size` is the request; `width` and `height` are measurements. A
+success message alone does not prove exact size. Keep `auto_upload: false` until
+size and visual checks pass. Do not label a mismatched file as native 4K.
+
+## Explicit parameterized API script
+
+Codex's installed imagegen skill includes `scripts/image_gen.py`. This is a real
+script accepting a parameter set and an output directory, but it is a separate,
+credentialed API path, not the keyless Codex image tool or `generate_local`.
+Use only after the user chooses that path. Obtain credentials through the
+environment's approved vault mechanism; never ask for keys in chat. A request
+to research parameters or update this skill is not permission for a paid run.
+
+Read the installed imagegen CLI reference and `--help` before using it. Example
+PowerShell call, with `--dry-run` so no key, network or generation is needed:
+
+```powershell
+$imageGenScript = Join-Path $env:USERPROFILE '.codex/skills/.system/imagegen/scripts/image_gen.py'
+python $imageGenScript edit `
+  --model gpt-image-2 `
+  --image 'C:/path/to/original.png' `
+  --prompt-file 'C:/path/to/approved-brief.txt' `
+  --style 'cinematic landscape' `
+  --palette 'warm amber, deep forest green, blue mountains' `
+  --lighting 'sunset with warm community lights' `
+  --composition 'elevated valley, distant mountains, quiet upper-left copy area' `
+  --constraints 'preserve river; no boy, text or network lines' `
+  --size 3840x2160 --quality high --output-format png `
+  --out-dir 'C:/path/to/approved-output-directory' `
+  --dry-run
+```
+
+For generation, replace `edit` with `generate` and omit `--image`. For a stable
+filename use `--out` instead of `--out-dir`. Respect `CODEX_HOME` if configured;
+the example uses the default Windows installation path. Do not modify the
+bundled script or build another wrapper for parameters it already supports.
+
+Corpus content is not an API parameter. Read only the requested sources, select
+relevant authorized facts, retain source references alongside the brief, and
+state which are conceptual rather than observed. Never bulk-send a corpus or
+claim that mentioning a file path makes the generator read its contents.
+
+For `gpt-image-2`, size is `auto` or constrained `WIDTHxHEIGHT`: edges divisible
+by 16, maximum edge 3840, ratio at most 3:1, and 655360–8294400 total pixels.
+Above 2560x1440 is experimental. API output still requires dimension and visual
+checks. Style/palette/lighting are prompt augmentation, not separate model
+rendering controls. `input_fidelity` is not supported for `gpt-image-2`.
+
+Sources (checked 2026-09-26):
+- [Codex image generation and reference-image guidance](https://learn.chatgpt.com/docs/image-generation)
+- [Codex CLI flags](https://developers.openai.com/codex/cli/reference)
+- [Responses image tool parameters](https://developers.openai.com/api/docs/guides/tools-image-generation)
+- [Image API and resolution constraints](https://developers.openai.com/api/docs/guides/image-generation)
 
 ## Upload to Regen Media
 
 After generation, upload finished images through the project uploader when available:
 
 ```powershell
-powershell.exe -ExecutionPolicy Bypass -File "{PROJECT_ROOT}/scripts/upload-to-media.ps1" "output/imagegen/<name>.png"
+powershell.exe -ExecutionPolicy Bypass -File "{PROJECT_ROOT}/scripts/upload-to-media.ps1" ".rdc/tmp/imagegen/<name>.png"
 ```
 
 The uploader obtains `regen-media-api` from clauth and posts to Regen Media. Never print credential values. If upload is not required, return the local artifact path and dimensions.
@@ -81,15 +186,15 @@ Use the deployed regen-media MCP/API generation path only when the local Codex i
 1. Classify the task: `generate`, `edit`, `upscale`, or `upload`.
 2. If `RDC_TEST=1`, print the selected path and planned commands without executing external calls.
 3. For generation/edit/upscale, attempt the local keyless Codex preflight.
-4. Build the Codex `exec` command with the requested size and explicit built-in `image_gen` instruction.
-5. Save to `output/imagegen/` or a caller-provided path.
-6. Verify the file exists and record pixel dimensions.
+4. Use the requested service, keyless Codex command, or explicitly chosen API script; distinguish prompt fields from supported native parameters.
+5. Save/copy non-destructively to the caller-provided path, or `.rdc/tmp/imagegen/` for Regen Root scratch. Preserve the original.
+6. Verify this run's file exists, measure actual pixel dimensions, compare with requested size, and inspect composition. Stop and report unmet constraints on mismatch.
 7. If the artifact should be managed, upload it to Regen Media and return the media URL/slug plus local path.
-8. If local Codex is unavailable, use the server-side regen-media generation fallback and clearly say that it is the fallback path.
+8. If local Codex is unavailable or cannot meet a hard requirement, explain the credentialed fallback and obtain the user's choice before invoking it.
 
 ## Boundaries
 
 - Do not write or expose API keys.
 - Do not silently downgrade from local keyless `gpt-image-2` to server-side MCP/API generation.
-- Do not use prompt-only size hints; always set the Codex command and instruction shape above.
+- Do not present prompt-only size requests as native parameters or guarantee dimensions from CLI flags alone.
 - Do not run generation or upload in test mode.

package/tests/lib/jsx-references.test.mjs

@@ -0,0 +1,113 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { treesitterPlugin } from '../../scripts/lib/plugins/treesitter.mjs';
+import { srp } from '../../scripts/lib/solid-scoring.mjs';
+
+let fixture = 0;
+function inspect(body, prefix = 'const registry = { a: A };') {
+  const [unit] = treesitterPlugin.extractUnits(`/jsx-reference-${fixture++}.tsx`,
+    `function A() { return null; } ${prefix} function B() { ${body} }`);
+  return { calls: unit.members.find(m => m.name === 'B').calls, score: srp(unit).score };
+}
+
+test('direct call and opening/self-closing JSX have the same local dependency', () => {
+  for (const body of ['return A();', 'return <A/>;', 'return <A></A>;']) {
+    const result = inspect(body);
+    assert.ok(result.calls.includes('A'));
+    assert.equal(result.score, 100);
+    assert.equal(result.calls.filter(c => c === 'A').length, 1);
+  }
+});
+
+test('member JSX and const aliases resolve a statically selected registry entry', () => {
+  for (const body of ['return <registry.a/>;', 'const C = registry.a; return <C/>;',
+    'const C = registry["a"]; return C();', 'const C = registry.a; const D = C; return <D/>;']) {
+    assert.ok(inspect(body).calls.includes('A'), body);
+  }
+});
+
+test('external member JSX retains receiver; intrinsic tags are not component calls', () => {
+  const { calls } = inspect('return <><UI.A/><a/><div/></>;', '');
+  assert.deepEqual(calls, ['UI.A']);
+});
+
+test('dynamic lookup, spread, reassignment, parameter shadow and cycles stay unresolved', () => {
+  const cases = [
+    ['const C=registry[key]; return <C/>;', 'const registry=getRegistry();'],
+    ['const C=registry.a; return <C/>;', 'const registry={a:A,...other};'],
+    ['registry.a=other; const C=registry.a; return <C/>;', 'const registry={a:A};'],
+    ['const C=registry.a; return <C/>;', 'let registry={a:A};'],
+    ['const C=registry.a; return <C/>;', 'const registry={a:A,[key]:other};'],
+    ['const C=registry.a; return <C/>;', 'const registry={a:A,a:other};'],
+    ['consume(registry); const C=registry.a; return <C/>;', 'const registry={a:A};'],
+    ['const C=D; const D=C; return <C/>;', ''],
+    ['function nested(registry){ const C=registry.a; return <C/>; } return nested({});', 'const registry={a:A};'],
+    ['function nested(A){ const registry={A}; const C=registry.A; return <C/>; } return nested(other);', ''],
+    ['const {registry}=other; return <registry.a/>;', 'const registry={a:A};'],
+    ['consume({registry}); return <registry.a/>;', 'const registry={a:A};'],
+    ['(registry.a)=Other; return <registry.a/>;', 'const registry={a:A};'],
+    ['[registry.a]=[Other]; return <registry.a/>;', 'const registry={a:A};'],
+    ['for(const A of others){return <A/>;}', ''],
+    ['function A(){return null;} return <A/>;', ''],
+    ['const f=function A(){return <A/>;}; return f();', ''],
+    ['const f=class A { render(){return <A/>;} }; return f;', ''],
+  ];
+  for (const [body, prefix] of cases) assert.ok(!inspect(body, prefix).calls.includes('A'), body);
+});
+
+test('unused registry values do not create call edges', () => {
+  assert.equal(inspect('return null;').score, 70);
+});
+
+test('const assertions and shorthand registry entries retain the selected reference', () => {
+  assert.ok(inspect('return <registry.A/>;', 'const registry={A} as const;').calls.includes('A'));
+});
+
+test('JSX parameter shadows do not connect an unrelated module function', () => {
+  const [unit] = treesitterPlugin.extractUnits('/jsx-param-shadow.tsx', 'function A(){return null;} function B(A){return <A/>;}');
+  assert.deepEqual(unit.members.find(member => member.name === 'B').calls, []);
+  assert.equal(srp(unit).score, 70);
+});
+
+test('closed registry dispatch records possible call targets, as explicit branches do', () => {
+  const prefix = 'function A(){return null;} function B(){return null;} function Fallback(){return null;} const registry={a:A,b:B};';
+  for (const body of [
+    'const C=registry[key] ?? Fallback; return <C/>;',
+    'const C=registry[key] ?? Fallback; return C();',
+  ]) {
+    const [unit] = treesitterPlugin.extractUnits(`/closed-dispatch-${fixture++}.tsx`, `${prefix} function Render(key){${body}}`);
+    const calls = unit.members.find(member => member.name === 'Render').calls;
+    for (const target of ['A', 'B', 'Fallback']) assert.ok(calls.includes(target), `${body}: ${target}`);
+    assert.equal(srp(unit).score, 100);
+  }
+});
+
+test('literal selection does not connect unselected registry entries', () => {
+  const [unit] = treesitterPlugin.extractUnits('/literal-selection.tsx',
+    'function A(){return null;} function B(){return null;} const registry={a:A,b:B}; function Render(){const C=registry["a"];return <C/>;}');
+  assert.deepEqual(unit.members.find(member => member.name === 'Render').calls, ['A']);
+  assert.equal(srp(unit).score, 70);
+});
+
+test('dynamic registry analysis preserves mutation, escape, shadow and open-object negatives', () => {
+  const negatives = [
+    ['const registry=getRegistry();', ''],
+    ['let registry={a:A};', ''],
+    ['const registry={a:A,...other};', ''],
+    ['const registry={a:A,[key]:Other};', ''],
+    ['const registry={a:A,a:Other};', ''],
+    ['export const registry={a:A};', ''],
+    ['const registry={a:A};', 'consume({registry});'],
+    ['const registry={a:A};', '(registry.a)=Other;'],
+    ['const registry={a:A};', '[registry.a]=[Other];'],
+    ['const registry={a:A};', 'const {registry}=other;'],
+    ['A=Other; const registry={a:A};', ''],
+    ['const registry={a:A};', 'for (registry.a of others) {}'],
+    ['const registry={a:A};', 'for (registry.a in other) {}'],
+  ];
+  for (const [prefix, before] of negatives) {
+    const result = inspect(`${before} const C=registry[key] ?? ExternalFallback; return <C/>;`, prefix);
+    assert.ok(!result.calls.includes('A'), `${prefix} ${before}`);
+    assert.ok(result.calls.includes('ExternalFallback'));
+  }
+});