@guidobuilds/forge-ai 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Versions prior to 0.3.0 are not reconstructed here; see git history for earlier changes.
+
+## [Unreleased]
+
+## [0.3.0] - 2026-05-15
+
+### Added
+
+- Unified canonical **artifact** model: all sources live under `artifacts/<name>/<name>.md` and declare `kind: agent | skill` in frontmatter. Each per-platform block can override `kind`, so one artifact renders as an agent on one platform and a skill on another.
+- `forge` orchestrator installs as a Claude Code **skill** (`/forge`) on Claude Code, while remaining a primary agent on OpenCode and Codex. This fixes the previous setup where `forge` was installed as a Claude subagent and could not delegate to `forge-worker` (Claude subagents cannot call `Task`).
+- Installer **classifies each destination** as one of `new`, `managed-unmodified`, `managed-modified`, or `foreign`, and prints the status next to each file (`[refresh]`, `[overwrite, backup -> …]`, `[foreign overwrite]`, `[new]`).
+- **Automatic backups** of user-edited Forge files before overwrite or prune, stored under `~/.forge-ai/backups/<scope>/<ISO-timestamp>/<relative-path>`. A single timestamp directory groups all backups from one run.
+- **Combined confirmation prompt** in interactive mode listing every file that needs the user's decision (edited overwrites, edited deletions, foreign overwrites) with the destination backup directory.
+- Non-interactive installs refuse with exit code 1 when there are edited or foreign files and neither `--yes` nor `--force` is set, instead of silently overwriting.
+- New diagnostic codes: `MANAGED_FILE_OVERWRITE`, `FOREIGN_FILE_OVERWRITE`, `MISSING_KIND`, `INVALID_KIND`, `INVALID_PLATFORM_KIND`, `OPENCODE_MODE_ON_SKILL`, `SUPPORT_FILES_NOT_COPIED`.
+- Claude tool and model validation (`src/adapters/claude-known.ts`): unknown tools/models in agent frontmatter emit warnings instead of being silently accepted.
+- Skill source directories now allow sibling files (groundwork for future support-file bundling); detected files emit an `info` diagnostic noting that copying is not yet implemented.
+
+### Changed
+
+- Source layout: `agents/` and `skills/` directories are gone; everything moved to `artifacts/<name>/<name>.md`.
+- `forge-worker` agent and `forge-worker` skill (previously two files with the same name in separate namespaces) merged into a **single** `forge-worker` artifact rendered as a subagent on every platform. The artificial "thin agent loads a skill" indirection is removed.
+- `package.json` `files` now ships `artifacts/` instead of `agents/` + `skills/`.
+- Refreshing a managed-unmodified file is **silent** — no warning emitted. Previously every existing destination produced an indiscriminate `OVERWRITE_FORCED`.
+- Stale-managed files the user edited are now **backed up and deleted** during `update` (when `--yes`/`--force`); previously they were left on disk with a `CHECKSUM_MISMATCH` warning. Interactive runs prompt before backing up + deleting.
+- OpenCode `permissions` keys switched from boolean (`true`/`false`) to explicit strings (`allow`/`deny`); orchestrator now explicitly denies file/code operations.
+- Adapters consume a unified `CanonicalArtifact` type (with `body` field) instead of separate `CanonicalAgent`/`CanonicalSkill` types.
+- Frontmatter parsing now uses the `yaml` library (replaces the hand-rolled parser), with stricter spec compliance and better edge-case handling (colons in descriptions, horizontal rules in bodies, BOM, CRLF).
+- Claude agent `tools` and skill `allowed-tools` are emitted as comma-separated strings (matches Claude Code's native format).
+- Development tooling migrated from npm to **pnpm**: `packageManager: "pnpm@11.1.1"` pinned via Corepack (no global install needed); `pnpm.onlyBuiltDependencies: []` allowlist is explicit so postinstall script blocking is documented behavior. The published package is unaffected — consumers still install via `npx`.
+
+### Removed
+
+- `CanonicalAgent` and `CanonicalSkill` types (replaced by `CanonicalArtifact`).
+- `agents/` and `skills/` source directories.
+- `DESTINATION_EXISTS` error and `OVERWRITE_FORCED` warning (replaced by status-aware `MANAGED_FILE_OVERWRITE` and `FOREIGN_FILE_OVERWRITE`).
+- `CHECKSUM_MISMATCH` warning during prune (the file is now backed up and deleted on consent).
+- `package-lock.json` (replaced by `pnpm-lock.yaml`).
+
+### Fixed
+
+- `forge` orchestrator deployment to Claude Code now actually works: it is installed as a `/forge` skill in the main thread, which retains the `Task` tool and can delegate to the `forge-worker` subagent. The previous subagent install was inert because Claude subagents cannot call `Task`.
+- Installer no longer raises spurious overwrite warnings for files Forge installed itself and that have not been edited.
+
+### Security
+
+- Migrated the development workflow to pnpm. pnpm 10+ **blocks postinstall scripts by default** (`onlyBuiltDependencies` allowlist), enforces strict `node_modules` (no phantom dependencies), and uses an auditable text lockfile (`pnpm-lock.yaml`). The npm registry is the same, but install-time defaults are hardened.
+- User edits to Forge-managed files are **always backed up** before being overwritten or deleted, eliminating silent data loss when running `update` against a customized install.
+
+### Migration from 0.2.0
+
+- Run `npx @guidobuilds/forge-ai update` (not `install`) after upgrading. `update` prunes the now-orphaned `.claude/agents/forge.md` and the old standalone `forge-worker` skill from the previous layout. Local edits to any of those files are backed up automatically to `~/.forge-ai/backups/`.
+- `install` (without `update`) will leave the orphaned files on disk. They are harmless but unmanaged.

package/README.md

@@ -77,7 +77,7 @@ The same operating model is shared across all supported agents so the workflow s
 The primary installer is the npm CLI:
 
 ```sh
-npx forge-ai install
+npx @guidobuilds/forge-ai install
 ```
 
 The installer prompts for the target agent platform and whether Forge should be installed globally for your user or locally for the current project.
@@ -85,34 +85,36 @@ The installer prompts for the target agent platform and whether Forge should be
 To update an existing install:
 
 ```sh
-npx forge-ai update
+npx @guidobuilds/forge-ai update
 ```
 
 For non-interactive environments:
 
 ```sh
-npx forge-ai install --platform all --scope user --yes
+npx @guidobuilds/forge-ai install --platform all --scope user --yes
 ```
 
 Preview the files without writing them:
 
 ```sh
-npx forge-ai install --platform all --scope user --dry-run
+npx @guidobuilds/forge-ai install --platform all --scope user --dry-run
 ```
 
 Validate a local Forge source tree:
 
 ```sh
-npx forge-ai validate --source .
+npx @guidobuilds/forge-ai validate --source .
 ```
 
 ## Local Development
 
+Forge uses [pnpm](https://pnpm.io) for development (pinned via `packageManager` in `package.json`, so `corepack enable` is enough — no global install needed). The published package is still consumed by end users via `npx`/npm, unchanged.
+
 From a local checkout:
 
 ```sh
-npm install
-npm run build
+pnpm install
+pnpm run build
 node bin/forge-ai.mjs install --source . --platform all --scope user
 ```
 
@@ -127,11 +129,15 @@ node bin/forge-ai.mjs install --source . --platform all --scope project --dry-ru
 Run the npm updater:
 
 ```sh
-npx forge-ai update
+npx @guidobuilds/forge-ai update
 ```
 
 Forge replaces its managed agent and skill definitions in your supported agent configuration directories.
 
+Forge records installed files in manifests under `~/.forge-ai/` so updates can safely remove files that are no longer bundled. `update` prunes stale managed files by default only when the current file still matches the recorded checksum; use `--no-prune` to keep stale managed files. `--dry-run` previews writes and deletes without changing files or manifests.
+
+Forge now routes a single canonical artifact to the right artifact kind per agent: the orchestrator installs as a Claude Code skill (`/forge`) but as an agent on OpenCode and Codex. If you installed an earlier version, run `update` (not `install`) so Forge prunes the now-stale `forge` agent and standalone `forge-worker` skill left by the previous layout.
+
 ## Uninstalling
 
 Remove Forge from the agent configuration directories for OpenCode, Codex, or Claude Code by deleting the installed Forge agent and skill entries.

package/{agents → artifacts/forge}/forge.md

@@ -1,15 +1,25 @@
 ---
 name: forge
 description: Forge orchestrator with dynamic runtime routing and a single worker type
+kind: agent
 claude:
-  permissions:
-    tools: [Task, AskUserQuestion, TodoWrite]
+  kind: skill
 opencode:
   mode: primary
   permissions:
-    task: true
-    question: true
-    todowrite: true
+    task: allow
+    question: allow
+    todowrite: allow
+    read: deny
+    write: deny
+    edit: deny
+    bash: deny
+    glob: deny
+    grep: deny
+    list: deny
+    patch: deny
+    skill: allow
+    webfetch: deny
 ---
 
 # Role

package/artifacts/forge-grill/forge-grill.md

@@ -0,0 +1,93 @@
+---
+name: forge-grill
+description: Stress-test a plan or design through Forge orchestration, batching user questions while delegating codebase-answerable work to forge-worker.
+kind: skill
+---
+
+# Forge Grill Skill
+
+## Role
+
+Use this skill when the user wants Forge to stress-test, challenge, or "grill" a plan, design, proposal, or implementation approach.
+
+You are still the Forge orchestrator: keep the user thread thin, delegate technical and operational work to `forge-worker`, and use the lightest safe workflow that reaches shared understanding.
+
+## Core behavior
+
+- Build a decision tree for the plan or design under review.
+- Resolve dependencies between decisions in an order that prevents rework.
+- Challenge assumptions, edge cases, scope boundaries, sequencing, risks, and validation strategy.
+- Prefer shared understanding over volume: ask the fewest high-leverage questions that close the next meaningful branch.
+- Do not perform worker work inline.
+
+## Question policy
+
+- Use the `question` tool for questions that require the user's judgment, preference, product intent, approval, or risk tolerance.
+- Group related questions into small batches, usually 2-4 questions, instead of asking one question at a time.
+- For each question or option, include Forge's recommended answer and a brief rationale so the user can accept or correct it quickly.
+- Keep each batch focused on one decision branch or tightly related set of branches.
+- Do not ask the user questions that can be answered by inspecting the repository, existing artifacts, logs, tests, or documentation available in the workspace.
+
+## Delegation policy
+
+When a question can be answered by exploring the codebase or existing Forge artifacts, launch `forge-worker` instead of asking the user.
+
+Use `forge-worker` for:
+
+- repository inspection
+- artifact review
+- validation checks
+- feasibility or integration discovery
+- implementation-plan consistency checks
+- technical risk investigation
+
+Keep each worker prompt bounded and explicit about:
+
+- the plan/design branch being tested
+- what facts to inspect
+- what is out of scope
+- expected validation or evidence
+- that the worker must not ask the user directly
+
+## Worker contract enforcement
+
+Every delegated worker run must return exactly the Forge worker contract:
+
+```text
+STATUS: success|partial|blocked
+WORK_TYPE: inspect|design|plan|build|operate|verify|mixed
+FEATURE_SLUG: <kebab-case>
+ARTIFACTS:
+- <path or None>
+SUMMARY:
+- <point>
+NEXT_RECOMMENDED: inspect|design|plan|build|operate|verify|ask-user|none
+RISKS:
+- <risk or None>
+QUESTIONS:
+1) <question>
+```
+
+`QUESTIONS` must appear only when `STATUS: blocked`.
+
+If a worker response is malformed, request one reformat retry for the same task. If it is malformed again, stop and surface an actionable orchestration error.
+
+## Grill workflow
+
+1. Restate the goal, known constraints, and the plan/design surface being grilled.
+2. Identify decision branches and separate them into:
+   - repo-answerable facts for `forge-worker`
+   - user-owned decisions for the `question` tool
+   - safe assumptions that can be stated and revisited
+3. Delegate repo-answerable inspection before asking the user about the same branch.
+4. Ask small batches of user-owned questions with a recommended answer for each.
+5. After each batch or worker result, update the decision tree and resolve dependent branches.
+6. Stop when the remaining unknowns are either resolved, explicitly accepted as risks, or safely deferred.
+
+## Output style to the user
+
+- Be direct and rigorous, but not performative.
+- Explain why each question matters.
+- Include recommendations in actionable language, such as "Recommended: choose A because...".
+- Make unresolved risk visible before moving to build, plan, or approval-seeking work.
+- If grilling reveals implementation work is needed, route it through the normal Forge worker model instead of doing it inline.

package/{skills/forge-worker/SKILL.md → artifacts/forge-worker/forge-worker.md}

@@ -1,15 +1,35 @@
 ---
 name: forge-worker
-description: Execute bounded Forge work across inspect, design, plan, build, operate, and verify modes.
+description: Forge universal worker for inspect, design, plan, build, operate, and verify work
+kind: agent
+claude:
+  permissions:
+    tools: [TodoWrite, Read, Write, Edit, Bash, Glob, Grep, LS, MultiEdit, WebFetch]
+opencode:
+  mode: subagent
+  permissions:
+    todowrite: allow
+    read: allow
+    write: allow
+    edit: allow
+    bash: allow
+    glob: allow
+    grep: allow
+    list: allow
+    patch: allow
+    skill: allow
+    webfetch: allow
 ---
 
-# Forge Worker Skill
+# Forge Worker
 
 ## Role
 Execute only the subgoal assigned by the Forge orchestrator.
 
 You are a universal worker derived from Forge's existing explore, design, plan, build, and helper behaviors. Treat those as internal modes, not mandatory phases.
 
+You are the only worker type in Forge. The orchestrator may launch multiple instances of you in parallel or sequence.
+
 ## Inputs
 
 - Orchestrator prompt with the assigned subgoal, constraints, approval context, and expected validation

package/{skills/using-forge/SKILL.md → artifacts/using-forge/using-forge.md}

@@ -1,6 +1,7 @@
 ---
 name: using-forge
 description: Route work through the lightest safe Forge workflow using dynamic runtime routing.
+kind: skill
 ---
 
 # Using Forge Skill

package/dist/src/adapters/claude-known.js

@@ -0,0 +1,31 @@
+export const knownClaudeTools = new Set([
+    'Read',
+    'Write',
+    'Edit',
+    'MultiEdit',
+    'NotebookEdit',
+    'Bash',
+    'Glob',
+    'Grep',
+    'LS',
+    'Task',
+    'TodoWrite',
+    'WebFetch',
+    'WebSearch',
+    'AskUserQuestion',
+    'ExitPlanMode'
+]);
+const mcpToolPattern = /^mcp__[A-Za-z0-9_-]+__[A-Za-z0-9_*-]+$/;
+export function isKnownClaudeTool(name) {
+    return knownClaudeTools.has(name) || mcpToolPattern.test(name);
+}
+export const knownClaudeModels = new Set([
+    'sonnet',
+    'opus',
+    'haiku',
+    'inherit'
+]);
+const versionedModelPattern = /^claude-(?:sonnet|opus|haiku)-[A-Za-z0-9.-]+$/;
+export function isKnownClaudeModel(value) {
+    return knownClaudeModels.has(value) || versionedModelPattern.test(value);
+}

package/dist/src/adapters/claude.js

@@ -1,32 +1,44 @@
 import { stringifyYaml } from '../frontmatter.js';
 import { diagnostic } from '../diagnostics.js';
-import { isRecord, stringList } from './shared.js';
-export function renderClaudeAgent(agent) {
+import { isKnownClaudeModel, isKnownClaudeTool } from './claude-known.js';
+import { isRecord, patternList, stringList } from './shared.js';
+export function renderClaudeAgent(artifact) {
     const diagnostics = [];
-    const fm = { name: agent.name, description: agent.description };
-    if (agent.claude?.model)
-        fm.model = agent.claude.model;
-    const permissions = agent.claude?.permissions;
+    const fm = { name: artifact.name, description: artifact.description };
+    if (artifact.claude?.model) {
+        fm.model = artifact.claude.model;
+        if (!isKnownClaudeModel(artifact.claude.model)) {
+            diagnostics.push(diagnostic('warning', 'CLAUDE_UNKNOWN_MODEL', `Unknown Claude model "${artifact.claude.model}" for ${artifact.name}`, { platform: 'claude' }));
+        }
+    }
+    const permissions = artifact.claude?.permissions;
     const tools = isRecord(permissions) ? stringList(permissions.tools) : stringList(permissions);
-    if (tools)
-        fm.tools = tools;
-    else if (permissions !== undefined)
-        diagnostics.push(diagnostic('info', 'CLAUDE_AGENT_TOOLS_IGNORED', `Claude agent permissions must be a tools string list for ${agent.name}`, { platform: 'claude' }));
-    return { content: `${stringifyYaml(fm)}${agent.definition}\n`, diagnostics };
+    if (tools) {
+        fm.tools = tools.join(', ');
+        for (const tool of tools) {
+            if (!isKnownClaudeTool(tool)) {
+                diagnostics.push(diagnostic('warning', 'CLAUDE_UNKNOWN_TOOL', `Unknown Claude tool "${tool}" for ${artifact.name}`, { platform: 'claude' }));
+            }
+        }
+    }
+    else if (permissions !== undefined) {
+        diagnostics.push(diagnostic('info', 'CLAUDE_AGENT_TOOLS_IGNORED', `Claude agent permissions must be a tools string list for ${artifact.name}`, { platform: 'claude' }));
+    }
+    return { content: `${stringifyYaml(fm)}${artifact.body}\n`, diagnostics };
 }
-export function renderClaudeSkill(skill) {
+export function renderClaudeSkill(artifact) {
     const diagnostics = [];
-    const fm = { name: skill.name, description: skill.description };
-    const permissions = skill.claude?.permissions;
-    const allowedTools = isRecord(permissions) ? stringList(permissions['allowed-tools']) : undefined;
+    const fm = { name: artifact.name, description: artifact.description };
+    const permissions = artifact.claude?.permissions;
+    const allowedTools = isRecord(permissions) ? patternList(permissions['allowed-tools']) : undefined;
     if (allowedTools) {
-        fm['allowed-tools'] = allowedTools;
-        diagnostics.push(diagnostic('warning', 'CLAUDE_SKILL_ALLOWED_TOOLS', `Claude skill allowed-tools preapproves tools but does not universally restrict them for ${skill.name}`, { platform: 'claude' }));
+        fm['allowed-tools'] = allowedTools.join(', ');
+        diagnostics.push(diagnostic('warning', 'CLAUDE_SKILL_ALLOWED_TOOLS', `Claude skill allowed-tools preapproves tools but does not universally restrict them for ${artifact.name}`, { platform: 'claude' }));
     }
     else if (permissions !== undefined) {
-        diagnostics.push(diagnostic('info', 'CLAUDE_SKILL_PERMISSIONS_IGNORED', `Claude skill permissions are not emitted for ${skill.name}`, { platform: 'claude' }));
+        diagnostics.push(diagnostic('info', 'CLAUDE_SKILL_PERMISSIONS_IGNORED', `Claude skill permissions are not emitted for ${artifact.name}`, { platform: 'claude' }));
     }
-    if (skill.claude?.model)
-        diagnostics.push(diagnostic('info', 'CLAUDE_SKILL_MODEL_IGNORED', `Claude skill model is not emitted for ${skill.name}`, { platform: 'claude' }));
-    return { content: `${stringifyYaml(fm)}${skill.instructions}\n`, diagnostics };
+    if (artifact.claude?.model)
+        diagnostics.push(diagnostic('info', 'CLAUDE_SKILL_MODEL_IGNORED', `Claude skill model is not emitted for ${artifact.name}`, { platform: 'claude' }));
+    return { content: `${stringifyYaml(fm)}${artifact.body}\n`, diagnostics };
 }

package/dist/src/adapters/codex.js

@@ -2,28 +2,28 @@ import { stringifyYaml } from '../frontmatter.js';
 import { diagnostic } from '../diagnostics.js';
 import { isRecord, tomlString } from './shared.js';
 const safeSandboxModes = new Set(['read-only', 'workspace-write']);
-export function renderCodexAgent(agent) {
-    const diagnostics = [diagnostic('info', 'CODEX_PARTIAL_AGENT_SUPPORT', `Codex agent output is partial and does not generate AGENTS.md or profiles for ${agent.name}`, { platform: 'codex' })];
-    const lines = [`name = ${tomlString(agent.name)}`, `description = ${tomlString(agent.description)}`, `developer_instructions = ${tomlString(agent.definition)}`];
-    if (agent.codex?.model)
-        lines.push(`model = ${tomlString(agent.codex.model)}`);
-    const permissions = agent.codex?.permissions;
+export function renderCodexAgent(artifact) {
+    const diagnostics = [diagnostic('info', 'CODEX_PARTIAL_AGENT_SUPPORT', `Codex agent output is partial and does not generate AGENTS.md or profiles for ${artifact.name}`, { platform: 'codex' })];
+    const lines = [`name = ${tomlString(artifact.name)}`, `description = ${tomlString(artifact.description)}`, `developer_instructions = ${tomlString(artifact.body)}`];
+    if (artifact.codex?.model)
+        lines.push(`model = ${tomlString(artifact.codex.model)}`);
+    const permissions = artifact.codex?.permissions;
     if (isRecord(permissions) && typeof permissions.sandbox_mode === 'string') {
         if (safeSandboxModes.has(permissions.sandbox_mode))
             lines.push(`sandbox_mode = ${tomlString(permissions.sandbox_mode)}`);
         else
-            diagnostics.push(diagnostic('warning', 'CODEX_UNSAFE_SANDBOX_IGNORED', `Unsafe Codex sandbox_mode ignored for ${agent.name}`, { platform: 'codex' }));
+            diagnostics.push(diagnostic('warning', 'CODEX_UNSAFE_SANDBOX_IGNORED', `Unsafe Codex sandbox_mode ignored for ${artifact.name}`, { platform: 'codex' }));
     }
     else if (permissions !== undefined) {
-        diagnostics.push(diagnostic('info', 'CODEX_AGENT_PERMISSIONS_IGNORED', `Codex agent permissions are not emitted for ${agent.name}`, { platform: 'codex' }));
+        diagnostics.push(diagnostic('info', 'CODEX_AGENT_PERMISSIONS_IGNORED', `Codex agent permissions are not emitted for ${artifact.name}`, { platform: 'codex' }));
     }
     return { content: `${lines.join('\n')}\n`, diagnostics };
 }
-export function renderCodexSkill(skill) {
+export function renderCodexSkill(artifact) {
     const diagnostics = [];
-    if (skill.codex?.permissions)
-        diagnostics.push(diagnostic('info', 'CODEX_SKILL_PERMISSIONS_IGNORED', `Codex skill permissions are not emitted for ${skill.name}`, { platform: 'codex' }));
-    if (skill.codex?.model)
-        diagnostics.push(diagnostic('info', 'CODEX_SKILL_MODEL_IGNORED', `Codex skill model is not emitted for ${skill.name}`, { platform: 'codex' }));
-    return { content: `${stringifyYaml({ name: skill.name, description: skill.description })}${skill.instructions}\n`, diagnostics };
+    if (artifact.codex?.permissions)
+        diagnostics.push(diagnostic('info', 'CODEX_SKILL_PERMISSIONS_IGNORED', `Codex skill permissions are not emitted for ${artifact.name}`, { platform: 'codex' }));
+    if (artifact.codex?.model)
+        diagnostics.push(diagnostic('info', 'CODEX_SKILL_MODEL_IGNORED', `Codex skill model is not emitted for ${artifact.name}`, { platform: 'codex' }));
+    return { content: `${stringifyYaml({ name: artifact.name, description: artifact.description })}${artifact.body}\n`, diagnostics };
 }

package/dist/src/adapters/opencode.js

@@ -1,20 +1,20 @@
 import { stringifyYaml } from '../frontmatter.js';
 import { diagnostic } from '../diagnostics.js';
-export function renderOpenCodeAgent(agent) {
-    const fm = { description: agent.description };
-    if (agent.opencode?.mode)
-        fm.mode = agent.opencode.mode;
-    if (agent.opencode?.model)
-        fm.model = agent.opencode.model;
-    if (agent.opencode?.permissions)
-        fm.permission = agent.opencode.permissions;
-    return { content: `${stringifyYaml(fm)}${agent.definition}\n`, diagnostics: [] };
+export function renderOpenCodeAgent(artifact) {
+    const fm = { description: artifact.description };
+    if (artifact.opencode?.mode)
+        fm.mode = artifact.opencode.mode;
+    if (artifact.opencode?.model)
+        fm.model = artifact.opencode.model;
+    if (artifact.opencode?.permissions)
+        fm.permission = artifact.opencode.permissions;
+    return { content: `${stringifyYaml(fm)}${artifact.body}\n`, diagnostics: [] };
 }
-export function renderOpenCodeSkill(skill) {
+export function renderOpenCodeSkill(artifact) {
     const diagnostics = [];
-    if (skill.opencode?.permissions)
-        diagnostics.push(diagnostic('info', 'OPENCODE_SKILL_PERMISSIONS_IGNORED', `OpenCode skill permissions are not emitted for ${skill.name}`, { platform: 'opencode' }));
-    if (skill.opencode?.model)
-        diagnostics.push(diagnostic('info', 'OPENCODE_SKILL_MODEL_IGNORED', `OpenCode skill model is not emitted for ${skill.name}`, { platform: 'opencode' }));
-    return { content: `${stringifyYaml({ name: skill.name, description: skill.description })}${skill.instructions}\n`, diagnostics };
+    if (artifact.opencode?.permissions)
+        diagnostics.push(diagnostic('info', 'OPENCODE_SKILL_PERMISSIONS_IGNORED', `OpenCode skill permissions are not emitted for ${artifact.name}`, { platform: 'opencode' }));
+    if (artifact.opencode?.model)
+        diagnostics.push(diagnostic('info', 'OPENCODE_SKILL_MODEL_IGNORED', `OpenCode skill model is not emitted for ${artifact.name}`, { platform: 'opencode' }));
+    return { content: `${stringifyYaml({ name: artifact.name, description: artifact.description })}${artifact.body}\n`, diagnostics };
 }

package/dist/src/adapters/shared.js

@@ -1,8 +1,13 @@
 export function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
+const toolNamePattern = /^[A-Za-z0-9_*-]+$/;
+const patternBodyPattern = /^[^,\n]+$/;
 export function stringList(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === 'string' && /^[A-Za-z0-9_*.,:-]+$/.test(item)) ? value : undefined;
+    return Array.isArray(value) && value.every((item) => typeof item === 'string' && toolNamePattern.test(item)) ? value : undefined;
+}
+export function patternList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string' && item.length > 0 && patternBodyPattern.test(item)) ? value : undefined;
 }
 export function tomlString(value) {
     return JSON.stringify(value);