@macedon-technologies/batman 1.24.1 → 1.25.0

package/.jsii

@@ -1283,6 +1283,6 @@
       "symbolId": "src/WorkflowAutoDiscover:WorkflowAutoDiscover"
     }
   },
-  "version": "1.24.1",
-  "fingerprint": "bdThwmtMhTqwV9t5UIGZ/xaWCjgz6ApzLO1QSEnnLIA="
+  "version": "1.25.0",
+  "fingerprint": "PndeNL5NXQb1TkD3BzT8gxANwXiAJBG0k+/ZMUVENRk="
 }

package/architecture-rules/README.md

@@ -9,6 +9,9 @@ needs a genuinely new kind of check.
 
 ## Rule shape
 
+Two `check.type`s are implemented: `forbidden-import` (whole-repo import-graph
+check) and `required-companion` (diff-based co-change check).
+
 ```json
 {
   "id": "unique-id",
@@ -23,6 +26,56 @@ needs a genuinely new kind of check.
 }
 ```
 
+```json
+{
+  "id": "unique-id",
+  "description": "What this enforces and why.",
+  "enabled": true,
+  "severity": "low" | "medium" | "high" | "critical",
+  "check": {
+    "type": "required-companion",
+    "from": ["glob patterns selecting changed files that trigger the requirement"],
+    "requireOneOf": ["glob patterns -- at least one CHANGED file must match one of these"],
+    "exempt": ["optional -- from-files matching these globs don't trigger the requirement"]
+  }
+}
+```
+
+`required-companion` evaluates the set of files changed in the current diff
+(`git diff --name-only --diff-filter=ACMR <baseRef>...HEAD`), not the whole
+repo tree: if any changed file matches `from` (and doesn't match `exempt`) but
+no changed file matches `requireOneOf`, that's a violation. The base ref
+defaults to `origin/main` and can be overridden with the
+`ARCHITECTURE_RULES_BASE_REF` environment variable. This means the checkout
+running `pnpm validate:architecture` must have that base ref fetched and
+resolvable (a shallow, single-branch checkout will make the check fail closed
+with an error rather than silently reporting no violations) — make sure
+whatever runs this task fetches enough history for `git diff <baseRef>...HEAD`
+to succeed.
+
+`from`/`requireOneOf`/`exempt` globs are matched against the paths `git
+diff --name-only` reports, which are relative to the git repository's
+top-level directory. This lines up with `from`'s own directory (the parent of
+`architecture-rules/`) in the common case — a single project generated at the
+repo root — but if `architecture-rules/` instead lives under a nested
+subdirectory of a larger git repo, write globs relative to the git root, not
+to that subdirectory.
+
+**`required-companion` is a coverage check, not a correctness check.** It only
+confirms that *some* changed file matches `requireOneOf` — it can't tell
+whether that change is actually related to the triggering `from` change (a
+trivial or unrelated edit to a file under `requireOneOf` satisfies the rule
+just as well as a substantive one), and it can't tell whether a given `from`
+change genuinely needed a companion at all (a pure refactor might not).
+`exempt` covers *known, glob-expressible* exceptions, but not every false
+positive is expressible as a glob — that judgment call still belongs to the
+rule author (scoping `from`/`exempt`) and the reviewer (reading the companion
+diff, not just trusting that the check passed). Also note that `main()`
+fails the whole run on *any* violation regardless of `severity` — `severity`
+is informational only, not a leniency lever — so start with a narrowly
+scoped `from` (or `enabled: false`) and widen it as the convention proves
+itself, the same guidance as for `forbidden-import`.
+
 `enabled: false` rules are skipped (reported as "deferred") rather than
 evaluated — use this for a rule you've named and described but don't yet
 have a concrete convention to check.
@@ -35,8 +88,10 @@ conventions solidify (e.g. an event-sourced/CQRS module layout under
 
 ## Adding a check type
 
-`forbidden-import` is the only implemented `check.type`. If a future rule
-needs something it can't express (e.g. "every aggregate file must have a
-matching events file"), add a new `type` value, a matching interface, and a
-case in `evaluateRule()` in `check.ts` — keep the engine itself generic;
-rule-specific knowledge belongs in `rules.json`.
+`forbidden-import` (whole-repo import graph) and `required-companion`
+(diff-based co-change) are the implemented `check.type`s. If a future rule
+needs a data source neither provides (e.g. "every aggregate file must have a
+matching events file", which is a repo-wide naming convention rather than
+either an import-graph or a diff check), add a new `type` value, a matching
+interface, and a case in `evaluateRule()` in `check.ts` — keep the engine
+itself generic; rule-specific knowledge belongs in `rules.json`.

package/architecture-rules/check.ts

@@ -6,6 +6,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import rulesFile from './rules.json';
 
 interface ForbiddenImportCheck {
@@ -16,12 +17,22 @@ interface ForbiddenImportCheck {
   forbid: string[];
 }
 
+interface RequiredCompanionCheck {
+  type: 'required-companion';
+  // Glob patterns selecting changed files that trigger the requirement.
+  from: string[];
+  // Glob patterns -- at least one CHANGED file must match one of these.
+  requireOneOf: string[];
+  // Optional -- 'from' files matching these globs don't trigger the requirement.
+  exempt?: string[];
+}
+
 interface Rule {
   id: string;
   description: string;
   enabled: boolean;
   severity: 'low' | 'medium' | 'high' | 'critical';
-  check: ForbiddenImportCheck;
+  check: ForbiddenImportCheck | RequiredCompanionCheck;
 }
 
 interface Violation {
@@ -32,6 +43,7 @@ interface Violation {
 
 const REPO_ROOT = path.resolve(__dirname, '..');
 const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);
+const BASE_REF = process.env.ARCHITECTURE_RULES_BASE_REF || 'origin/main';
 
 // Minimal glob -> RegExp: supports "*", "**", "**/" and literal path segments.
 // No new dependency for this — the only pattern shapes rules.json ever needs
@@ -69,6 +81,26 @@ function toRepoRelative(absPath: string): string {
   return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');
 }
 
+// Files changed relative to baseRef, sourced from git rather than the whole-tree
+// walk() below -- required-companion checks care about what a PR touched, not
+// the full repo. Throws (rather than returning []) if baseRef cannot be resolved,
+// so an unfetched base ref fails the check instead of silently reporting no violations.
+function getChangedFiles(baseRef: string): string[] {
+  let output: string;
+  try {
+    output = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', `${baseRef}...HEAD`], {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+    });
+  } catch (err) {
+    throw new Error(
+      `architecture-rules: failed to compute the changed-file set against base ref "${baseRef}" -- ` +
+        `is it fetched and resolvable in this checkout? (${(err as Error).message})`,
+    );
+  }
+  return output.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+}
+
 function walk(dir: string, acc: string[] = []): string[] {
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     if (IGNORED_DIRS.has(entry.name)) continue;
@@ -103,7 +135,7 @@ function resolvedCandidates(fromFile: string, spec: string): string[] {
 }
 
 function evaluateForbiddenImport(rule: Rule): Violation[] {
-  const { from, forbid } = rule.check;
+  const { from, forbid } = rule.check as ForbiddenImportCheck;
   if (from.length === 0 || forbid.length === 0) return [];
 
   const violations: Violation[] = [];
@@ -126,10 +158,34 @@ function evaluateForbiddenImport(rule: Rule): Violation[] {
   return violations;
 }
 
+function evaluateRequiredCompanion(rule: Rule): Violation[] {
+  const { from, requireOneOf, exempt } = rule.check as RequiredCompanionCheck;
+  if (from.length === 0 || requireOneOf.length === 0) return [];
+
+  const changedFiles = getChangedFiles(BASE_REF);
+  const triggering = changedFiles.filter(
+    (file) => matchesAny(file, from) && !(exempt && matchesAny(file, exempt)),
+  );
+  if (triggering.length === 0) return [];
+
+  const satisfied = changedFiles.some((file) => matchesAny(file, requireOneOf));
+  if (satisfied) return [];
+
+  return [
+    {
+      ruleId: rule.id,
+      severity: rule.severity,
+      message: `changed file(s) ${triggering.join(', ')} match rule "${rule.id}"'s "from" patterns, but no changed file matches its "requireOneOf" patterns`,
+    },
+  ];
+}
+
 function evaluateRule(rule: Rule): Violation[] {
   switch (rule.check.type) {
     case 'forbidden-import':
       return evaluateForbiddenImport(rule);
+    case 'required-companion':
+      return evaluateRequiredCompanion(rule);
     default:
       throw new Error(`architecture-rules: unknown check.type "${(rule.check as { type: string }).type}" on rule "${rule.id}"`);
   }

package/lib/BatmanProject.js

@@ -12,7 +12,7 @@ const SoftwareFactoryFiles_1 = require("./SoftwareFactoryFiles");
 const utils_1 = require("./utils");
 const ViteReactProject_1 = require("./ViteReactProject");
 class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.25.0" };
     constructor(options) {
         super({
             ...options,

package/lib/BootcampProject.js

@@ -12,7 +12,7 @@ const SoftwareFactoryFiles_1 = require("./SoftwareFactoryFiles");
 const utils_1 = require("./utils");
 const ViteReactProject_1 = require("./ViteReactProject");
 class BootcampProject extends awscdk_1.AwsCdkTypeScriptApp {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BootcampProject", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BootcampProject", version: "1.25.0" };
     constructor(options) {
         super({
             ...options,

package/lib/CodeOwnersFile.js

@@ -4,7 +4,7 @@ exports.CodeOwnersFile = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const projen_1 = require("projen");
 class CodeOwnersFile extends projen_1.TextFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.CodeOwnersFile", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.CodeOwnersFile", version: "1.25.0" };
     constructor(project, options = {}) {
         const defaultOwners = ['* @macedon-technologies/platform', '* @macedon-technologies/ai-development-team'];
         const allOwners = [...defaultOwners, ...(options.additionalOwners || [])];

package/lib/ProductionDeployWorkflow.js

@@ -7,7 +7,7 @@ const javascript_1 = require("projen/lib/javascript");
 const utils_1 = require("./utils");
 const WorkflowActionVersions_1 = require("./WorkflowActionVersions");
 class ProductionDeployWorkflow extends projen_1.YamlFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.ProductionDeployWorkflow", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.ProductionDeployWorkflow", version: "1.25.0" };
     constructor(project, options) {
         const packageManager = project.package.packageManager;
         const actionVersions = (0, WorkflowActionVersions_1.resolveActionVersions)(options.actionVersions);

package/lib/SoftwareFactoryArchitectureRules.js

@@ -21,6 +21,7 @@ class SoftwareFactoryArchitectureRules {
                 ' */',
                 "import * as fs from 'node:fs';",
                 "import * as path from 'node:path';",
+                "import { execFileSync } from 'node:child_process';",
                 "import rulesFile from './rules.json';",
                 '',
                 'interface ForbiddenImportCheck {',
@@ -31,12 +32,22 @@ class SoftwareFactoryArchitectureRules {
                 '  forbid: string[];',
                 '}',
                 '',
+                'interface RequiredCompanionCheck {',
+                "  type: 'required-companion';",
+                '  // Glob patterns selecting changed files that trigger the requirement.',
+                '  from: string[];',
+                '  // Glob patterns -- at least one CHANGED file must match one of these.',
+                '  requireOneOf: string[];',
+                "  // Optional -- 'from' files matching these globs don't trigger the requirement.",
+                '  exempt?: string[];',
+                '}',
+                '',
                 'interface Rule {',
                 '  id: string;',
                 '  description: string;',
                 '  enabled: boolean;',
                 "  severity: 'low' | 'medium' | 'high' | 'critical';",
-                '  check: ForbiddenImportCheck;',
+                '  check: ForbiddenImportCheck | RequiredCompanionCheck;',
                 '}',
                 '',
                 'interface Violation {',
@@ -47,6 +58,7 @@ class SoftwareFactoryArchitectureRules {
                 '',
                 "const REPO_ROOT = path.resolve(__dirname, '..');",
                 "const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);",
+                "const BASE_REF = process.env.ARCHITECTURE_RULES_BASE_REF || 'origin/main';",
                 '',
                 '// Minimal glob -> RegExp: supports "*", "**", "**/" and literal path segments.',
                 '// No new dependency for this — the only pattern shapes rules.json ever needs',
@@ -84,6 +96,26 @@ class SoftwareFactoryArchitectureRules {
                 "  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');",
                 '}',
                 '',
+                '// Files changed relative to baseRef, sourced from git rather than the whole-tree',
+                '// walk() below -- required-companion checks care about what a PR touched, not',
+                '// the full repo. Throws (rather than returning []) if baseRef cannot be resolved,',
+                '// so an unfetched base ref fails the check instead of silently reporting no violations.',
+                'function getChangedFiles(baseRef: string): string[] {',
+                '  let output: string;',
+                '  try {',
+                "    output = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', `${baseRef}...HEAD`], {",
+                '      cwd: REPO_ROOT,',
+                "      encoding: 'utf8',",
+                '    });',
+                '  } catch (err) {',
+                '    throw new Error(',
+                '      `architecture-rules: failed to compute the changed-file set against base ref "${baseRef}" -- ` +',
+                '        `is it fetched and resolvable in this checkout? (${(err as Error).message})`,',
+                '    );',
+                '  }',
+                "  return output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);",
+                '}',
+                '',
                 'function walk(dir: string, acc: string[] = []): string[] {',
                 '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',
                 '    if (IGNORED_DIRS.has(entry.name)) continue;',
@@ -118,7 +150,7 @@ class SoftwareFactoryArchitectureRules {
                 '}',
                 '',
                 'function evaluateForbiddenImport(rule: Rule): Violation[] {',
-                '  const { from, forbid } = rule.check;',
+                '  const { from, forbid } = rule.check as ForbiddenImportCheck;',
                 '  if (from.length === 0 || forbid.length === 0) return [];',
                 '',
                 '  const violations: Violation[] = [];',
@@ -141,10 +173,34 @@ class SoftwareFactoryArchitectureRules {
                 '  return violations;',
                 '}',
                 '',
+                'function evaluateRequiredCompanion(rule: Rule): Violation[] {',
+                '  const { from, requireOneOf, exempt } = rule.check as RequiredCompanionCheck;',
+                '  if (from.length === 0 || requireOneOf.length === 0) return [];',
+                '',
+                '  const changedFiles = getChangedFiles(BASE_REF);',
+                '  const triggering = changedFiles.filter(',
+                '    (file) => matchesAny(file, from) && !(exempt && matchesAny(file, exempt)),',
+                '  );',
+                '  if (triggering.length === 0) return [];',
+                '',
+                '  const satisfied = changedFiles.some((file) => matchesAny(file, requireOneOf));',
+                '  if (satisfied) return [];',
+                '',
+                '  return [',
+                '    {',
+                '      ruleId: rule.id,',
+                '      severity: rule.severity,',
+                '      message: `changed file(s) ${triggering.join(\', \')} match rule "${rule.id}"\'s "from" patterns, but no changed file matches its "requireOneOf" patterns`,',
+                '    },',
+                '  ];',
+                '}',
+                '',
                 'function evaluateRule(rule: Rule): Violation[] {',
                 '  switch (rule.check.type) {',
                 "    case 'forbidden-import':",
                 '      return evaluateForbiddenImport(rule);',
+                "    case 'required-companion':",
+                '      return evaluateRequiredCompanion(rule);',
                 '    default:',
                 '      throw new Error(`architecture-rules: unknown check.type "${(rule.check as { type: string }).type}" on rule "${rule.id}"`);',
                 '  }',
@@ -203,6 +259,9 @@ class SoftwareFactoryArchitectureRules {
                 '',
                 '## Rule shape',
                 '',
+                'Two `check.type`s are implemented: `forbidden-import` (whole-repo import-graph',
+                'check) and `required-companion` (diff-based co-change check).',
+                '',
                 '```json',
                 '{',
                 '  "id": "unique-id",',
@@ -217,6 +276,56 @@ class SoftwareFactoryArchitectureRules {
                 '}',
                 '```',
                 '',
+                '```json',
+                '{',
+                '  "id": "unique-id",',
+                '  "description": "What this enforces and why.",',
+                '  "enabled": true,',
+                '  "severity": "low" | "medium" | "high" | "critical",',
+                '  "check": {',
+                '    "type": "required-companion",',
+                '    "from": ["glob patterns selecting changed files that trigger the requirement"],',
+                '    "requireOneOf": ["glob patterns -- at least one CHANGED file must match one of these"],',
+                '    "exempt": ["optional -- from-files matching these globs don\'t trigger the requirement"]',
+                '  }',
+                '}',
+                '```',
+                '',
+                '`required-companion` evaluates the set of files changed in the current diff',
+                '(`git diff --name-only --diff-filter=ACMR <baseRef>...HEAD`), not the whole',
+                'repo tree: if any changed file matches `from` (and doesn\'t match `exempt`) but',
+                'no changed file matches `requireOneOf`, that\'s a violation. The base ref',
+                'defaults to `origin/main` and can be overridden with the',
+                '`ARCHITECTURE_RULES_BASE_REF` environment variable. This means the checkout',
+                'running `pnpm validate:architecture` must have that base ref fetched and',
+                'resolvable (a shallow, single-branch checkout will make the check fail closed',
+                'with an error rather than silently reporting no violations) — make sure',
+                'whatever runs this task fetches enough history for `git diff <baseRef>...HEAD`',
+                'to succeed.',
+                '',
+                '`from`/`requireOneOf`/`exempt` globs are matched against the paths `git',
+                'diff --name-only` reports, which are relative to the git repository\'s',
+                'top-level directory. This lines up with `from`\'s own directory (the parent of',
+                '`architecture-rules/`) in the common case — a single project generated at the',
+                'repo root — but if `architecture-rules/` instead lives under a nested',
+                'subdirectory of a larger git repo, write globs relative to the git root, not',
+                'to that subdirectory.',
+                '',
+                '**`required-companion` is a coverage check, not a correctness check.** It only',
+                'confirms that *some* changed file matches `requireOneOf` — it can\'t tell',
+                'whether that change is actually related to the triggering `from` change (a',
+                'trivial or unrelated edit to a file under `requireOneOf` satisfies the rule',
+                'just as well as a substantive one), and it can\'t tell whether a given `from`',
+                'change genuinely needed a companion at all (a pure refactor might not).',
+                '`exempt` covers *known, glob-expressible* exceptions, but not every false',
+                'positive is expressible as a glob — that judgment call still belongs to the',
+                'rule author (scoping `from`/`exempt`) and the reviewer (reading the companion',
+                'diff, not just trusting that the check passed). Also note that `main()`',
+                'fails the whole run on *any* violation regardless of `severity` — `severity`',
+                'is informational only, not a leniency lever — so start with a narrowly',
+                'scoped `from` (or `enabled: false`) and widen it as the convention proves',
+                'itself, the same guidance as for `forbidden-import`.',
+                '',
                 '`enabled: false` rules are skipped (reported as "deferred") rather than',
                 "evaluated — use this for a rule you've named and described but don't yet",
                 'have a concrete convention to check.',
@@ -229,11 +338,13 @@ class SoftwareFactoryArchitectureRules {
                 '',
                 '## Adding a check type',
                 '',
-                '`forbidden-import` is the only implemented `check.type`. If a future rule',
-                'needs something it can\'t express (e.g. "every aggregate file must have a',
-                'matching events file"), add a new `type` value, a matching interface, and a',
-                'case in `evaluateRule()` in `check.ts` — keep the engine itself generic;',
-                'rule-specific knowledge belongs in `rules.json`.',
+                '`forbidden-import` (whole-repo import graph) and `required-companion`',
+                '(diff-based co-change) are the implemented `check.type`s. If a future rule',
+                'needs a data source neither provides (e.g. "every aggregate file must have a',
+                'matching events file", which is a repo-wide naming convention rather than',
+                'either an import-graph or a diff check), add a new `type` value, a matching',
+                'interface, and a case in `evaluateRule()` in `check.ts` — keep the engine',
+                'itself generic; rule-specific knowledge belongs in `rules.json`.',
             ],
         });
         new projen_1.SampleFile(project, 'architecture-rules/rules.json', {
@@ -242,4 +353,4 @@ class SoftwareFactoryArchitectureRules {
     }
 }
 exports.SoftwareFactoryArchitectureRules = SoftwareFactoryArchitectureRules;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryArchitectureRules.js","sourceRoot":"","sources":["../src/SoftwareFactoryArchitectureRules.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, SampleFile, TextFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\n/**\n * The generic, data-driven architecture rule engine plus an empty seed\n * rules.json. `check.ts`/`tsconfig.json`/`README.md` are managed (Batman\n * owns the engine); `rules.json` is a `SampleFile` — each repo's own rules\n * are data the team owns, not something Batman should overwrite.\n */\nexport class SoftwareFactoryArchitectureRules {\n  constructor(project: NodeProject) {\n    new TextFile(project, 'architecture-rules/check.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Generic architecture-rule engine. Rules live entirely in rules.json — this',\n        ' * file only knows how to evaluate the check \"types\" that rules can declare.',\n        ' * Add a new rule by adding a rules.json entry; add a new check type by adding',\n        ' * a case in evaluateRule().',\n        ' */',\n        \"import * as fs from 'node:fs';\",\n        \"import * as path from 'node:path';\",\n        \"import rulesFile from './rules.json';\",\n        '',\n        'interface ForbiddenImportCheck {',\n        \"  type: 'forbidden-import';\",\n        '  // Glob patterns (relative to repo root) selecting the files this rule inspects.',\n        '  from: string[];',\n        '  // Glob patterns (relative to repo root) that \"from\" files may not import from.',\n        '  forbid: string[];',\n        '}',\n        '',\n        'interface Rule {',\n        '  id: string;',\n        '  description: string;',\n        '  enabled: boolean;',\n        \"  severity: 'low' | 'medium' | 'high' | 'critical';\",\n        '  check: ForbiddenImportCheck;',\n        '}',\n        '',\n        'interface Violation {',\n        '  ruleId: string;',\n        '  severity: string;',\n        '  message: string;',\n        '}',\n        '',\n        \"const REPO_ROOT = path.resolve(__dirname, '..');\",\n        \"const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);\",\n        '',\n        '// Minimal glob -> RegExp: supports \"*\", \"**\", \"**/\" and literal path segments.',\n        '// No new dependency for this — the only pattern shapes rules.json ever needs',\n        '// are directory-prefix globs like \"src/domains/*/commands/**\".',\n        'function globToRegExp(glob: string): RegExp {',\n        \"  let out = '';\",\n        '  for (let i = 0; i < glob.length; i++) {',\n        '    const c = glob[i];',\n        \"    if (c === '*' && glob[i + 1] === '*') {\",\n        '      i++;',\n        \"      if (glob[i + 1] === '/') {\",\n        \"        out += '(?:.*/)?';\",\n        '        i++;',\n        '      } else {',\n        \"        out += '.*';\",\n        '      }',\n        \"    } else if (c === '*') {\",\n        \"      out += '[^/]*';\",\n        \"    } else if (c === '?') {\",\n        \"      out += '[^/]';\",\n        \"    } else if ('.+^${}()|[]\\\\\\\\'.includes(c)) {\",\n        '      out += `\\\\\\\\${c}`;',\n        '    } else {',\n        '      out += c;',\n        '    }',\n        '  }',\n        '  return new RegExp(`^${out}$`);',\n        '}',\n        '',\n        'function matchesAny(relFile: string, globs: string[]): boolean {',\n        '  return globs.some((glob) => globToRegExp(glob).test(relFile));',\n        '}',\n        '',\n        'function toRepoRelative(absPath: string): string {',\n        \"  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');\",\n        '}',\n        '',\n        'function walk(dir: string, acc: string[] = []): string[] {',\n        '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',\n        '    if (IGNORED_DIRS.has(entry.name)) continue;',\n        '    const full = path.join(dir, entry.name);',\n        '    if (entry.isDirectory()) {',\n        '      walk(full, acc);',\n        \"    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {\",\n        '      acc.push(full);',\n        '    }',\n        '  }',\n        '  return acc;',\n        '}',\n        '',\n        \"const RELATIVE_IMPORT_RE = /(?:import|export)\\\\s+(?:[^'\\\";]*?\\\\bfrom\\\\s+)?['\\\"](\\\\.[^'\\\"]+)['\\\"]/g;\",\n        '',\n        'function findRelativeImports(source: string): string[] {',\n        '  const specs: string[] = [];',\n        '  RELATIVE_IMPORT_RE.lastIndex = 0;',\n        '  let match: RegExpExecArray | null;',\n        '  while ((match = RELATIVE_IMPORT_RE.exec(source))) {',\n        '    specs.push(match[1]);',\n        '  }',\n        '  return specs;',\n        '}',\n        '',\n        '// An import spec resolves to a module, not a specific file extension, so a',\n        '// forbid glob is checked against the bare resolved path plus its .ts/index.ts',\n        '// variants.',\n        'function resolvedCandidates(fromFile: string, spec: string): string[] {',\n        '  const resolved = toRepoRelative(path.normalize(path.join(path.dirname(fromFile), spec)));',\n        '  return [resolved, `${resolved}.ts`, `${resolved}/index.ts`];',\n        '}',\n        '',\n        'function evaluateForbiddenImport(rule: Rule): Violation[] {',\n        '  const { from, forbid } = rule.check;',\n        '  if (from.length === 0 || forbid.length === 0) return [];',\n        '',\n        '  const violations: Violation[] = [];',\n        '  for (const file of walk(REPO_ROOT)) {',\n        '    const relFile = toRepoRelative(file);',\n        '    if (!matchesAny(relFile, from)) continue;',\n        '',\n        \"    const source = fs.readFileSync(file, 'utf8');\",\n        '    for (const spec of findRelativeImports(source)) {',\n        '      const candidates = resolvedCandidates(file, spec);',\n        '      if (candidates.some((candidate) => matchesAny(candidate, forbid))) {',\n        '        violations.push({',\n        '          ruleId: rule.id,',\n        '          severity: rule.severity,',\n        '          message: `${relFile} imports \"${spec}\", which resolves under a path forbidden by rule \"${rule.id}\"`,',\n        '        });',\n        '      }',\n        '    }',\n        '  }',\n        '  return violations;',\n        '}',\n        '',\n        'function evaluateRule(rule: Rule): Violation[] {',\n        '  switch (rule.check.type) {',\n        \"    case 'forbidden-import':\",\n        '      return evaluateForbiddenImport(rule);',\n        '    default:',\n        '      throw new Error(`architecture-rules: unknown check.type \"${(rule.check as { type: string }).type}\" on rule \"${rule.id}\"`);',\n        '  }',\n        '}',\n        '',\n        'function main(): number {',\n        '  const rules = (rulesFile as { rules: Rule[] }).rules;',\n        '  let evaluated = 0;',\n        '  let deferred = 0;',\n        '  const violations: Violation[] = [];',\n        '',\n        '  for (const rule of rules) {',\n        '    if (!rule.enabled) {',\n        '      deferred++;',\n        '      console.log(`[deferred] ${rule.id}: ${rule.description}`);',\n        '      continue;',\n        '    }',\n        '    evaluated++;',\n        '    violations.push(...evaluateRule(rule));',\n        '  }',\n        '',\n        '  console.log(`\\\\narchitecture-rules: ${evaluated} rule(s) evaluated, ${deferred} deferred, ${violations.length} violation(s)`);',\n        '  for (const violation of violations) {',\n        '    console.error(`  [${violation.severity}] ${violation.ruleId}: ${violation.message}`);',\n        '  }',\n        '',\n        '  return violations.length > 0 ? 1 : 0;',\n        '}',\n        '',\n        'process.exit(main());',\n      ],\n    });\n\n    new JsonFile(project, 'architecture-rules/tsconfig.json', {\n      marker: false,\n      obj: {\n        extends: '../tsconfig.json',\n        compilerOptions: {\n          noEmit: true,\n          rootDir: '.',\n        },\n        include: ['*.ts', '*.json'],\n        exclude: ['node_modules'],\n      },\n    });\n\n    new TextFile(project, 'architecture-rules/README.md', {\n      marker: true,\n      lines: [\n        '# Architecture rules',\n        '',\n        'A data-driven registry of architectural constraints, enforced by',\n        '`pnpm validate:architecture` and run as part of the pre-PR verification',\n        'workflow (`workflows/workflow-pre-pr-verify.yaml`) before the swamp factory',\n        'opens a PR. New rules are new entries in `rules.json`, not new code — the',\n        'engine (`check.ts`) only needs a new case in `evaluateRule()` when a rule',\n        'needs a genuinely new kind of check.',\n        '',\n        '## Rule shape',\n        '',\n        '```json',\n        '{',\n        '  \"id\": \"unique-id\",',\n        '  \"description\": \"What this enforces and why.\",',\n        '  \"enabled\": true,',\n        '  \"severity\": \"low\" | \"medium\" | \"high\" | \"critical\",',\n        '  \"check\": {',\n        '    \"type\": \"forbidden-import\",',\n        '    \"from\": [\"glob patterns selecting files this rule inspects\"],',\n        '    \"forbid\": [\"glob patterns those files may not import from\"]',\n        '  }',\n        '}',\n        '```',\n        '',\n        '`enabled: false` rules are skipped (reported as \"deferred\") rather than',\n        \"evaluated — use this for a rule you've named and described but don't yet\",\n        'have a concrete convention to check.',\n        '',\n        '## Current rules',\n        '',\n        'None yet — `rules.json` ships empty. Add rules as your domain module',\n        'conventions solidify (e.g. an event-sourced/CQRS module layout under',\n        '`src/domains/<name>/{commands,events,aggregates,projections}/`).',\n        '',\n        '## Adding a check type',\n        '',\n        '`forbidden-import` is the only implemented `check.type`. If a future rule',\n        'needs something it can\\'t express (e.g. \"every aggregate file must have a',\n        'matching events file\"), add a new `type` value, a matching interface, and a',\n        'case in `evaluateRule()` in `check.ts` — keep the engine itself generic;',\n        'rule-specific knowledge belongs in `rules.json`.',\n      ],\n    });\n\n    new SampleFile(project, 'architecture-rules/rules.json', {\n      contents: JSON.stringify({ rules: [] }, null, 2) + '\\n',\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryArchitectureRules.js","sourceRoot":"","sources":["../src/SoftwareFactoryArchitectureRules.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, SampleFile, TextFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\n/**\n * The generic, data-driven architecture rule engine plus an empty seed\n * rules.json. `check.ts`/`tsconfig.json`/`README.md` are managed (Batman\n * owns the engine); `rules.json` is a `SampleFile` — each repo's own rules\n * are data the team owns, not something Batman should overwrite.\n */\nexport class SoftwareFactoryArchitectureRules {\n  constructor(project: NodeProject) {\n    new TextFile(project, 'architecture-rules/check.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Generic architecture-rule engine. Rules live entirely in rules.json — this',\n        ' * file only knows how to evaluate the check \"types\" that rules can declare.',\n        ' * Add a new rule by adding a rules.json entry; add a new check type by adding',\n        ' * a case in evaluateRule().',\n        ' */',\n        \"import * as fs from 'node:fs';\",\n        \"import * as path from 'node:path';\",\n        \"import { execFileSync } from 'node:child_process';\",\n        \"import rulesFile from './rules.json';\",\n        '',\n        'interface ForbiddenImportCheck {',\n        \"  type: 'forbidden-import';\",\n        '  // Glob patterns (relative to repo root) selecting the files this rule inspects.',\n        '  from: string[];',\n        '  // Glob patterns (relative to repo root) that \"from\" files may not import from.',\n        '  forbid: string[];',\n        '}',\n        '',\n        'interface RequiredCompanionCheck {',\n        \"  type: 'required-companion';\",\n        '  // Glob patterns selecting changed files that trigger the requirement.',\n        '  from: string[];',\n        '  // Glob patterns -- at least one CHANGED file must match one of these.',\n        '  requireOneOf: string[];',\n        \"  // Optional -- 'from' files matching these globs don't trigger the requirement.\",\n        '  exempt?: string[];',\n        '}',\n        '',\n        'interface Rule {',\n        '  id: string;',\n        '  description: string;',\n        '  enabled: boolean;',\n        \"  severity: 'low' | 'medium' | 'high' | 'critical';\",\n        '  check: ForbiddenImportCheck | RequiredCompanionCheck;',\n        '}',\n        '',\n        'interface Violation {',\n        '  ruleId: string;',\n        '  severity: string;',\n        '  message: string;',\n        '}',\n        '',\n        \"const REPO_ROOT = path.resolve(__dirname, '..');\",\n        \"const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);\",\n        \"const BASE_REF = process.env.ARCHITECTURE_RULES_BASE_REF || 'origin/main';\",\n        '',\n        '// Minimal glob -> RegExp: supports \"*\", \"**\", \"**/\" and literal path segments.',\n        '// No new dependency for this — the only pattern shapes rules.json ever needs',\n        '// are directory-prefix globs like \"src/domains/*/commands/**\".',\n        'function globToRegExp(glob: string): RegExp {',\n        \"  let out = '';\",\n        '  for (let i = 0; i < glob.length; i++) {',\n        '    const c = glob[i];',\n        \"    if (c === '*' && glob[i + 1] === '*') {\",\n        '      i++;',\n        \"      if (glob[i + 1] === '/') {\",\n        \"        out += '(?:.*/)?';\",\n        '        i++;',\n        '      } else {',\n        \"        out += '.*';\",\n        '      }',\n        \"    } else if (c === '*') {\",\n        \"      out += '[^/]*';\",\n        \"    } else if (c === '?') {\",\n        \"      out += '[^/]';\",\n        \"    } else if ('.+^${}()|[]\\\\\\\\'.includes(c)) {\",\n        '      out += `\\\\\\\\${c}`;',\n        '    } else {',\n        '      out += c;',\n        '    }',\n        '  }',\n        '  return new RegExp(`^${out}$`);',\n        '}',\n        '',\n        'function matchesAny(relFile: string, globs: string[]): boolean {',\n        '  return globs.some((glob) => globToRegExp(glob).test(relFile));',\n        '}',\n        '',\n        'function toRepoRelative(absPath: string): string {',\n        \"  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');\",\n        '}',\n        '',\n        '// Files changed relative to baseRef, sourced from git rather than the whole-tree',\n        '// walk() below -- required-companion checks care about what a PR touched, not',\n        '// the full repo. Throws (rather than returning []) if baseRef cannot be resolved,',\n        '// so an unfetched base ref fails the check instead of silently reporting no violations.',\n        'function getChangedFiles(baseRef: string): string[] {',\n        '  let output: string;',\n        '  try {',\n        \"    output = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', `${baseRef}...HEAD`], {\",\n        '      cwd: REPO_ROOT,',\n        \"      encoding: 'utf8',\",\n        '    });',\n        '  } catch (err) {',\n        '    throw new Error(',\n        '      `architecture-rules: failed to compute the changed-file set against base ref \"${baseRef}\" -- ` +',\n        '        `is it fetched and resolvable in this checkout? (${(err as Error).message})`,',\n        '    );',\n        '  }',\n        \"  return output.split('\\\\n').map((line) => line.trim()).filter((line) => line.length > 0);\",\n        '}',\n        '',\n        'function walk(dir: string, acc: string[] = []): string[] {',\n        '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',\n        '    if (IGNORED_DIRS.has(entry.name)) continue;',\n        '    const full = path.join(dir, entry.name);',\n        '    if (entry.isDirectory()) {',\n        '      walk(full, acc);',\n        \"    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {\",\n        '      acc.push(full);',\n        '    }',\n        '  }',\n        '  return acc;',\n        '}',\n        '',\n        \"const RELATIVE_IMPORT_RE = /(?:import|export)\\\\s+(?:[^'\\\";]*?\\\\bfrom\\\\s+)?['\\\"](\\\\.[^'\\\"]+)['\\\"]/g;\",\n        '',\n        'function findRelativeImports(source: string): string[] {',\n        '  const specs: string[] = [];',\n        '  RELATIVE_IMPORT_RE.lastIndex = 0;',\n        '  let match: RegExpExecArray | null;',\n        '  while ((match = RELATIVE_IMPORT_RE.exec(source))) {',\n        '    specs.push(match[1]);',\n        '  }',\n        '  return specs;',\n        '}',\n        '',\n        '// An import spec resolves to a module, not a specific file extension, so a',\n        '// forbid glob is checked against the bare resolved path plus its .ts/index.ts',\n        '// variants.',\n        'function resolvedCandidates(fromFile: string, spec: string): string[] {',\n        '  const resolved = toRepoRelative(path.normalize(path.join(path.dirname(fromFile), spec)));',\n        '  return [resolved, `${resolved}.ts`, `${resolved}/index.ts`];',\n        '}',\n        '',\n        'function evaluateForbiddenImport(rule: Rule): Violation[] {',\n        '  const { from, forbid } = rule.check as ForbiddenImportCheck;',\n        '  if (from.length === 0 || forbid.length === 0) return [];',\n        '',\n        '  const violations: Violation[] = [];',\n        '  for (const file of walk(REPO_ROOT)) {',\n        '    const relFile = toRepoRelative(file);',\n        '    if (!matchesAny(relFile, from)) continue;',\n        '',\n        \"    const source = fs.readFileSync(file, 'utf8');\",\n        '    for (const spec of findRelativeImports(source)) {',\n        '      const candidates = resolvedCandidates(file, spec);',\n        '      if (candidates.some((candidate) => matchesAny(candidate, forbid))) {',\n        '        violations.push({',\n        '          ruleId: rule.id,',\n        '          severity: rule.severity,',\n        '          message: `${relFile} imports \"${spec}\", which resolves under a path forbidden by rule \"${rule.id}\"`,',\n        '        });',\n        '      }',\n        '    }',\n        '  }',\n        '  return violations;',\n        '}',\n        '',\n        'function evaluateRequiredCompanion(rule: Rule): Violation[] {',\n        '  const { from, requireOneOf, exempt } = rule.check as RequiredCompanionCheck;',\n        '  if (from.length === 0 || requireOneOf.length === 0) return [];',\n        '',\n        '  const changedFiles = getChangedFiles(BASE_REF);',\n        '  const triggering = changedFiles.filter(',\n        '    (file) => matchesAny(file, from) && !(exempt && matchesAny(file, exempt)),',\n        '  );',\n        '  if (triggering.length === 0) return [];',\n        '',\n        '  const satisfied = changedFiles.some((file) => matchesAny(file, requireOneOf));',\n        '  if (satisfied) return [];',\n        '',\n        '  return [',\n        '    {',\n        '      ruleId: rule.id,',\n        '      severity: rule.severity,',\n        '      message: `changed file(s) ${triggering.join(\\', \\')} match rule \"${rule.id}\"\\'s \"from\" patterns, but no changed file matches its \"requireOneOf\" patterns`,',\n        '    },',\n        '  ];',\n        '}',\n        '',\n        'function evaluateRule(rule: Rule): Violation[] {',\n        '  switch (rule.check.type) {',\n        \"    case 'forbidden-import':\",\n        '      return evaluateForbiddenImport(rule);',\n        \"    case 'required-companion':\",\n        '      return evaluateRequiredCompanion(rule);',\n        '    default:',\n        '      throw new Error(`architecture-rules: unknown check.type \"${(rule.check as { type: string }).type}\" on rule \"${rule.id}\"`);',\n        '  }',\n        '}',\n        '',\n        'function main(): number {',\n        '  const rules = (rulesFile as { rules: Rule[] }).rules;',\n        '  let evaluated = 0;',\n        '  let deferred = 0;',\n        '  const violations: Violation[] = [];',\n        '',\n        '  for (const rule of rules) {',\n        '    if (!rule.enabled) {',\n        '      deferred++;',\n        '      console.log(`[deferred] ${rule.id}: ${rule.description}`);',\n        '      continue;',\n        '    }',\n        '    evaluated++;',\n        '    violations.push(...evaluateRule(rule));',\n        '  }',\n        '',\n        '  console.log(`\\\\narchitecture-rules: ${evaluated} rule(s) evaluated, ${deferred} deferred, ${violations.length} violation(s)`);',\n        '  for (const violation of violations) {',\n        '    console.error(`  [${violation.severity}] ${violation.ruleId}: ${violation.message}`);',\n        '  }',\n        '',\n        '  return violations.length > 0 ? 1 : 0;',\n        '}',\n        '',\n        'process.exit(main());',\n      ],\n    });\n\n    new JsonFile(project, 'architecture-rules/tsconfig.json', {\n      marker: false,\n      obj: {\n        extends: '../tsconfig.json',\n        compilerOptions: {\n          noEmit: true,\n          rootDir: '.',\n        },\n        include: ['*.ts', '*.json'],\n        exclude: ['node_modules'],\n      },\n    });\n\n    new TextFile(project, 'architecture-rules/README.md', {\n      marker: true,\n      lines: [\n        '# Architecture rules',\n        '',\n        'A data-driven registry of architectural constraints, enforced by',\n        '`pnpm validate:architecture` and run as part of the pre-PR verification',\n        'workflow (`workflows/workflow-pre-pr-verify.yaml`) before the swamp factory',\n        'opens a PR. New rules are new entries in `rules.json`, not new code — the',\n        'engine (`check.ts`) only needs a new case in `evaluateRule()` when a rule',\n        'needs a genuinely new kind of check.',\n        '',\n        '## Rule shape',\n        '',\n        'Two `check.type`s are implemented: `forbidden-import` (whole-repo import-graph',\n        'check) and `required-companion` (diff-based co-change check).',\n        '',\n        '```json',\n        '{',\n        '  \"id\": \"unique-id\",',\n        '  \"description\": \"What this enforces and why.\",',\n        '  \"enabled\": true,',\n        '  \"severity\": \"low\" | \"medium\" | \"high\" | \"critical\",',\n        '  \"check\": {',\n        '    \"type\": \"forbidden-import\",',\n        '    \"from\": [\"glob patterns selecting files this rule inspects\"],',\n        '    \"forbid\": [\"glob patterns those files may not import from\"]',\n        '  }',\n        '}',\n        '```',\n        '',\n        '```json',\n        '{',\n        '  \"id\": \"unique-id\",',\n        '  \"description\": \"What this enforces and why.\",',\n        '  \"enabled\": true,',\n        '  \"severity\": \"low\" | \"medium\" | \"high\" | \"critical\",',\n        '  \"check\": {',\n        '    \"type\": \"required-companion\",',\n        '    \"from\": [\"glob patterns selecting changed files that trigger the requirement\"],',\n        '    \"requireOneOf\": [\"glob patterns -- at least one CHANGED file must match one of these\"],',\n        '    \"exempt\": [\"optional -- from-files matching these globs don\\'t trigger the requirement\"]',\n        '  }',\n        '}',\n        '```',\n        '',\n        '`required-companion` evaluates the set of files changed in the current diff',\n        '(`git diff --name-only --diff-filter=ACMR <baseRef>...HEAD`), not the whole',\n        'repo tree: if any changed file matches `from` (and doesn\\'t match `exempt`) but',\n        'no changed file matches `requireOneOf`, that\\'s a violation. The base ref',\n        'defaults to `origin/main` and can be overridden with the',\n        '`ARCHITECTURE_RULES_BASE_REF` environment variable. This means the checkout',\n        'running `pnpm validate:architecture` must have that base ref fetched and',\n        'resolvable (a shallow, single-branch checkout will make the check fail closed',\n        'with an error rather than silently reporting no violations) — make sure',\n        'whatever runs this task fetches enough history for `git diff <baseRef>...HEAD`',\n        'to succeed.',\n        '',\n        '`from`/`requireOneOf`/`exempt` globs are matched against the paths `git',\n        'diff --name-only` reports, which are relative to the git repository\\'s',\n        'top-level directory. This lines up with `from`\\'s own directory (the parent of',\n        '`architecture-rules/`) in the common case — a single project generated at the',\n        'repo root — but if `architecture-rules/` instead lives under a nested',\n        'subdirectory of a larger git repo, write globs relative to the git root, not',\n        'to that subdirectory.',\n        '',\n        '**`required-companion` is a coverage check, not a correctness check.** It only',\n        'confirms that *some* changed file matches `requireOneOf` — it can\\'t tell',\n        'whether that change is actually related to the triggering `from` change (a',\n        'trivial or unrelated edit to a file under `requireOneOf` satisfies the rule',\n        'just as well as a substantive one), and it can\\'t tell whether a given `from`',\n        'change genuinely needed a companion at all (a pure refactor might not).',\n        '`exempt` covers *known, glob-expressible* exceptions, but not every false',\n        'positive is expressible as a glob — that judgment call still belongs to the',\n        'rule author (scoping `from`/`exempt`) and the reviewer (reading the companion',\n        'diff, not just trusting that the check passed). Also note that `main()`',\n        'fails the whole run on *any* violation regardless of `severity` — `severity`',\n        'is informational only, not a leniency lever — so start with a narrowly',\n        'scoped `from` (or `enabled: false`) and widen it as the convention proves',\n        'itself, the same guidance as for `forbidden-import`.',\n        '',\n        '`enabled: false` rules are skipped (reported as \"deferred\") rather than',\n        \"evaluated — use this for a rule you've named and described but don't yet\",\n        'have a concrete convention to check.',\n        '',\n        '## Current rules',\n        '',\n        'None yet — `rules.json` ships empty. Add rules as your domain module',\n        'conventions solidify (e.g. an event-sourced/CQRS module layout under',\n        '`src/domains/<name>/{commands,events,aggregates,projections}/`).',\n        '',\n        '## Adding a check type',\n        '',\n        '`forbidden-import` (whole-repo import graph) and `required-companion`',\n        '(diff-based co-change) are the implemented `check.type`s. If a future rule',\n        'needs a data source neither provides (e.g. \"every aggregate file must have a',\n        'matching events file\", which is a repo-wide naming convention rather than',\n        'either an import-graph or a diff check), add a new `type` value, a matching',\n        'interface, and a case in `evaluateRule()` in `check.ts` — keep the engine',\n        'itself generic; rule-specific knowledge belongs in `rules.json`.',\n      ],\n    });\n\n    new SampleFile(project, 'architecture-rules/rules.json', {\n      contents: JSON.stringify({ rules: [] }, null, 2) + '\\n',\n    });\n  }\n}\n"]}

package/lib/SoftwareFactoryFiles.js

@@ -31,7 +31,7 @@ const DEFAULT_GITHUB_OWNER = 'macedon-technologies';
  * workflows that wire them together) is templated.
  */
 class SoftwareFactoryFiles {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.25.0" };
     constructor(project, options) {
         const { repoName, actionVersions } = options;
         const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;

package/lib/SoftwareFactoryModels.js

@@ -298,8 +298,22 @@ globalArguments:
           change-request evidence>, base=${baseBranch}, dryRun=false), with
           title/body referencing the intake stage's issue number, the
           OpenSpec change(s), the attestation block, and the manifest
-          comment, then record the pr-opened evidence with the returned PR
-          url and number.
+          comment. If openPr fails specifically because the vault can't
+          resolve GITHUB_TOKEN (an error naming \`GITHUB_TOKEN\` as not
+          found), don't treat that as terminal — fall back to opening the
+          PR via the \`gh\` CLI instead: push the branch recorded in
+          change-request evidence with \`git push -u origin <branch>\` if it
+          isn't already pushed, write the exact same title and body
+          (attestation block, manifest comment, and OpenSpec change
+          line(s) included) to a temp file, and run \`gh pr create --title
+          "<title>" --body-file <path> --base ${baseBranch} --head <branch> --repo
+          ${repo}\`. Any other openPr failure
+          (bad arguments, network, permissions) MUST still be surfaced as
+          a real failure, not papered over with this fallback. Then record
+          the pr-opened evidence with the returned PR url and number —
+          from openPr's response on the primary path, or by parsing \`gh pr
+          create\`'s output (or a follow-up \`gh pr view <branch> --json
+          number,url\`) on the fallback path.
       evidence:
         - name: pr-opened
           schema:
@@ -338,4 +352,4 @@ methods: {}
     }
 }
 exports.SoftwareFactoryModels = SoftwareFactoryModels;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryModels.js","sourceRoot":"","sources":["../src/SoftwareFactoryModels.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AACpC,mCAAoC;AAqBpC;;;;;GAKG;AACH,MAAa,qBAAqB;IAChC,YAAY,OAAoB,EAAE,OAAqC;QACrE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QACtD,MAAM,IAAI,GAAG,GAAG,WAAW,IAAI,QAAQ,EAAE,CAAC;QAC1C,MAAM,WAAW,GAAG,GAAG,QAAQ,SAAS,CAAC;QACzC,MAAM,OAAO,GAAG,GAAG,QAAQ,KAAK,CAAC;QACjC,MAAM,UAAU,GAAG,GAAG,QAAQ,QAAQ,CAAC;QACvC,MAAM,sBAAsB,GAAG,GAAG,QAAQ,qBAAqB,CAAC;QAChE,MAAM,kBAAkB,GAAG,GAAG,QAAQ,iBAAiB,CAAC;QACxD,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAC3C,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAE3C,IAAI,mBAAU,CAAC,OAAO,EAAE,4BAA4B,OAAO,OAAO,EAAE;YAClE,QAAQ,EAAE;;MAEV,IAAA,mBAAU,GAAE;QACV,OAAO;;;;2BAIY,YAAY;WAC5B,WAAW;;CAErB;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,2BAA2B,WAAW,OAAO,EAAE;YACrE,QAAQ,EAAE;;MAEV,IAAA,mBAAU,GAAE;QACV,WAAW;;;;;CAKlB;SACI,CAAC,CAAC;QAEH,KAAK,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE,sBAAsB,EAAE,kBAAkB,CAAC,EAAE,CAAC;YAC5E,IAAI,mBAAU,CAAC,OAAO,EAAE,wBAAwB,IAAI,OAAO,EAAE;gBAC3D,QAAQ,EAAE;;MAEZ,IAAA,mBAAU,GAAE;QACV,IAAI;;;;;CAKX;aACM,CAAC,CAAC;QACL,CAAC;QAED,IAAI,mBAAU,CAAC,OAAO,EAAE,kCAAkC,YAAY,OAAO,EAAE;YAC7E,QAAQ,EAAE;;MAEV,IAAA,mBAAU,GAAE;QACV,YAAY;;;;;;;;;;;;;;;;;;YAkBR,IAAI,cAAc,WAAW;;YAE7B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDA4L+B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;sBAwBlD,OAAO;kBACX,IAAI;2CACqB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCpD;SACI,CAAC,CAAC;IACL,CAAC;CACF;AA3UD,sDA2UC","sourcesContent":["import { randomUUID } from 'crypto';\nimport { SampleFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\nexport interface SoftwareFactoryModelsOptions {\n  /**\n   * The bare repo name (e.g. `expense-tracker`), used to derive model names\n   * like `<repoName>-factory`, `<repoName>-shell`, `<repoName>-secrets`.\n   */\n  readonly repoName: string;\n\n  /**\n   * The GitHub org the repo lives in.\n   */\n  readonly githubOwner: string;\n\n  /**\n   * The branch the factory opens pull requests against.\n   */\n  readonly baseBranch: string;\n}\n\n/**\n * Seed swamp model instances wiring the `@swamp/software-factory` state\n * machine to this repo's GitHub issues/PRs and shell steps. These are\n * `SampleFile`s (written once, then owned by the team) since the factory's\n * stages/gates are the kind of thing a team tunes for its own workflow.\n */\nexport class SoftwareFactoryModels {\n  constructor(project: NodeProject, options: SoftwareFactoryModelsOptions) {\n    const { repoName, githubOwner, baseBranch } = options;\n    const repo = `${githubOwner}/${repoName}`;\n    const issuesModel = `${repoName}-issues`;\n    const prModel = `${repoName}-pr`;\n    const shellModel = `${repoName}-shell`;\n    const shellArchitectureModel = `${repoName}-shell-architecture`;\n    const shellManifestModel = `${repoName}-shell-manifest`;\n    const secretsVault = `${repoName}-secrets`;\n    const factoryModel = `${repoName}-factory`;\n\n    new SampleFile(project, `models/@goodcraft/github/${prModel}.yaml`, {\n      contents: `type: '@goodcraft/github'\ntypeVersion: 2026.06.14.1\nid: ${randomUUID()}\nname: ${prModel}\nversion: 1\ntags: {}\nglobalArguments:\n  token: '\\${{ vault.get(${secretsVault}, GITHUB_TOKEN) }}'\n  owner: ${githubOwner}\nmethods: {}\n`,\n    });\n\n    new SampleFile(project, `models/@webframp/github/${issuesModel}.yaml`, {\n      contents: `type: '@webframp/github'\ntypeVersion: 2026.08.28.1\nid: ${randomUUID()}\nname: ${issuesModel}\nversion: 1\ntags: {}\nglobalArguments: {}\nmethods: {}\n`,\n    });\n\n    for (const name of [shellModel, shellArchitectureModel, shellManifestModel]) {\n      new SampleFile(project, `models/command/shell/${name}.yaml`, {\n        contents: `type: command/shell\ntypeVersion: 2026.02.09.1\nid: ${randomUUID()}\nname: ${name}\nversion: 1\ntags: {}\nglobalArguments: {}\nmethods: {}\n`,\n      });\n    }\n\n    new SampleFile(project, `models/@swamp/software-factory/${factoryModel}.yaml`, {\n      contents: `type: '@swamp/software-factory'\ntypeVersion: 2026.06.24.1\nid: ${randomUUID()}\nname: ${factoryModel}\nversion: 1\ntags: {}\nreports:\n  require:\n    - name: \"@swamp/software-factory/work-item-summary\"\n      methods: [summary]\nglobalArguments:\n  stages:\n    - id: intake\n      initial: true\n      description: >-\n        Fetch the GitHub issue for this work item (workItem is the bare\n        issue number) and record its context.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Fetch the GitHub issue numbered \\${{ self.workItem }} for\n          ${repo} using the ${issuesModel} model\n          (list_issues, then swamp data query filtered by number — see the\n          ${issuesModel} data), and record the issue-context artifact.\n      artifacts:\n        - name: issue-context\n          schema:\n            type: object\n            required: [number, title, url]\n            properties:\n              number: { type: integer }\n              title: { type: string, minLength: 1 }\n              body: { type: string }\n              url: { type: string, minLength: 1 }\n              labels: { type: array, items: { type: string } }\n      transitions:\n        - name: submit\n          to: planning\n          gates:\n            - type: artifact-exists\n              config: { artifact: issue-context }\n\n    - id: planning\n      description: >-\n        Turn the issue into a real OpenSpec change (proposal, design,\n        specs, tasks) — OpenSpec's task list is the plan, not a\n        freeform artifact.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Using the recorded issue-context artifact, use the\n          openspec-propose skill to create a complete OpenSpec change\n          (proposal.md, design.md, specs with deltas, tasks.md) for this\n          work item under openspec/changes/<changeSlug>/ — do not write a\n          freeform plan instead of this. Then record the plan artifact\n          with the change's slug and a one-line summary.\n      artifacts:\n        - name: plan\n          schema:\n            type: object\n            required: [changeSlug, summary]\n            properties:\n              changeSlug: { type: string, minLength: 1 }\n              summary: { type: string, minLength: 1 }\n      transitions:\n        - name: submit\n          to: openspec-plan-verify\n          gates:\n            - type: artifact-exists\n              config: { artifact: plan }\n\n    - id: openspec-plan-verify\n      description: >-\n        Verify the OpenSpec change is real and well-formed (not just an\n        artifact claiming one exists) before implementation starts. Requires\n        a human to approve the 'implementation-approval' gate before\n        advancing to implementing. A reject on that gate doesn't dead-end\n        the run — take the ungated 'rework' transition back to planning to\n        produce a revised plan and ask again.\n      work:\n        mode: workflow\n        workflow:\n          name: openspec-plan-verify\n          inputs:\n            changeSlug: '\\${{ data.latest(self.name, \"artifact-plan\").payload.changeSlug }}'\n        resultEvidence: plan-verify-run\n      transitions:\n        - name: pass\n          to: implementing\n          gates:\n            - type: workflow-succeeded\n              config: { workflow: openspec-plan-verify }\n            - type: human-approval\n              config: { id: implementation-approval }\n        - name: fail\n          to: planning\n          gates:\n            - type: evidence-recorded\n              config: { name: plan-verify-run, requireField: { status: failed } }\n        - name: rework\n          to: planning\n          gates: []\n\n    - id: implementing\n      description: Implement the OpenSpec change's tasks on a branch.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Use the openspec-apply-change skill against the change recorded\n          in the plan artifact's changeSlug — work through its tasks.md\n          one task at a time, checking each off (\\`- [ ]\\` -> \\`- [x]\\`) as\n          you complete it, until every task is done. Commit the work on a\n          feature branch. Record the change-summary artifact and the\n          change-request evidence (branch name and head commit sha — no\n          PR yet, that happens after pre-PR verification passes).\n      artifacts:\n        - name: change-summary\n          schema:\n            type: object\n            required: [summary, headSha]\n            properties:\n              summary: { type: string, minLength: 1 }\n              headSha: { type: string, minLength: 7 }\n      evidence:\n        - name: change-request\n          schema:\n            type: object\n            required: [branch, headSha]\n            properties:\n              branch: { type: string, minLength: 1 }\n              headSha: { type: string, minLength: 7 }\n              url: { type: string }\n      transitions:\n        - name: submit\n          to: openspec-tasks-verify\n          gates:\n            - type: artifact-exists\n              config: { artifact: change-summary }\n            - type: evidence-recorded\n              config: { name: change-request }\n\n    - id: openspec-tasks-verify\n      description: >-\n        Verify every task in the OpenSpec change is actually checked off\n        before pre-PR verification runs.\n      work:\n        mode: workflow\n        workflow:\n          name: openspec-tasks-verify\n          inputs:\n            changeSlug: '\\${{ data.latest(self.name, \"artifact-plan\").payload.changeSlug }}'\n        resultEvidence: tasks-verify-run\n      transitions:\n        - name: pass\n          to: pre-pr-verify\n          gates:\n            - type: workflow-succeeded\n              config: { workflow: openspec-tasks-verify }\n        - name: fail\n          to: implementing\n          gates:\n            - type: evidence-recorded\n              config: { name: tasks-verify-run, requireField: { status: failed } }\n\n    - id: pre-pr-verify\n      description: >-\n        Pre-PR verification: build/synth/test/lint plus the architecture\n        rule registry, run before the PR is opened rather than relying on\n        CI after the fact. If the bound commit needs to change (rebase,\n        fixup, human-requested edit) without a real verification failure,\n        take the ungated 'rework' transition back to implementing instead\n        of recording a fabricated 'fail'.\n      work:\n        mode: workflow\n        workflow:\n          name: pre-pr-verify\n          inputs:\n            commit: '\\${{ data.latest(self.name, \"evidence-change-request\").payload.headSha }}'\n            branch: '\\${{ data.latest(self.name, \"evidence-change-request\").payload.branch }}'\n        resultEvidence: verify-run\n      transitions:\n        - name: pass\n          to: open-pr\n          gates:\n            - type: workflow-succeeded\n              config: { workflow: pre-pr-verify }\n        - name: fail\n          to: implementing\n          gates:\n            - type: evidence-recorded\n              config: { name: verify-run, requireField: { status: failed } }\n        - name: rework\n          to: implementing\n          gates: []\n\n    - id: open-pr\n      description: >-\n        Open the pull request now that pre-PR verification has passed. If\n        the bound commit needs to change after entering this stage (e.g.\n        main moved and the branch needs a rebase), a human can approve the\n        'rework-approval' gate to take the 'rework' transition back to\n        implementing rather than aborting the run.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Before opening the PR, fetch the real pre-pr-verify attestation\n          with \\`swamp data get --workflow pre-pr-verify\n          report-swamp-verification-attestation --json\\` and include its\n          \\`content\\` verbatim (as a markdown block, e.g. under a \"Pre-PR\n          verification\" heading) in the PR body — never just assert in\n          prose that checks passed. Also fetch this same run's manifest step\n          output (\\`swamp data query 'modelName == \"${shellManifestModel}\" &&\n          name == \"result\"' --select attributes.stdout --json\\`, take the\n          latest) and append it to the PR body as\n          \\`<!-- attestation-manifest {\"commit\": \"<headSha>\", \"status\":\n          \"succeeded\", ...the manifest step's JSON, spread in...} -->\\` — an\n          HTML comment so it's invisible when rendered but still present in\n          the raw body text verify-attestation.yml reads via the GitHub API.\n          Also fetch the plan artifact's changeSlug and include an explicit\n          \"OpenSpec change\" line in the PR body naming it and its path\n          (\\`openspec/changes/<changeSlug>/\\`) — every PR the factory opens\n          must call out which OpenSpec change(s) drove the session, not\n          just imply it. If planning cycled through more than one change\n          (a rework loop produced a new changeSlug), list every distinct\n          changeSlug recorded across the run's plan artifact versions, not\n          only the latest. The PR title MUST start with a Conventional\n          Commits prefix in the form \\`type(scope): summary\\` — \\`type\\` is\n          \\`feat\\` for new capabilities, \\`fix\\` for bug fixes, or \\`chore\\`\n          for tooling/maintenance with no behavior change (fall back to\n          \\`refactor\\`/\\`docs\\`/\\`test\\` only if none of those fit), chosen\n          from the intake issue and OpenSpec change(s); \\`scope\\` names the\n          affected package (e.g. \\`projen\\`, \\`clerk-authorizer\\`). This\n          repo's PR-deploy and PR-cleanup automation only trigger for\n          titles starting with \\`fix\\` or \\`feat\\`, and every merged PR in\n          this repo follows this convention — an untyped title breaks both.\n          Then call ${prModel}'s openPr method\n          (repo=${repo}, head=<the branch recorded in\n          change-request evidence>, base=${baseBranch}, dryRun=false), with\n          title/body referencing the intake stage's issue number, the\n          OpenSpec change(s), the attestation block, and the manifest\n          comment, then record the pr-opened evidence with the returned PR\n          url and number.\n      evidence:\n        - name: pr-opened\n          schema:\n            type: object\n            required: [url, number]\n            properties:\n              url: { type: string, minLength: 1 }\n              number: { type: integer }\n      transitions:\n        - name: submit\n          to: done\n          gates:\n            - type: evidence-recorded\n              config: { name: pr-opened }\n        - name: rework\n          to: implementing\n          gates:\n            - type: human-approval\n              config: { id: rework-approval }\n\n    - id: done\n      terminal: true\n\n    - id: aborted\n      terminal: true\n\n  globalTransitions:\n    - name: abort\n      to: aborted\n      gates:\n        - type: human-approval\n          config: { id: abort-confirmation }\nmethods: {}\n`,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryModels.js","sourceRoot":"","sources":["../src/SoftwareFactoryModels.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AACpC,mCAAoC;AAqBpC;;;;;GAKG;AACH,MAAa,qBAAqB;IAChC,YAAY,OAAoB,EAAE,OAAqC;QACrE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QACtD,MAAM,IAAI,GAAG,GAAG,WAAW,IAAI,QAAQ,EAAE,CAAC;QAC1C,MAAM,WAAW,GAAG,GAAG,QAAQ,SAAS,CAAC;QACzC,MAAM,OAAO,GAAG,GAAG,QAAQ,KAAK,CAAC;QACjC,MAAM,UAAU,GAAG,GAAG,QAAQ,QAAQ,CAAC;QACvC,MAAM,sBAAsB,GAAG,GAAG,QAAQ,qBAAqB,CAAC;QAChE,MAAM,kBAAkB,GAAG,GAAG,QAAQ,iBAAiB,CAAC;QACxD,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAC3C,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAE3C,IAAI,mBAAU,CAAC,OAAO,EAAE,4BAA4B,OAAO,OAAO,EAAE;YAClE,QAAQ,EAAE;;MAEV,IAAA,mBAAU,GAAE;QACV,OAAO;;;;2BAIY,YAAY;WAC5B,WAAW;;CAErB;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,2BAA2B,WAAW,OAAO,EAAE;YACrE,QAAQ,EAAE;;MAEV,IAAA,mBAAU,GAAE;QACV,WAAW;;;;;CAKlB;SACI,CAAC,CAAC;QAEH,KAAK,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE,sBAAsB,EAAE,kBAAkB,CAAC,EAAE,CAAC;YAC5E,IAAI,mBAAU,CAAC,OAAO,EAAE,wBAAwB,IAAI,OAAO,EAAE;gBAC3D,QAAQ,EAAE;;MAEZ,IAAA,mBAAU,GAAE;QACV,IAAI;;;;;CAKX;aACM,CAAC,CAAC;QACL,CAAC;QAED,IAAI,mBAAU,CAAC,OAAO,EAAE,kCAAkC,YAAY,OAAO,EAAE;YAC7E,QAAQ,EAAE;;MAEV,IAAA,mBAAU,GAAE;QACV,YAAY;;;;;;;;;;;;;;;;;;YAkBR,IAAI,cAAc,WAAW;;YAE7B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDA4L+B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;sBAwBlD,OAAO;kBACX,IAAI;2CACqB,UAAU;;;;;;;;;;;gDAWL,UAAU;YAC9C,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCf;SACI,CAAC,CAAC;IACL,CAAC;CACF;AAzVD,sDAyVC","sourcesContent":["import { randomUUID } from 'crypto';\nimport { SampleFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\nexport interface SoftwareFactoryModelsOptions {\n  /**\n   * The bare repo name (e.g. `expense-tracker`), used to derive model names\n   * like `<repoName>-factory`, `<repoName>-shell`, `<repoName>-secrets`.\n   */\n  readonly repoName: string;\n\n  /**\n   * The GitHub org the repo lives in.\n   */\n  readonly githubOwner: string;\n\n  /**\n   * The branch the factory opens pull requests against.\n   */\n  readonly baseBranch: string;\n}\n\n/**\n * Seed swamp model instances wiring the `@swamp/software-factory` state\n * machine to this repo's GitHub issues/PRs and shell steps. These are\n * `SampleFile`s (written once, then owned by the team) since the factory's\n * stages/gates are the kind of thing a team tunes for its own workflow.\n */\nexport class SoftwareFactoryModels {\n  constructor(project: NodeProject, options: SoftwareFactoryModelsOptions) {\n    const { repoName, githubOwner, baseBranch } = options;\n    const repo = `${githubOwner}/${repoName}`;\n    const issuesModel = `${repoName}-issues`;\n    const prModel = `${repoName}-pr`;\n    const shellModel = `${repoName}-shell`;\n    const shellArchitectureModel = `${repoName}-shell-architecture`;\n    const shellManifestModel = `${repoName}-shell-manifest`;\n    const secretsVault = `${repoName}-secrets`;\n    const factoryModel = `${repoName}-factory`;\n\n    new SampleFile(project, `models/@goodcraft/github/${prModel}.yaml`, {\n      contents: `type: '@goodcraft/github'\ntypeVersion: 2026.06.14.1\nid: ${randomUUID()}\nname: ${prModel}\nversion: 1\ntags: {}\nglobalArguments:\n  token: '\\${{ vault.get(${secretsVault}, GITHUB_TOKEN) }}'\n  owner: ${githubOwner}\nmethods: {}\n`,\n    });\n\n    new SampleFile(project, `models/@webframp/github/${issuesModel}.yaml`, {\n      contents: `type: '@webframp/github'\ntypeVersion: 2026.08.28.1\nid: ${randomUUID()}\nname: ${issuesModel}\nversion: 1\ntags: {}\nglobalArguments: {}\nmethods: {}\n`,\n    });\n\n    for (const name of [shellModel, shellArchitectureModel, shellManifestModel]) {\n      new SampleFile(project, `models/command/shell/${name}.yaml`, {\n        contents: `type: command/shell\ntypeVersion: 2026.02.09.1\nid: ${randomUUID()}\nname: ${name}\nversion: 1\ntags: {}\nglobalArguments: {}\nmethods: {}\n`,\n      });\n    }\n\n    new SampleFile(project, `models/@swamp/software-factory/${factoryModel}.yaml`, {\n      contents: `type: '@swamp/software-factory'\ntypeVersion: 2026.06.24.1\nid: ${randomUUID()}\nname: ${factoryModel}\nversion: 1\ntags: {}\nreports:\n  require:\n    - name: \"@swamp/software-factory/work-item-summary\"\n      methods: [summary]\nglobalArguments:\n  stages:\n    - id: intake\n      initial: true\n      description: >-\n        Fetch the GitHub issue for this work item (workItem is the bare\n        issue number) and record its context.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Fetch the GitHub issue numbered \\${{ self.workItem }} for\n          ${repo} using the ${issuesModel} model\n          (list_issues, then swamp data query filtered by number — see the\n          ${issuesModel} data), and record the issue-context artifact.\n      artifacts:\n        - name: issue-context\n          schema:\n            type: object\n            required: [number, title, url]\n            properties:\n              number: { type: integer }\n              title: { type: string, minLength: 1 }\n              body: { type: string }\n              url: { type: string, minLength: 1 }\n              labels: { type: array, items: { type: string } }\n      transitions:\n        - name: submit\n          to: planning\n          gates:\n            - type: artifact-exists\n              config: { artifact: issue-context }\n\n    - id: planning\n      description: >-\n        Turn the issue into a real OpenSpec change (proposal, design,\n        specs, tasks) — OpenSpec's task list is the plan, not a\n        freeform artifact.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Using the recorded issue-context artifact, use the\n          openspec-propose skill to create a complete OpenSpec change\n          (proposal.md, design.md, specs with deltas, tasks.md) for this\n          work item under openspec/changes/<changeSlug>/ — do not write a\n          freeform plan instead of this. Then record the plan artifact\n          with the change's slug and a one-line summary.\n      artifacts:\n        - name: plan\n          schema:\n            type: object\n            required: [changeSlug, summary]\n            properties:\n              changeSlug: { type: string, minLength: 1 }\n              summary: { type: string, minLength: 1 }\n      transitions:\n        - name: submit\n          to: openspec-plan-verify\n          gates:\n            - type: artifact-exists\n              config: { artifact: plan }\n\n    - id: openspec-plan-verify\n      description: >-\n        Verify the OpenSpec change is real and well-formed (not just an\n        artifact claiming one exists) before implementation starts. Requires\n        a human to approve the 'implementation-approval' gate before\n        advancing to implementing. A reject on that gate doesn't dead-end\n        the run — take the ungated 'rework' transition back to planning to\n        produce a revised plan and ask again.\n      work:\n        mode: workflow\n        workflow:\n          name: openspec-plan-verify\n          inputs:\n            changeSlug: '\\${{ data.latest(self.name, \"artifact-plan\").payload.changeSlug }}'\n        resultEvidence: plan-verify-run\n      transitions:\n        - name: pass\n          to: implementing\n          gates:\n            - type: workflow-succeeded\n              config: { workflow: openspec-plan-verify }\n            - type: human-approval\n              config: { id: implementation-approval }\n        - name: fail\n          to: planning\n          gates:\n            - type: evidence-recorded\n              config: { name: plan-verify-run, requireField: { status: failed } }\n        - name: rework\n          to: planning\n          gates: []\n\n    - id: implementing\n      description: Implement the OpenSpec change's tasks on a branch.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Use the openspec-apply-change skill against the change recorded\n          in the plan artifact's changeSlug — work through its tasks.md\n          one task at a time, checking each off (\\`- [ ]\\` -> \\`- [x]\\`) as\n          you complete it, until every task is done. Commit the work on a\n          feature branch. Record the change-summary artifact and the\n          change-request evidence (branch name and head commit sha — no\n          PR yet, that happens after pre-PR verification passes).\n      artifacts:\n        - name: change-summary\n          schema:\n            type: object\n            required: [summary, headSha]\n            properties:\n              summary: { type: string, minLength: 1 }\n              headSha: { type: string, minLength: 7 }\n      evidence:\n        - name: change-request\n          schema:\n            type: object\n            required: [branch, headSha]\n            properties:\n              branch: { type: string, minLength: 1 }\n              headSha: { type: string, minLength: 7 }\n              url: { type: string }\n      transitions:\n        - name: submit\n          to: openspec-tasks-verify\n          gates:\n            - type: artifact-exists\n              config: { artifact: change-summary }\n            - type: evidence-recorded\n              config: { name: change-request }\n\n    - id: openspec-tasks-verify\n      description: >-\n        Verify every task in the OpenSpec change is actually checked off\n        before pre-PR verification runs.\n      work:\n        mode: workflow\n        workflow:\n          name: openspec-tasks-verify\n          inputs:\n            changeSlug: '\\${{ data.latest(self.name, \"artifact-plan\").payload.changeSlug }}'\n        resultEvidence: tasks-verify-run\n      transitions:\n        - name: pass\n          to: pre-pr-verify\n          gates:\n            - type: workflow-succeeded\n              config: { workflow: openspec-tasks-verify }\n        - name: fail\n          to: implementing\n          gates:\n            - type: evidence-recorded\n              config: { name: tasks-verify-run, requireField: { status: failed } }\n\n    - id: pre-pr-verify\n      description: >-\n        Pre-PR verification: build/synth/test/lint plus the architecture\n        rule registry, run before the PR is opened rather than relying on\n        CI after the fact. If the bound commit needs to change (rebase,\n        fixup, human-requested edit) without a real verification failure,\n        take the ungated 'rework' transition back to implementing instead\n        of recording a fabricated 'fail'.\n      work:\n        mode: workflow\n        workflow:\n          name: pre-pr-verify\n          inputs:\n            commit: '\\${{ data.latest(self.name, \"evidence-change-request\").payload.headSha }}'\n            branch: '\\${{ data.latest(self.name, \"evidence-change-request\").payload.branch }}'\n        resultEvidence: verify-run\n      transitions:\n        - name: pass\n          to: open-pr\n          gates:\n            - type: workflow-succeeded\n              config: { workflow: pre-pr-verify }\n        - name: fail\n          to: implementing\n          gates:\n            - type: evidence-recorded\n              config: { name: verify-run, requireField: { status: failed } }\n        - name: rework\n          to: implementing\n          gates: []\n\n    - id: open-pr\n      description: >-\n        Open the pull request now that pre-PR verification has passed. If\n        the bound commit needs to change after entering this stage (e.g.\n        main moved and the branch needs a rebase), a human can approve the\n        'rework-approval' gate to take the 'rework' transition back to\n        implementing rather than aborting the run.\n      work:\n        mode: interactive\n        systemPrompt: >-\n          Before opening the PR, fetch the real pre-pr-verify attestation\n          with \\`swamp data get --workflow pre-pr-verify\n          report-swamp-verification-attestation --json\\` and include its\n          \\`content\\` verbatim (as a markdown block, e.g. under a \"Pre-PR\n          verification\" heading) in the PR body — never just assert in\n          prose that checks passed. Also fetch this same run's manifest step\n          output (\\`swamp data query 'modelName == \"${shellManifestModel}\" &&\n          name == \"result\"' --select attributes.stdout --json\\`, take the\n          latest) and append it to the PR body as\n          \\`<!-- attestation-manifest {\"commit\": \"<headSha>\", \"status\":\n          \"succeeded\", ...the manifest step's JSON, spread in...} -->\\` — an\n          HTML comment so it's invisible when rendered but still present in\n          the raw body text verify-attestation.yml reads via the GitHub API.\n          Also fetch the plan artifact's changeSlug and include an explicit\n          \"OpenSpec change\" line in the PR body naming it and its path\n          (\\`openspec/changes/<changeSlug>/\\`) — every PR the factory opens\n          must call out which OpenSpec change(s) drove the session, not\n          just imply it. If planning cycled through more than one change\n          (a rework loop produced a new changeSlug), list every distinct\n          changeSlug recorded across the run's plan artifact versions, not\n          only the latest. The PR title MUST start with a Conventional\n          Commits prefix in the form \\`type(scope): summary\\` — \\`type\\` is\n          \\`feat\\` for new capabilities, \\`fix\\` for bug fixes, or \\`chore\\`\n          for tooling/maintenance with no behavior change (fall back to\n          \\`refactor\\`/\\`docs\\`/\\`test\\` only if none of those fit), chosen\n          from the intake issue and OpenSpec change(s); \\`scope\\` names the\n          affected package (e.g. \\`projen\\`, \\`clerk-authorizer\\`). This\n          repo's PR-deploy and PR-cleanup automation only trigger for\n          titles starting with \\`fix\\` or \\`feat\\`, and every merged PR in\n          this repo follows this convention — an untyped title breaks both.\n          Then call ${prModel}'s openPr method\n          (repo=${repo}, head=<the branch recorded in\n          change-request evidence>, base=${baseBranch}, dryRun=false), with\n          title/body referencing the intake stage's issue number, the\n          OpenSpec change(s), the attestation block, and the manifest\n          comment. If openPr fails specifically because the vault can't\n          resolve GITHUB_TOKEN (an error naming \\`GITHUB_TOKEN\\` as not\n          found), don't treat that as terminal — fall back to opening the\n          PR via the \\`gh\\` CLI instead: push the branch recorded in\n          change-request evidence with \\`git push -u origin <branch>\\` if it\n          isn't already pushed, write the exact same title and body\n          (attestation block, manifest comment, and OpenSpec change\n          line(s) included) to a temp file, and run \\`gh pr create --title\n          \"<title>\" --body-file <path> --base ${baseBranch} --head <branch> --repo\n          ${repo}\\`. Any other openPr failure\n          (bad arguments, network, permissions) MUST still be surfaced as\n          a real failure, not papered over with this fallback. Then record\n          the pr-opened evidence with the returned PR url and number —\n          from openPr's response on the primary path, or by parsing \\`gh pr\n          create\\`'s output (or a follow-up \\`gh pr view <branch> --json\n          number,url\\`) on the fallback path.\n      evidence:\n        - name: pr-opened\n          schema:\n            type: object\n            required: [url, number]\n            properties:\n              url: { type: string, minLength: 1 }\n              number: { type: integer }\n      transitions:\n        - name: submit\n          to: done\n          gates:\n            - type: evidence-recorded\n              config: { name: pr-opened }\n        - name: rework\n          to: implementing\n          gates:\n            - type: human-approval\n              config: { id: rework-approval }\n\n    - id: done\n      terminal: true\n\n    - id: aborted\n      terminal: true\n\n  globalTransitions:\n    - name: abort\n      to: aborted\n      gates:\n        - type: human-approval\n          config: { id: abort-confirmation }\nmethods: {}\n`,\n    });\n  }\n}\n"]}

package/lib/StagingDeployWorkflow.js

@@ -7,7 +7,7 @@ const javascript_1 = require("projen/lib/javascript");
 const utils_1 = require("./utils");
 const WorkflowActionVersions_1 = require("./WorkflowActionVersions");
 class StagingDeployWorkflow extends projen_1.YamlFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.StagingDeployWorkflow", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.StagingDeployWorkflow", version: "1.25.0" };
     constructor(project, options) {
         const packageManager = project.package.packageManager;
         const actionVersions = (0, WorkflowActionVersions_1.resolveActionVersions)(options.actionVersions);

package/lib/WorkflowAutoDiscover.js

@@ -39,7 +39,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const projen_1 = require("projen");
 class WorkflowAutoDiscover extends projen_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.WorkflowAutoDiscover", version: "1.24.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.WorkflowAutoDiscover", version: "1.25.0" };
     constructor(project) {
         super(project);
     }

package/models/@swamp/software-factory/platform-common-factory.yaml

@@ -238,8 +238,22 @@ globalArguments:
           change-request evidence>, base=main, dryRun=false), with
           title/body referencing the intake stage's issue number, the
           OpenSpec change(s), the attestation block, and the manifest
-          comment, then record the pr-opened evidence with the returned PR
-          url and number.
+          comment. If openPr fails specifically because the vault can't
+          resolve GITHUB_TOKEN (an error naming `GITHUB_TOKEN` as not
+          found), don't treat that as terminal — fall back to opening the
+          PR via the `gh` CLI instead: push the branch recorded in
+          change-request evidence with `git push -u origin <branch>` if it
+          isn't already pushed, write the exact same title and body
+          (attestation block, manifest comment, and OpenSpec change
+          line(s) included) to a temp file, and run `gh pr create --title
+          "<title>" --body-file <path> --base main --head <branch> --repo
+          macedon-technologies/platform-common`. Any other openPr failure
+          (bad arguments, network, permissions) MUST still be surfaced as
+          a real failure, not papered over with this fallback. Then record
+          the pr-opened evidence with the returned PR url and number —
+          from openPr's response on the primary path, or by parsing `gh pr
+          create`'s output (or a follow-up `gh pr view <branch> --json
+          number,url`) on the fallback path.
       evidence:
         - name: pr-opened
           schema:

package/package.json

@@ -49,7 +49,7 @@
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "stability": "stable",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [