Source: ~/.pi/agent/skills/commit-msg/SKILL.md, “Core Contract”.

The generated commit message MUST:

1. Match the style and format of recent `develop` branch commits.
2. Use past tense.
3. Be multiline.
4. Be based solely on inspected file changes from the requested input.
5. Avoid claims that are not supported by the diff/stat/name-status data.
6. Avoid reusing a placeholder subject such as `WIP` from the target commit(s).
7. Avoid mutating git state; this skill is read-only.

Source: ~/.agents/skills/implementation-steps/SKILL.md, opening contract.

Produce a hands-on implementation course for the selected target. Every numbered
stage includes actual working source and its own detailed README. A learner who
follows the documented steps must understand what they are writing and why, and
reach the captured target code exactly. Technical correctness, exact source
equality, and teachability are separate requirements; none substitutes for another.

This workflow is language- and framework-independent. Inspect the target rather
than imposing a runtime, architecture, fixed number of stages, or previous task's
implementation choices. Create the learning artifacts; leave the target unchanged.

Source: ~/.agents/skills/lightpanda/SKILL.md, “CLI and persistent automation”.

For a known authorized URL, start with a bounded extraction:

```zsh
lightpanda fetch --dump markdown --dump-max-bytes 12000 --fail-on-http-error 'http://127.0.0.1:PORT/PATH'
```

Replace the URL with an observed application URL. Use `--dump html` for markup or `--dump semantic_tree_text` for a compact semantic tree. Inspect command status and errors; a dump alone is not proof of successful navigation or interaction.

Source: ~/.agents/skills/rex/SKILL.md, complete file.

---
name: rex
description: Use the rex CLI to manage Rex sessions, open tabs, arrange panes, run commands, inspect terminal output, and control connected Rex apps.
metadata:
  rex-stub: "2"
---


Run `rex __internal skill` and follow the guide it prints. The guide comes from
the installed Rex CLI, so it describes the commands available in that version.

If the command fails, the installed Rex version predates the guide. Start with
`rex whoami --json`, then use `rex --help` and `rex COMMAND --help`.

Source: ~/.agents/skills/ui-sdk/SKILL.md, “Read first”.

The docs for the installed version ship in each package, as Markdown:

- `node_modules/@ui-sdk//docs/llms.txt` is the index. Read it first. `` is `react`, `vue`, `svelte`, `solid` or `web`.
- Then read only the pages your task needs, like `docs/components/select.md`. Don't read the whole `docs/` folder; it's large.
- An interface built from our components doesn't need `docs/core.md`. Only path 2 below does, and even then you search it by heading: it's over 300 KB. `docs/rendering.md` sits next to it in the same `docs/` folder.
- Don't read compiled JavaScript in `dist/*.js`, even to debug. The docs and the `.d.ts` types are the API; when they don't answer, write a small test that tries it.

Here “path 2” means constructing a missing component/behavior from @ui-sdk/core, rather than composing existing components.

Source: ~/.agents/skills/ui-ux-a11y/SKILL.md, “Scope and authority gate”.

Before editing or approving work:

1. Identify the user-authorized implementation scope, repository instructions, and any applicable plan or acceptance criteria in the current project.
2. Discover and inspect the current project's actual sources of truth: existing product behavior, user-supplied reference, design contract, design system, token source, and deployed behavior when the task requires it. Do not assume any filename or path.
3. Identify every applicable `UX-*`, `A11Y-*`, `CC-*`, and `VAL-*` rule ID for the affected routes, states, locales, viewports, themes, and interactions.
4. Record the authoritative baseline required by `VAL-01` before implementation. Use a reference baseline only when the current task or project defines one.
5. Stop if a required source of truth is missing or if compliance would require an unapproved route, feature, redesign, workflow, dependency, content, permission, or product-scope change.

Its complete ui_ux_a11y/ rule folder remains authoritative; this excerpt does not replace its accessibility, contrast, and rendered-experience checks.

{
  "subagents": {
    "agentOverrides": {
      "worker": {
        "model": "openai-codex/gpt-6.1-sol",
        "thinking": "medium",
        "inheritProjectContext": true,
        "tools": [
          "read",
          "grep",
          "find",
          "ls",
          "bash",
          "edit",
          "write",
          "contact_supervisor"
        ],
        "systemPrompt": "You are the implementation worker. Implement only the assigned work traceable to actual user requirements. Never expand scope without explicit prior USER approval. Agent recommendations are not approval. The\n coordinator coordinates, maintains the progress ledger, and relays agent-authored code; it must not author or revise code. Apply advisor-provided code only after checking its applicability to the current files and approved\n requirements. At each assigned implementation checkpoint, report requirement references, changed files, validation evidence, remaining work, and ledger updates needed; request the coordinator's decision before beginning the next\n implementation unit. Use contact_supervisor with reason need_decision for blocking questions and checkpoint decisions, or progress_update for material changes requiring coordinator attention. Do not send routine narration or duplicate completion messages. Never claim validation passed without evidence."
      },
      "reviewer": {
        "model": "openai-codex/gpt-6.1-sol",
        "thinking": "high",
        "inheritProjectContext": true,
        "defaultContext": "fresh",
        "tools": [
          "read",
          "grep",
          "find",
          "ls",
          "contact_supervisor"
        ],
        "systemPrompt": "You are the read-only implementation reviewer. Review the assigned worker checkpoint against actual user requirements, the implementation, tests, and validation evidence. Do not edit files or create patch or\n report files. Return actionable findings with requirement references, exact locations, evidence, and concrete replacement code or unified diffs INLINE when useful. Distinguish actual defects from optional recommendations. Do not\n expand or redefine scope, and never treat your recommendations as user approval. Report blocking findings promptly through contact_supervisor; otherwise return a concise final review. Avoid heartbeats, duplicate findings, and routine chatter. Identify stale checkpoints and unsupported completion claims."
      },
      "oracle": {
        "model": "openai-codex/gpt-6-astra",
        "thinking": "medium",
        "inheritProjectContext": true,
        "defaultContext": "fresh",
        "tools": [
          "read",
          "grep",
          "find",
          "ls",
          "contact_supervisor"
        ],
        "systemPrompt": "You are a read-only advisor answering the specific question assigned by the coordinator. Challenge unsupported assumptions, identify architectural or correctness risks, and distinguish facts, uncertainty,\n and recommendations. When useful, provide actual corrective code or unified diffs INLINE. Do not edit files or create patch or report files. Preserve actual user requirements; scope expansion requires explicit prior USER approval. You cannot grant that approval. Escalate blocking missing decisions through contact_supervisor; otherwise return your bounded answer without routine progress chatter. Do not invent additional requirements or initiate unrelated work."
      },
      "scopeCreepPatrol": {
        "model": "openai-codex/gpt-6-astra",
        "thinking": "medium",
        "inheritProjectContext": true,
        "defaultContext": "fresh",
        "tools": [
          "read",
          "grep",
          "find",
          "ls",
          "contact_supervisor"
        ],
        "systemPrompt": "You are the read-only scope and requirement-traceability auditor. Compare the assigned worker checkpoint and progress ledger with actual user requirements and explicit prior user approvals. Detect\n unauthorized expansion, omitted or altered requirements, and agent suggestions misrepresented as user authority. Check that the ledger includes implementation-requirement references, a literal 1 to N column, status, and requirement\n origin. Do not invent the meaning of 1 to N. Preserve statuses exactly: no-started / in-progress / deferred / completed / not-applicable. Distinguish user-requirement from agent-requirement; an agent-requirement does not authorize\n scope expansion. Report evidence-backed discrepancies promptly through contact_supervisor. Supply concrete corrective code INLINE when useful and within existing scope. Never edit files, create patch or report files, redefine\n requirements, grant approvals, or manufacture acceptance gates. Avoid routine chatter."
      }
    },
    "watchdog": {
      "enabled": true,
      "scope": {
        "enabled": true
      },
      "clarification": true,
      "main": {
        "model": "openai-codex/gpt-6-astra",
        "thinking": "medium"
      },
      "cadence": {
        "everyNTools": 16
      },
      "children": {
        "enabled": false,
        "overrides": {
          "worker": {
            "enabled": true,
            "model": "openai-codex/gpt-6.1-sol",
            "thinking": "high",
            "cadence": {
              "everyNTools": 8
            }
          }
        }
      }
    }
  }
}

From local-inference/packages/pi-proxy/src/index.ts. Credentials and provider configuration stay behind ModelRuntime; refresh and listing receive the request's cancellation signal.

  static async create(options: PiBackendOptions = {}): Promise<PiBackend> {
    const { provider, ...runtimeOptions } = options;
    return new PiBackend(await ModelRuntime.create(runtimeOptions), provider);
  }

  async models(signal: AbortSignal) {
    await this.runtime.refresh({ providers: this.provider ? [this.provider] : undefined, signal });
    signal.throwIfAborted();
    const available = await this.runtime.getAvailable(this.provider, { signal });
    return available.map(model => ({ id: this.provider ? model.id : `${model.provider}/${model.id}`, owned_by: model.provider }));
  }

From the same file. Pi supplies provider metadata and custom-model resolution; the HTTP layer retains the caller's exact model ID rather than applying CLI fuzzy-name or thinking-suffix conveniences to it.

  async resolve(id: string, signal: AbortSignal): Promise<InferenceModel> {
    signal.throwIfAborted();
    const slash = id.indexOf("/");
    const provider = this.provider ?? (slash > 0 ? id.slice(0, slash) : undefined);
    const modelId = this.provider ? id : id.slice(slash + 1);
    if (!provider) throw new ApiError(400, "Use provider/model as the model ID, or start with --provider");
    await this.runtime.refresh({ providers: [provider], signal });
    signal.throwIfAborted();
    const selected = resolveCliModel({ cliProvider: provider, cliModel: modelId, modelRuntime: this.runtime });
    if (!selected.model) throw new ApiError(400, selected.error ?? "Pi could not resolve the requested model", "model_resolution_error");
    // Pi owns model construction, provider metadata and custom-model support.
    // Its CLI resolver also accepts fuzzy names/thinking suffixes; an HTTP model
    // field is an exact ID, so those conveniences must not rewrite that field.
    return { ...selected.model, id: modelId };
  }

From PiBackend.stream in the same file. Shared reasoning options use streamSimple; native reasoningEffort options use stream.

    const events = request.reasoningEffort === undefined
      ? this.runtime.streamSimple(model, context, request)
      : this.runtime.stream(model, context, request);

From local-inference/packages/server/src/index.ts, inside the event switch. Text deltas are emitted as they arrive, without waiting for provider completion.

      case "text_delta": source.push(event.delta); await chunk({ content: event.delta }); break;
      case "thinking_delta": await chunk({ reasoning_content: event.delta }); break;