@really-knows-ai/foundry 3.5.6 → 3.5.8

package/dist/.opencode/plugins/foundry.js

@@ -36,7 +36,7 @@ import { createMemoryAdminTools } from './foundry-tools/memory-admin-tools.js';
 import { createSnapshotTools } from './foundry-tools/snapshot-tools.js';
 import { createAttestationTools } from './foundry-tools/attestation-tools.js';
 import { createRefreshAgentsTool } from './foundry-tools/refresh-agents-tool.js';
-import { resolveGit } from '../../scripts/lib/tool-paths.js';
+import { resolveGit, resolvePnpm } from '../../scripts/lib/tool-paths.js';
 
 function findPackageRoot(startDir) {
   let dir = startDir;
@@ -103,7 +103,17 @@ function initGitRepo(worktree) {
   }
 }
 
+function ensurePackageJson(worktree) {
+  if (existsSync(path.join(worktree, 'package.json'))) return;
+  try {
+    execFileSync(resolvePnpm(), ['init'], { cwd: worktree, stdio: 'pipe' });
+  } catch (err) {
+    console.error('Foundry pnpm init error:', err.message);
+  }
+}
+
 function runBootstrapSequence(worktree, pkgRoot) {
+  ensurePackageJson(worktree);
   bootstrapDirectories(worktree);
   bootstrapGitignore(worktree);
   refreshAgents(worktree);

package/dist/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [3.5.8] - 2026-05-23
+
+### Added
+
+- Foundry bootstrap runs `pnpm init` on the project workspace when no `package.json` exists, so validators can install dependencies immediately.
+
+### Changed
+
+- Validator guidance in the add-law skill hardened from "prefer libraries" to "hand-rolled heuristics are a last resort."
+
+## [3.5.7] - 2026-05-23
+
+### Added
+
+- Artefact types can include an `example.md` alongside `definition.md`. When present, the forge skill treats its structure as normative — the forge agent follows the same format, preventing common formatting mistakes like unwanted title headings on haikus.
+
 ## [3.5.6] - 2026-05-23
 
 ### Fixed

package/dist/scripts/lib/config.js

@@ -22,12 +22,20 @@ export async function getCycleDefinition(foundryDir, cycleId, io) {
 }
 
 export async function getArtefactType(foundryDir, typeId, io) {
-  const path = join(foundryDir, 'artefacts', typeId, 'definition.md');
-  if (!(await io.exists(path))) {
+  const dir = join(foundryDir, 'artefacts', typeId);
+  const defPath = join(dir, 'definition.md');
+  if (!(await io.exists(defPath))) {
     throw new Error(`Artefact type not found: ${typeId}`);
   }
-  const text = await io.readFile(path);
-  return parseDoc(text);
+  const text = await io.readFile(defPath);
+  const result = parseDoc(text);
+
+  const examplePath = join(dir, 'example.md');
+  if (await io.exists(examplePath)) {
+    result.example = (await io.readFile(examplePath)).trim();
+  }
+
+  return result;
 }
 
 /**

package/dist/scripts/lib/tool-paths.js

@@ -18,4 +18,8 @@ function resolveOpenCode() {
   return process.env.FOUNDRY_OPENCODE_PATH || resolveFromPath('opencode');
 }
 
-export { resolveGit, resolveOpenCode };
+function resolvePnpm() {
+  return process.env.FOUNDRY_PNPM_PATH || resolveFromPath('pnpm');
+}
+
+export { resolveGit, resolveOpenCode, resolvePnpm };

package/dist/skills/add-law/SKILL.md

@@ -66,7 +66,7 @@ Walk the user through which elements of the law can be validated deterministical
 >
 > Shall I add validators for the script-checkable elements?
 
-For each script-checkable element, write a standalone `.mjs` script next to the artefacts it validates (e.g. `foundry/artefacts/<type>/check-line-count.mjs`) and reference it in the command (e.g. `node foundry/artefacts/<type>/check-line-count.mjs {files}`). Place validators alongside the artefacts so they colocate with what they validate. Prefer Node.js built-ins and libraries already in the project; hand-rolled heuristics are fragile — use available packages instead of writing custom validation logic from scratch.
+For each script-checkable element, write a standalone `.mjs` script next to the artefacts it validates (e.g. `foundry/artefacts/<type>/check-line-count.mjs`) and reference it in the command (e.g. `node foundry/artefacts/<type>/check-line-count.mjs {files}`). Place validators alongside the artefacts so they colocate with what they validate. Use existing project dependencies and Node.js built‑ins. Hand‑rolled heuristics (custom syllable counters, regex parsers, manual character walks) are a last resort — they produce false positives, waste tokens on debugging, and break on edge cases. Install a library instead. Only write validation logic from scratch when no npm package exists for the task and the heuristic is trivially correct.
 
 **Validators**: Ask about `validators` (optional) — offer to create one or skip.
 

package/dist/skills/forge/SKILL.md

@@ -40,7 +40,7 @@ Forge runs inside an enforced stage. Your **first** and **last** tool calls are
 
    Then return control to the user and stop.
 3. `foundry_config_cycle` — understand what to produce and what inputs are available.
-4. `foundry_config_artefact_type` with the output type ID — get the artefact type definition, especially its `file-patterns`.
+4. `foundry_config_artefact_type` with the output type ID — get the artefact type definition, `file-patterns`, and any example. When the response includes an `example` field, its structure is normative — your output must follow the same format (no extra headings, metadata blocks, or free-form prose that the example does not include).
 5. `foundry_config_laws` — get all applicable laws (global + type-specific).
 6. If the cycle declares `inputs`, discover input files by filesystem scan:
    - For each type listed in `inputs`, call `foundry_config_artefact_type` to get its `file-patterns`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@really-knows-ai/foundry",
-  "version": "3.5.6",
+  "version": "3.5.8",
   "description": "A skill-driven framework for governed artefact generation with AI coding tools. Define your own artefact types, laws, and flows — Foundry handles the forge → quench → appraise pipeline with deterministic routing, quality gates, and iterative refinement.",
   "type": "module",
   "main": "dist/.opencode/plugins/foundry.js",