special-agents 0.3.6 → 0.3.7

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!) The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -2,7 +2,7 @@
 
 29 composable best-practice rule packs, 6 skills, and 4 agent roles for Claude Code and Codex.
 
-The content layer of [Rafi](https://github.com/ttante/foreman). Ships both the authoring source (`content/`) and prebuilt composition logic so it can be used as a library, consumed by `rafi compile`, or extended directly.
+The content layer of [Rafi](https://github.com/ttante/rafi). Ships both the authoring source (`content/`) and prebuilt composition logic so it can be used as a library, consumed by `rafi compile`, or extended directly.
 
 ## Install
 

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "special-agents",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "Rafi library: composable best-practice rules, skills, and agents for Claude Code and Codex.",
+  "license": "Apache-2.0",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ttante/rafi.git",
+    "directory": "packages/special-agents"
+  },
+  "bugs": {
+    "url": "https://github.com/ttante/rafi/issues"
+  },
+  "homepage": "https://github.com/ttante/rafi/tree/main/packages/special-agents#readme",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -14,27 +24,25 @@
   "files": [
     "dist",
     "content",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts"
+  },
   "engines": {
     "node": ">=20"
   },
-  "bundledDependencies": [
-    "rafi-spec"
-  ],
   "dependencies": {
+    "rafi-spec": "0.3.7",
     "ajv": "^8.20.0",
-    "yaml": "^2.5.1",
-    "rafi-spec": "0.0.0"
+    "yaml": "^2.5.1"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
-    "test": "tsx --test test/*.test.ts"
   }
-}
+}

package/node_modules/rafi-spec/dist/index.d.ts

@@ -1,4 +0,0 @@
-/** Rafi neutral schema — public surface. */
-export * from "./types.js";
-export { rulePackSchema, skillManifestSchema, agentManifestSchema, projectConfigSchema, } from "./schemas.js";
-export { type ValidationResult, validateRulePack, validateSkillManifest, validateAgentManifest, validateProjectConfig, assertRulePack, assertSkillManifest, assertAgentManifest, assertProjectConfig, } from "./validate.js";

package/node_modules/rafi-spec/dist/index.js

@@ -1,4 +0,0 @@
-/** Rafi neutral schema — public surface. */
-export * from "./types.js";
-export { rulePackSchema, skillManifestSchema, agentManifestSchema, projectConfigSchema, } from "./schemas.js";
-export { validateRulePack, validateSkillManifest, validateAgentManifest, validateProjectConfig, assertRulePack, assertSkillManifest, assertAgentManifest, assertProjectConfig, } from "./validate.js";

package/node_modules/rafi-spec/dist/schemas.d.ts

@@ -1,245 +0,0 @@
-/**
- * JSON Schemas (draft-07) for the neutral types in {@link ./types}. Kept in lockstep
- * with those interfaces; validated by {@link ./validate}.
- */
-export declare const rulePackSchema: {
-    readonly $id: "rafi/rulePack";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["name", "category", "description", "condition", "template"];
-    readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$";
-        };
-        readonly category: {
-            readonly enum: readonly ["base", "process", "domain", "templated"];
-        };
-        readonly description: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly condition: {
-            readonly enum: readonly ["always", "frontend", "ai", "cloud", "backend"];
-        };
-        readonly template: {
-            readonly type: "boolean";
-        };
-        readonly supersededByForeman: {
-            readonly type: "boolean";
-        };
-        readonly body: {
-            readonly type: "string";
-        };
-    };
-};
-export declare const skillManifestSchema: {
-    readonly $id: "rafi/skillManifest";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["name", "description"];
-    readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$";
-        };
-        readonly description: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly pins: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-        };
-        readonly codexPriority: {
-            readonly enum: readonly ["inline", "reference"];
-        };
-        readonly body: {
-            readonly type: "string";
-        };
-    };
-};
-export declare const agentManifestSchema: {
-    readonly $id: "rafi/agentManifest";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["name", "description", "role", "packs", "skills"];
-    readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$";
-        };
-        readonly description: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly role: {
-            readonly enum: readonly ["builder", "qa", "planner", "ticket-maker"];
-        };
-        readonly packs: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-        };
-        readonly skills: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-        };
-        readonly conditionalPacks: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly ai: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-                readonly frontend: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-                readonly cloud: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-                readonly backend: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-            };
-        };
-        readonly model: {
-            readonly type: readonly ["string", "null"];
-        };
-        readonly effort: {
-            readonly type: readonly ["string", "null"];
-            readonly enum: readonly ["low", "medium", "high", "xhigh", null];
-        };
-    };
-};
-export declare const projectConfigSchema: {
-    readonly $id: "rafi/projectConfig";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["appName", "timezone", "stack", "flags", "harness", "agent_files", "agents", "skills"];
-    readonly properties: {
-        readonly appName: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly timezone: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly stack: {
-            type: string;
-            additionalProperties: boolean;
-            required: string[];
-            properties: {
-                [k: string]: {
-                    type: string;
-                    minLength: number;
-                };
-            };
-        };
-        readonly flags: {
-            type: string;
-            additionalProperties: boolean;
-            required: string[];
-            properties: {
-                [k: string]: {
-                    type: string;
-                };
-            };
-        };
-        readonly harness: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["targets", "qa"];
-            readonly properties: {
-                readonly targets: {
-                    readonly type: "array";
-                    readonly minItems: 1;
-                    readonly items: {
-                        readonly enum: readonly ["claude", "codex"];
-                    };
-                };
-                readonly qa: {
-                    readonly type: "boolean";
-                };
-            };
-        };
-        readonly agent_files: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["mode", "codex", "claude"];
-            readonly properties: {
-                readonly mode: {
-                    readonly enum: readonly ["append", "update", "overwrite"];
-                };
-                readonly codex: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly claude: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-            };
-        };
-        readonly agents: {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["artifact_source", "claude", "codex"];
-                readonly properties: {
-                    readonly artifact_source: {
-                        readonly enum: readonly ["rafi", "existing"];
-                    };
-                    readonly claude: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly codex: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-            };
-        };
-        readonly skills: {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["artifact_source", "claude", "codex"];
-                readonly properties: {
-                    readonly artifact_source: {
-                        readonly enum: readonly ["rafi", "existing"];
-                    };
-                    readonly claude: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly codex: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-            };
-        };
-    };
-};

package/node_modules/rafi-spec/dist/schemas.js

@@ -1,121 +0,0 @@
-/**
- * JSON Schemas (draft-07) for the neutral types in {@link ./types}. Kept in lockstep
- * with those interfaces; validated by {@link ./validate}.
- */
-const KEBAB = "^[a-z0-9]+(?:-[a-z0-9]+)*$";
-export const rulePackSchema = {
-    $id: "rafi/rulePack",
-    type: "object",
-    additionalProperties: false,
-    required: ["name", "category", "description", "condition", "template"],
-    properties: {
-        name: { type: "string", pattern: KEBAB },
-        category: { enum: ["base", "process", "domain", "templated"] },
-        description: { type: "string", minLength: 1 },
-        condition: { enum: ["always", "frontend", "ai", "cloud", "backend"] },
-        template: { type: "boolean" },
-        supersededByForeman: { type: "boolean" },
-        body: { type: "string" },
-    },
-};
-export const skillManifestSchema = {
-    $id: "rafi/skillManifest",
-    type: "object",
-    additionalProperties: false,
-    required: ["name", "description"],
-    properties: {
-        name: { type: "string", pattern: KEBAB },
-        description: { type: "string", minLength: 1 },
-        pins: { type: "array", items: { type: "string" } },
-        codexPriority: { enum: ["inline", "reference"] },
-        body: { type: "string" },
-    },
-};
-export const agentManifestSchema = {
-    $id: "rafi/agentManifest",
-    type: "object",
-    additionalProperties: false,
-    required: ["name", "description", "role", "packs", "skills"],
-    properties: {
-        name: { type: "string", pattern: KEBAB },
-        description: { type: "string", minLength: 1 },
-        role: { enum: ["builder", "qa", "planner", "ticket-maker"] },
-        packs: { type: "array", items: { type: "string" } },
-        skills: { type: "array", items: { type: "string" } },
-        conditionalPacks: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                ai: { type: "array", items: { type: "string" } },
-                frontend: { type: "array", items: { type: "string" } },
-                cloud: { type: "array", items: { type: "string" } },
-                backend: { type: "array", items: { type: "string" } },
-            },
-        },
-        model: { type: ["string", "null"] },
-        effort: { type: ["string", "null"], enum: ["low", "medium", "high", "xhigh", null] },
-    },
-};
-const stringRecord = (keys) => ({
-    type: "object",
-    additionalProperties: false,
-    required: keys,
-    properties: Object.fromEntries(keys.map((k) => [k, { type: "string", minLength: 1 }])),
-});
-const boolRecord = (keys) => ({
-    type: "object",
-    additionalProperties: false,
-    required: keys,
-    properties: Object.fromEntries(keys.map((k) => [k, { type: "boolean" }])),
-});
-const runtimeArtifactPaths = {
-    type: "object",
-    additionalProperties: false,
-    required: ["artifact_source", "claude", "codex"],
-    properties: {
-        artifact_source: { enum: ["rafi", "existing"] },
-        claude: { type: "string", minLength: 1 },
-        codex: { type: "string", minLength: 1 },
-    },
-};
-const artifactPathMap = {
-    type: "object",
-    additionalProperties: runtimeArtifactPaths,
-};
-export const projectConfigSchema = {
-    $id: "rafi/projectConfig",
-    type: "object",
-    additionalProperties: false,
-    required: ["appName", "timezone", "stack", "flags", "harness", "agent_files", "agents", "skills"],
-    properties: {
-        appName: { type: "string", minLength: 1 },
-        timezone: { type: "string", minLength: 1 },
-        stack: stringRecord(["frontend", "backend", "database", "cloud", "packageManager"]),
-        flags: boolRecord(["hasFrontend", "usesAI", "runsInCloud"]),
-        harness: {
-            type: "object",
-            additionalProperties: false,
-            required: ["targets", "qa"],
-            properties: {
-                targets: {
-                    type: "array",
-                    minItems: 1,
-                    items: { enum: ["claude", "codex"] },
-                },
-                qa: { type: "boolean" },
-            },
-        },
-        agent_files: {
-            type: "object",
-            additionalProperties: false,
-            required: ["mode", "codex", "claude"],
-            properties: {
-                mode: { enum: ["append", "update", "overwrite"] },
-                codex: { type: "string", minLength: 1 },
-                claude: { type: "string", minLength: 1 },
-            },
-        },
-        agents: artifactPathMap,
-        skills: artifactPathMap,
-    },
-};

package/node_modules/rafi-spec/dist/types.d.ts

@@ -1,129 +0,0 @@
-/**
- * Rafi neutral schema — the shapes that the `special-agents` library and the
- * `ai-foreman` runtime must agree on. Authoring inputs (rule packs, skills,
- * agent manifests) and the per-project configuration that drives composition.
- */
-/** Which category a rule pack belongs to (drives default load behavior). */
-export type PackCategory = "base" | "process" | "domain" | "templated";
-/**
- * When a pack applies. `always` packs load for every project; the others load
- * only when the matching project flag is on (see {@link ProjectFlags}).
- */
-export type PackCondition = "always" | "frontend" | "ai" | "cloud" | "backend";
-/** The YAML front-matter carried by each rule pack markdown file. */
-export interface RulePackFrontmatter {
-    /** Unique, kebab-case identifier (e.g. `security`). */
-    name: string;
-    category: PackCategory;
-    /** One-line summary used in indexes and pack pickers. */
-    description: string;
-    condition: PackCondition;
-    /** True when the body contains `{{placeholders}}` / `{{#if}}` directives. */
-    template: boolean;
-    /** When true, the pack is omitted while the foreman ticket tracker is active. */
-    supersededByForeman?: boolean;
-}
-/** A fully loaded rule pack: its front-matter plus the markdown body. */
-export interface RulePack extends RulePackFrontmatter {
-    /** The rule text (bullets) below the front-matter. */
-    body: string;
-}
-/** How a skill should be treated when flattening for Codex (which can't lazy-load). */
-export type CodexPriority = "inline" | "reference";
-/**
- * A skill manifest. Keeps the existing Anthropic `SKILL.md` format and adds two
- * optional composition fields that non-Rafi tools can safely ignore.
- */
-export interface SkillManifest {
-    /** Unique, kebab-case identifier matching the skill directory name. */
-    name: string;
-    /** One-line trigger description (the cheap progressive-disclosure index). */
-    description: string;
-    /** Rule packs this skill wants loaded alongside it. */
-    pins?: string[];
-    /** Whether Codex flattening should inline this skill's body or just reference it. */
-    codexPriority?: CodexPriority;
-    /** The skill body (instructions). Optional in metadata-only contexts. */
-    body?: string;
-}
-/** The role an agent fills, mapped to an ai-foreman turn-type or command. */
-export type AgentRole = "builder" | "qa" | "planner" | "ticket-maker";
-/** Reasoning effort levels accepted by the builders. */
-export type EffortLevel = "low" | "medium" | "high" | "xhigh";
-/** Packs added to a role only when the matching project flag is on. */
-export interface ConditionalPacks {
-    ai?: string[];
-    frontend?: string[];
-    cloud?: string[];
-    backend?: string[];
-}
-/**
- * A role manifest: a named composition of rule packs + skills that the runtime
- * loads for a given turn-type.
- */
-export interface AgentManifest {
-    /** Unique, kebab-case identifier (usually equals {@link role}). */
-    name: string;
-    description: string;
-    role: AgentRole;
-    /** Pack references; globs like `base/*` are allowed and expanded at compile time. */
-    packs: string[];
-    /** Skill names this role preloads. */
-    skills: string[];
-    /** Extra packs gated on project flags. */
-    conditionalPacks?: ConditionalPacks;
-    /** Model override; null inherits the runtime's `--model`. */
-    model?: string | null;
-    /** Effort override; null inherits the runtime's `--effort`. */
-    effort?: EffortLevel | null;
-}
-/** Which harness targets to emit native config for. */
-export type HarnessTarget = "claude" | "codex";
-/** The stack choices collected by `rafi create` (free-text strings). */
-export interface ProjectStack {
-    frontend: string;
-    backend: string;
-    database: string;
-    cloud: string;
-    packageManager: string;
-}
-/** Boolean flags that gate conditional packs and docs. */
-export interface ProjectFlags {
-    hasFrontend: boolean;
-    usesAI: boolean;
-    runsInCloud: boolean;
-}
-/** Harness emission + QA preferences. */
-export interface HarnessConfig {
-    targets: HarnessTarget[];
-    qa: boolean;
-}
-/** How Rafi should handle existing root instruction files. */
-export type AgentFileMode = "append" | "update" | "overwrite";
-/** Root instruction files used by Codex and Claude. */
-export interface AgentFilesConfig {
-    mode: AgentFileMode;
-    codex: string;
-    claude: string;
-}
-/** Per-runtime paths for a skill or agent artifact. */
-export type ArtifactSource = "rafi" | "existing";
-export interface RuntimeArtifactConfig {
-    artifact_source: ArtifactSource;
-    claude: string;
-    codex: string;
-}
-/**
- * The committed `rafi-config.yaml` in a target repo. Skipping the walkthrough uses
- * the library defaults, which reproduce today's hardcoded guidance.
- */
-export interface ProjectConfig {
-    appName: string;
-    timezone: string;
-    stack: ProjectStack;
-    flags: ProjectFlags;
-    harness: HarnessConfig;
-    agent_files: AgentFilesConfig;
-    agents: Record<string, RuntimeArtifactConfig>;
-    skills: Record<string, RuntimeArtifactConfig>;
-}

package/node_modules/rafi-spec/dist/types.js

@@ -1,6 +0,0 @@
-/**
- * Rafi neutral schema — the shapes that the `special-agents` library and the
- * `ai-foreman` runtime must agree on. Authoring inputs (rule packs, skills,
- * agent manifests) and the per-project configuration that drives composition.
- */
-export {};

package/node_modules/rafi-spec/dist/validate.d.ts

@@ -1,16 +0,0 @@
-import type { RulePackFrontmatter, SkillManifest, AgentManifest, ProjectConfig } from "./types.js";
-/** Outcome of validating a value against one of the neutral schemas. */
-export interface ValidationResult {
-    valid: boolean;
-    /** Human-readable messages; empty when valid. */
-    errors: string[];
-}
-export declare const validateRulePack: (d: unknown) => ValidationResult;
-export declare const validateSkillManifest: (d: unknown) => ValidationResult;
-export declare const validateAgentManifest: (d: unknown) => ValidationResult;
-export declare const validateProjectConfig: (d: unknown) => ValidationResult;
-/** Validate and narrow, throwing on failure. */
-export declare function assertRulePack(d: unknown): asserts d is RulePackFrontmatter;
-export declare function assertSkillManifest(d: unknown): asserts d is SkillManifest;
-export declare function assertAgentManifest(d: unknown): asserts d is AgentManifest;
-export declare function assertProjectConfig(d: unknown): asserts d is ProjectConfig;

package/node_modules/rafi-spec/dist/validate.js

@@ -1,40 +0,0 @@
-/** ajv-backed validation for the neutral schemas. */
-import { Ajv } from "ajv";
-import { rulePackSchema, skillManifestSchema, agentManifestSchema, projectConfigSchema, } from "./schemas.js";
-const ajv = new Ajv({ allErrors: true, allowUnionTypes: true });
-function run(fn, data) {
-    const valid = fn(data);
-    if (valid)
-        return { valid: true, errors: [] };
-    const errors = (fn.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message ?? "is invalid"}`.trim());
-    return { valid: false, errors };
-}
-const vRulePack = ajv.compile(rulePackSchema);
-const vSkill = ajv.compile(skillManifestSchema);
-const vAgent = ajv.compile(agentManifestSchema);
-const vProject = ajv.compile(projectConfigSchema);
-export const validateRulePack = (d) => run(vRulePack, d);
-export const validateSkillManifest = (d) => run(vSkill, d);
-export const validateAgentManifest = (d) => run(vAgent, d);
-export const validateProjectConfig = (d) => run(vProject, d);
-/** Validate and narrow, throwing on failure. */
-export function assertRulePack(d) {
-    const r = validateRulePack(d);
-    if (!r.valid)
-        throw new Error(`Invalid rule pack: ${r.errors.join("; ")}`);
-}
-export function assertSkillManifest(d) {
-    const r = validateSkillManifest(d);
-    if (!r.valid)
-        throw new Error(`Invalid skill manifest: ${r.errors.join("; ")}`);
-}
-export function assertAgentManifest(d) {
-    const r = validateAgentManifest(d);
-    if (!r.valid)
-        throw new Error(`Invalid agent manifest: ${r.errors.join("; ")}`);
-}
-export function assertProjectConfig(d) {
-    const r = validateProjectConfig(d);
-    if (!r.valid)
-        throw new Error(`Invalid project config: ${r.errors.join("; ")}`);
-}

package/node_modules/rafi-spec/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "rafi-spec",
-  "version": "0.0.0",
-  "private": true,
-  "description": "Rafi neutral schema: rule packs, skills, agents, and project config shapes shared by special-agents and ai-foreman.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
-    "test": "tsx --test test/*.test.ts"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "ajv": "^8.20.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.14.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.6.0"
-  }
-}

package/node_modules/rafi-spec/src/index.ts

@@ -1,19 +0,0 @@
-/** Rafi neutral schema — public surface. */
-export * from "./types.js";
-export {
-  rulePackSchema,
-  skillManifestSchema,
-  agentManifestSchema,
-  projectConfigSchema,
-} from "./schemas.js";
-export {
-  type ValidationResult,
-  validateRulePack,
-  validateSkillManifest,
-  validateAgentManifest,
-  validateProjectConfig,
-  assertRulePack,
-  assertSkillManifest,
-  assertAgentManifest,
-  assertProjectConfig,
-} from "./validate.js";

package/node_modules/rafi-spec/src/schemas.ts

@@ -1,130 +0,0 @@
-/**
- * JSON Schemas (draft-07) for the neutral types in {@link ./types}. Kept in lockstep
- * with those interfaces; validated by {@link ./validate}.
- */
-
-const KEBAB = "^[a-z0-9]+(?:-[a-z0-9]+)*$";
-
-export const rulePackSchema = {
-  $id: "rafi/rulePack",
-  type: "object",
-  additionalProperties: false,
-  required: ["name", "category", "description", "condition", "template"],
-  properties: {
-    name: { type: "string", pattern: KEBAB },
-    category: { enum: ["base", "process", "domain", "templated"] },
-    description: { type: "string", minLength: 1 },
-    condition: { enum: ["always", "frontend", "ai", "cloud", "backend"] },
-    template: { type: "boolean" },
-    supersededByForeman: { type: "boolean" },
-    body: { type: "string" },
-  },
-} as const;
-
-export const skillManifestSchema = {
-  $id: "rafi/skillManifest",
-  type: "object",
-  additionalProperties: false,
-  required: ["name", "description"],
-  properties: {
-    name: { type: "string", pattern: KEBAB },
-    description: { type: "string", minLength: 1 },
-    pins: { type: "array", items: { type: "string" } },
-    codexPriority: { enum: ["inline", "reference"] },
-    body: { type: "string" },
-  },
-} as const;
-
-export const agentManifestSchema = {
-  $id: "rafi/agentManifest",
-  type: "object",
-  additionalProperties: false,
-  required: ["name", "description", "role", "packs", "skills"],
-  properties: {
-    name: { type: "string", pattern: KEBAB },
-    description: { type: "string", minLength: 1 },
-    role: { enum: ["builder", "qa", "planner", "ticket-maker"] },
-    packs: { type: "array", items: { type: "string" } },
-    skills: { type: "array", items: { type: "string" } },
-    conditionalPacks: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        ai: { type: "array", items: { type: "string" } },
-        frontend: { type: "array", items: { type: "string" } },
-        cloud: { type: "array", items: { type: "string" } },
-        backend: { type: "array", items: { type: "string" } },
-      },
-    },
-    model: { type: ["string", "null"] },
-    effort: { type: ["string", "null"], enum: ["low", "medium", "high", "xhigh", null] },
-  },
-} as const;
-
-const stringRecord = (keys: string[]) => ({
-  type: "object",
-  additionalProperties: false,
-  required: keys,
-  properties: Object.fromEntries(keys.map((k) => [k, { type: "string", minLength: 1 }])),
-});
-
-const boolRecord = (keys: string[]) => ({
-  type: "object",
-  additionalProperties: false,
-  required: keys,
-  properties: Object.fromEntries(keys.map((k) => [k, { type: "boolean" }])),
-});
-
-const runtimeArtifactPaths = {
-  type: "object",
-  additionalProperties: false,
-  required: ["artifact_source", "claude", "codex"],
-  properties: {
-    artifact_source: { enum: ["rafi", "existing"] },
-    claude: { type: "string", minLength: 1 },
-    codex: { type: "string", minLength: 1 },
-  },
-} as const;
-
-const artifactPathMap = {
-  type: "object",
-  additionalProperties: runtimeArtifactPaths,
-} as const;
-
-export const projectConfigSchema = {
-  $id: "rafi/projectConfig",
-  type: "object",
-  additionalProperties: false,
-  required: ["appName", "timezone", "stack", "flags", "harness", "agent_files", "agents", "skills"],
-  properties: {
-    appName: { type: "string", minLength: 1 },
-    timezone: { type: "string", minLength: 1 },
-    stack: stringRecord(["frontend", "backend", "database", "cloud", "packageManager"]),
-    flags: boolRecord(["hasFrontend", "usesAI", "runsInCloud"]),
-    harness: {
-      type: "object",
-      additionalProperties: false,
-      required: ["targets", "qa"],
-      properties: {
-        targets: {
-          type: "array",
-          minItems: 1,
-          items: { enum: ["claude", "codex"] },
-        },
-        qa: { type: "boolean" },
-      },
-    },
-    agent_files: {
-      type: "object",
-      additionalProperties: false,
-      required: ["mode", "codex", "claude"],
-      properties: {
-        mode: { enum: ["append", "update", "overwrite"] },
-        codex: { type: "string", minLength: 1 },
-        claude: { type: "string", minLength: 1 },
-      },
-    },
-    agents: artifactPathMap,
-    skills: artifactPathMap,
-  },
-} as const;

package/node_modules/rafi-spec/src/types.ts

@@ -1,156 +0,0 @@
-/**
- * Rafi neutral schema — the shapes that the `special-agents` library and the
- * `ai-foreman` runtime must agree on. Authoring inputs (rule packs, skills,
- * agent manifests) and the per-project configuration that drives composition.
- */
-
-// ───────────────────────────── Rule packs ─────────────────────────────
-
-/** Which category a rule pack belongs to (drives default load behavior). */
-export type PackCategory = "base" | "process" | "domain" | "templated";
-
-/**
- * When a pack applies. `always` packs load for every project; the others load
- * only when the matching project flag is on (see {@link ProjectFlags}).
- */
-export type PackCondition = "always" | "frontend" | "ai" | "cloud" | "backend";
-
-/** The YAML front-matter carried by each rule pack markdown file. */
-export interface RulePackFrontmatter {
-  /** Unique, kebab-case identifier (e.g. `security`). */
-  name: string;
-  category: PackCategory;
-  /** One-line summary used in indexes and pack pickers. */
-  description: string;
-  condition: PackCondition;
-  /** True when the body contains `{{placeholders}}` / `{{#if}}` directives. */
-  template: boolean;
-  /** When true, the pack is omitted while the foreman ticket tracker is active. */
-  supersededByForeman?: boolean;
-}
-
-/** A fully loaded rule pack: its front-matter plus the markdown body. */
-export interface RulePack extends RulePackFrontmatter {
-  /** The rule text (bullets) below the front-matter. */
-  body: string;
-}
-
-// ───────────────────────────── Skills ─────────────────────────────
-
-/** How a skill should be treated when flattening for Codex (which can't lazy-load). */
-export type CodexPriority = "inline" | "reference";
-
-/**
- * A skill manifest. Keeps the existing Anthropic `SKILL.md` format and adds two
- * optional composition fields that non-Rafi tools can safely ignore.
- */
-export interface SkillManifest {
-  /** Unique, kebab-case identifier matching the skill directory name. */
-  name: string;
-  /** One-line trigger description (the cheap progressive-disclosure index). */
-  description: string;
-  /** Rule packs this skill wants loaded alongside it. */
-  pins?: string[];
-  /** Whether Codex flattening should inline this skill's body or just reference it. */
-  codexPriority?: CodexPriority;
-  /** The skill body (instructions). Optional in metadata-only contexts. */
-  body?: string;
-}
-
-// ───────────────────────────── Agents (roles) ─────────────────────────────
-
-/** The role an agent fills, mapped to an ai-foreman turn-type or command. */
-export type AgentRole = "builder" | "qa" | "planner" | "ticket-maker";
-
-/** Reasoning effort levels accepted by the builders. */
-export type EffortLevel = "low" | "medium" | "high" | "xhigh";
-
-/** Packs added to a role only when the matching project flag is on. */
-export interface ConditionalPacks {
-  ai?: string[];
-  frontend?: string[];
-  cloud?: string[];
-  backend?: string[];
-}
-
-/**
- * A role manifest: a named composition of rule packs + skills that the runtime
- * loads for a given turn-type.
- */
-export interface AgentManifest {
-  /** Unique, kebab-case identifier (usually equals {@link role}). */
-  name: string;
-  description: string;
-  role: AgentRole;
-  /** Pack references; globs like `base/*` are allowed and expanded at compile time. */
-  packs: string[];
-  /** Skill names this role preloads. */
-  skills: string[];
-  /** Extra packs gated on project flags. */
-  conditionalPacks?: ConditionalPacks;
-  /** Model override; null inherits the runtime's `--model`. */
-  model?: string | null;
-  /** Effort override; null inherits the runtime's `--effort`. */
-  effort?: EffortLevel | null;
-}
-
-// ───────────────────────────── Project config ─────────────────────────────
-
-/** Which harness targets to emit native config for. */
-export type HarnessTarget = "claude" | "codex";
-
-/** The stack choices collected by `rafi create` (free-text strings). */
-export interface ProjectStack {
-  frontend: string;
-  backend: string;
-  database: string;
-  cloud: string;
-  packageManager: string;
-}
-
-/** Boolean flags that gate conditional packs and docs. */
-export interface ProjectFlags {
-  hasFrontend: boolean;
-  usesAI: boolean;
-  runsInCloud: boolean;
-}
-
-/** Harness emission + QA preferences. */
-export interface HarnessConfig {
-  targets: HarnessTarget[];
-  qa: boolean;
-}
-
-/** How Rafi should handle existing root instruction files. */
-export type AgentFileMode = "append" | "update" | "overwrite";
-
-/** Root instruction files used by Codex and Claude. */
-export interface AgentFilesConfig {
-  mode: AgentFileMode;
-  codex: string;
-  claude: string;
-}
-
-/** Per-runtime paths for a skill or agent artifact. */
-export type ArtifactSource = "rafi" | "existing";
-
-export interface RuntimeArtifactConfig {
-  artifact_source: ArtifactSource;
-  claude: string;
-  codex: string;
-}
-
-/**
- * The committed `rafi-config.yaml` in a target repo. Skipping the walkthrough uses
- * the library defaults, which reproduce today's hardcoded guidance.
- */
-export interface ProjectConfig {
-  appName: string;
-  timezone: string;
-  stack: ProjectStack;
-  flags: ProjectFlags;
-  harness: HarnessConfig;
-  agent_files: AgentFilesConfig;
-  agents: Record<string, RuntimeArtifactConfig>;
-  skills: Record<string, RuntimeArtifactConfig>;
-}

package/node_modules/rafi-spec/src/validate.ts

@@ -1,60 +0,0 @@
-/** ajv-backed validation for the neutral schemas. */
-import { Ajv, type ValidateFunction } from "ajv";
-import {
-  rulePackSchema,
-  skillManifestSchema,
-  agentManifestSchema,
-  projectConfigSchema,
-} from "./schemas.js";
-import type {
-  RulePackFrontmatter,
-  SkillManifest,
-  AgentManifest,
-  ProjectConfig,
-} from "./types.js";
-
-const ajv = new Ajv({ allErrors: true, allowUnionTypes: true });
-
-/** Outcome of validating a value against one of the neutral schemas. */
-export interface ValidationResult {
-  valid: boolean;
-  /** Human-readable messages; empty when valid. */
-  errors: string[];
-}
-
-function run(fn: ValidateFunction, data: unknown): ValidationResult {
-  const valid = fn(data) as boolean;
-  if (valid) return { valid: true, errors: [] };
-  const errors = (fn.errors ?? []).map(
-    (e) => `${e.instancePath || "(root)"} ${e.message ?? "is invalid"}`.trim(),
-  );
-  return { valid: false, errors };
-}
-
-const vRulePack = ajv.compile(rulePackSchema);
-const vSkill = ajv.compile(skillManifestSchema);
-const vAgent = ajv.compile(agentManifestSchema);
-const vProject = ajv.compile(projectConfigSchema);
-
-export const validateRulePack = (d: unknown): ValidationResult => run(vRulePack, d);
-export const validateSkillManifest = (d: unknown): ValidationResult => run(vSkill, d);
-export const validateAgentManifest = (d: unknown): ValidationResult => run(vAgent, d);
-export const validateProjectConfig = (d: unknown): ValidationResult => run(vProject, d);
-
-/** Validate and narrow, throwing on failure. */
-export function assertRulePack(d: unknown): asserts d is RulePackFrontmatter {
-  const r = validateRulePack(d);
-  if (!r.valid) throw new Error(`Invalid rule pack: ${r.errors.join("; ")}`);
-}
-export function assertSkillManifest(d: unknown): asserts d is SkillManifest {
-  const r = validateSkillManifest(d);
-  if (!r.valid) throw new Error(`Invalid skill manifest: ${r.errors.join("; ")}`);
-}
-export function assertAgentManifest(d: unknown): asserts d is AgentManifest {
-  const r = validateAgentManifest(d);
-  if (!r.valid) throw new Error(`Invalid agent manifest: ${r.errors.join("; ")}`);
-}
-export function assertProjectConfig(d: unknown): asserts d is ProjectConfig {
-  const r = validateProjectConfig(d);
-  if (!r.valid) throw new Error(`Invalid project config: ${r.errors.join("; ")}`);
-}