@macedon-technologies/batman 1.17.3 → 1.18.0

package/lib/SoftwareFactoryFiles.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryFiles = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const SoftwareFactoryArchitectureRules_1 = require("./SoftwareFactoryArchitectureRules");
+const SoftwareFactoryAttestation_1 = require("./SoftwareFactoryAttestation");
+const SoftwareFactoryModels_1 = require("./SoftwareFactoryModels");
+const SoftwareFactoryOpenSpecGates_1 = require("./SoftwareFactoryOpenSpecGates");
+const SoftwareFactoryWorkflows_1 = require("./SoftwareFactoryWorkflows");
+const GITHUB_OWNER = 'macedon-technologies';
+/**
+ * Backports exman's swamp "software factory" pattern
+ * (macedon-technologies/exman#13) as generated scaffolding: a
+ * `@swamp/software-factory` state machine that drives a GitHub issue from
+ * intake through an opened PR, enforcing OpenSpec usage, an architecture
+ * rule registry, and a pre-PR verification gate whose attestation is
+ * re-checked at merge time.
+ *
+ * What swamp itself would generate (extension docs pulled via
+ * `swamp extension pull`, `.swamp.yaml`, the vault, and the "swamp managed
+ * section" in CLAUDE.md) is deliberately NOT hand-templated here — those are
+ * produced by the real `swamp` CLI. `swamp init` is idempotent (a no-op if
+ * the repo is already initialized), so it's wired into the project's
+ * `install`/`install:ci` tasks and runs automatically on every install,
+ * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.
+ * CI). The extension pulls and vault creation are one-time, not idempotent
+ * in a way that's safe to repeat on every install, so they stay in the
+ * `swamp:bootstrap` task this construct adds. Only exman's own authored
+ * config (the factory's state machine, the architecture-rule engine, the
+ * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp
+ * workflows that wire them together) is templated.
+ */
+class SoftwareFactoryFiles {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.18.0" };
+    constructor(project, options) {
+        const { repoName, actionVersions } = options;
+        const baseBranch = options.baseBranch || 'main';
+        const secretsVault = `${repoName}-secrets`;
+        // A single redirect only: projen's built-in cross-platform task shell
+        // (dax) rejects a command with more than one redirect (e.g. combining
+        // `>/dev/null` with `2>&1`) with "Multiple redirects are currently not
+        // supported" — confirmed by dogfooding this construct on this very repo.
+        const swampInitStep = 'command -v swamp >/dev/null && swamp init --tool claude || true';
+        new SoftwareFactoryModels_1.SoftwareFactoryModels(project, {
+            repoName,
+            githubOwner: GITHUB_OWNER,
+            baseBranch,
+        });
+        new SoftwareFactoryArchitectureRules_1.SoftwareFactoryArchitectureRules(project);
+        new SoftwareFactoryAttestation_1.SoftwareFactoryAttestation(project, { repoName });
+        new SoftwareFactoryOpenSpecGates_1.SoftwareFactoryOpenSpecGates(project);
+        new SoftwareFactoryWorkflows_1.SoftwareFactoryWorkflows(project, { repoName, actionVersions });
+        project.addTask('validate:architecture', {
+            description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',
+            exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',
+        });
+        project.addTask('openspec:check-tasks-complete', {
+            description: 'Fail unless every task in the named OpenSpec change is complete (usage: -- <change-slug>)',
+            exec: 'ts-node --project openspec-gates/tsconfig.json openspec-gates/check-tasks-complete.ts',
+            receiveArgs: true,
+        });
+        project.addTask('attestation:manifest', {
+            description: 'Print SHA256 checksums of the files a PR attestation is verified against (see attestation/manifest.ts)',
+            exec: 'ts-node --project attestation/tsconfig.json attestation/manifest.ts',
+        });
+        project.addTask('attestation:verify', {
+            description: 'Verify a PR\'s embedded attestation-manifest against the current checkout (usage: -- --body-file <path> --commit <sha>)',
+            exec: 'ts-node --project attestation/tsconfig.json attestation/verify.ts',
+            receiveArgs: true,
+        });
+        project.addTask('swamp:bootstrap', {
+            description: 'One-time setup: pull the software-factory/github extensions and create the secrets vault (swamp init itself already runs on every install)',
+            steps: [
+                { exec: 'swamp extension pull @swamp/software-factory' },
+                { exec: 'swamp extension pull @webframp/github' },
+                { exec: 'swamp extension pull @goodcraft/github' },
+                { exec: `swamp vault create local_encryption ${secretsVault}` },
+                {
+                    exec: `echo "Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'"`,
+                },
+            ],
+        });
+        // `swamp init` is safe to re-run (idempotent when already initialized),
+        // so every install keeps the repo initialized without a separate manual
+        // step — including on a fresh clone that hasn't run swamp:bootstrap yet.
+        project.package.installTask.exec(swampInitStep);
+        project.package.installCiTask.exec(swampInitStep);
+        // Mirrors the patterns `swamp init` itself would append to .gitignore.
+        // projen's IgnoreFile fully regenerates .gitignore from its own tracked
+        // entries on every synth, so anything `swamp init` appends out-of-band
+        // gets silently wiped by the next `npx projen` run (caught by CI's
+        // self-mutation check) unless it's also added here.
+        project.addGitIgnore('.swamp/');
+        project.addGitIgnore('.swamp-sources.yaml');
+        project.addGitIgnore('.claude/worktrees/');
+        project.addGitIgnore('.claude/settings.local.json');
+        project.addGitIgnore('.claude/scheduled_tasks.lock');
+        project.addGitIgnore('.claude/scheduled_tasks.json');
+    }
+}
+exports.SoftwareFactoryFiles = SoftwareFactoryFiles;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryFiles.js","sourceRoot":"","sources":["../src/SoftwareFactoryFiles.ts"],"names":[],"mappings":";;;;AACA,yFAAsF;AACtF,6EAA0E;AAC1E,mEAAgE;AAChE,iFAA8E;AAC9E,yEAAsE;AAGtE,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAuB5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,oBAAoB;;IAC/B,YAAY,OAAoB,EAAE,OAAoC;QACpE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAC7C,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,MAAM,CAAC;QAChD,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAC3C,sEAAsE;QACtE,sEAAsE;QACtE,uEAAuE;QACvE,yEAAyE;QACzE,MAAM,aAAa,GAAG,iEAAiE,CAAC;QAExF,IAAI,6CAAqB,CAAC,OAAO,EAAE;YACjC,QAAQ;YACR,WAAW,EAAE,YAAY;YACzB,UAAU;SACX,CAAC,CAAC;QAEH,IAAI,mEAAgC,CAAC,OAAO,CAAC,CAAC;QAE9C,IAAI,uDAA0B,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEtD,IAAI,2DAA4B,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,mDAAwB,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC;QAEpE,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE;YACvC,WAAW,EAAE,qFAAqF;YAClG,IAAI,EAAE,gFAAgF;SACvF,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,+BAA+B,EAAE;YAC/C,WAAW,EAAE,2FAA2F;YACxG,IAAI,EAAE,uFAAuF;YAC7F,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,sBAAsB,EAAE;YACtC,WAAW,EAAE,wGAAwG;YACrH,IAAI,EAAE,qEAAqE;SAC5E,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE;YACpC,WAAW,EAAE,yHAAyH;YACtI,IAAI,EAAE,mEAAmE;YACzE,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;YACjC,WAAW,EAAE,4IAA4I;YACzJ,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,8CAA8C,EAAE;gBACxD,EAAE,IAAI,EAAE,uCAAuC,EAAE;gBACjD,EAAE,IAAI,EAAE,wCAAwC,EAAE;gBAClD,EAAE,IAAI,EAAE,uCAAuC,YAAY,EAAE,EAAE;gBAC/D;oBACE,IAAI,EAAE,+BAA+B,YAAY,+CAA+C;iBACjG;aACF;SACF,CAAC,CAAC;QAEH,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAChD,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAElD,uEAAuE;QACvE,wEAAwE;QACxE,uEAAuE;QACvE,mEAAmE;QACnE,oDAAoD;QACpD,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAC5C,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QAC3C,OAAO,CAAC,YAAY,CAAC,6BAA6B,CAAC,CAAC;QACpD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;QACrD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;IACvD,CAAC;;AA7EH,oDA8EC","sourcesContent":["import { NodeProject } from 'projen/lib/javascript';\nimport { SoftwareFactoryArchitectureRules } from './SoftwareFactoryArchitectureRules';\nimport { SoftwareFactoryAttestation } from './SoftwareFactoryAttestation';\nimport { SoftwareFactoryModels } from './SoftwareFactoryModels';\nimport { SoftwareFactoryOpenSpecGates } from './SoftwareFactoryOpenSpecGates';\nimport { SoftwareFactoryWorkflows } from './SoftwareFactoryWorkflows';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nconst GITHUB_OWNER = 'macedon-technologies';\n\nexport interface SoftwareFactoryFilesOptions {\n  /**\n   * The bare repo name (e.g. `expense-tracker`), used to derive the factory's\n   * model names (`<repoName>-factory`, `<repoName>-issues`, `<repoName>-pr`,\n   * `<repoName>-shell*`) and vault name (`<repoName>-secrets`).\n   */\n  readonly repoName: string;\n\n  /**\n   * The branch the factory opens pull requests against.\n   *\n   * @default 'main'\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * Overrides for the pinned action versions used by `verify-attestation.yml`.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n}\n\n/**\n * Backports exman's swamp \"software factory\" pattern\n * (macedon-technologies/exman#13) as generated scaffolding: a\n * `@swamp/software-factory` state machine that drives a GitHub issue from\n * intake through an opened PR, enforcing OpenSpec usage, an architecture\n * rule registry, and a pre-PR verification gate whose attestation is\n * re-checked at merge time.\n *\n * What swamp itself would generate (extension docs pulled via\n * `swamp extension pull`, `.swamp.yaml`, the vault, and the \"swamp managed\n * section\" in CLAUDE.md) is deliberately NOT hand-templated here — those are\n * produced by the real `swamp` CLI. `swamp init` is idempotent (a no-op if\n * the repo is already initialized), so it's wired into the project's\n * `install`/`install:ci` tasks and runs automatically on every install,\n * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.\n * CI). The extension pulls and vault creation are one-time, not idempotent\n * in a way that's safe to repeat on every install, so they stay in the\n * `swamp:bootstrap` task this construct adds. Only exman's own authored\n * config (the factory's state machine, the architecture-rule engine, the\n * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp\n * workflows that wire them together) is templated.\n */\nexport class SoftwareFactoryFiles {\n  constructor(project: NodeProject, options: SoftwareFactoryFilesOptions) {\n    const { repoName, actionVersions } = options;\n    const baseBranch = options.baseBranch || 'main';\n    const secretsVault = `${repoName}-secrets`;\n    // A single redirect only: projen's built-in cross-platform task shell\n    // (dax) rejects a command with more than one redirect (e.g. combining\n    // `>/dev/null` with `2>&1`) with \"Multiple redirects are currently not\n    // supported\" — confirmed by dogfooding this construct on this very repo.\n    const swampInitStep = 'command -v swamp >/dev/null && swamp init --tool claude || true';\n\n    new SoftwareFactoryModels(project, {\n      repoName,\n      githubOwner: GITHUB_OWNER,\n      baseBranch,\n    });\n\n    new SoftwareFactoryArchitectureRules(project);\n\n    new SoftwareFactoryAttestation(project, { repoName });\n\n    new SoftwareFactoryOpenSpecGates(project);\n\n    new SoftwareFactoryWorkflows(project, { repoName, actionVersions });\n\n    project.addTask('validate:architecture', {\n      description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',\n      exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',\n    });\n\n    project.addTask('openspec:check-tasks-complete', {\n      description: 'Fail unless every task in the named OpenSpec change is complete (usage: -- <change-slug>)',\n      exec: 'ts-node --project openspec-gates/tsconfig.json openspec-gates/check-tasks-complete.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('attestation:manifest', {\n      description: 'Print SHA256 checksums of the files a PR attestation is verified against (see attestation/manifest.ts)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/manifest.ts',\n    });\n\n    project.addTask('attestation:verify', {\n      description: 'Verify a PR\\'s embedded attestation-manifest against the current checkout (usage: -- --body-file <path> --commit <sha>)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/verify.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('swamp:bootstrap', {\n      description: 'One-time setup: pull the software-factory/github extensions and create the secrets vault (swamp init itself already runs on every install)',\n      steps: [\n        { exec: 'swamp extension pull @swamp/software-factory' },\n        { exec: 'swamp extension pull @webframp/github' },\n        { exec: 'swamp extension pull @goodcraft/github' },\n        { exec: `swamp vault create local_encryption ${secretsVault}` },\n        {\n          exec: `echo \"Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'\"`,\n        },\n      ],\n    });\n\n    // `swamp init` is safe to re-run (idempotent when already initialized),\n    // so every install keeps the repo initialized without a separate manual\n    // step — including on a fresh clone that hasn't run swamp:bootstrap yet.\n    project.package.installTask.exec(swampInitStep);\n    project.package.installCiTask.exec(swampInitStep);\n\n    // Mirrors the patterns `swamp init` itself would append to .gitignore.\n    // projen's IgnoreFile fully regenerates .gitignore from its own tracked\n    // entries on every synth, so anything `swamp init` appends out-of-band\n    // gets silently wiped by the next `npx projen` run (caught by CI's\n    // self-mutation check) unless it's also added here.\n    project.addGitIgnore('.swamp/');\n    project.addGitIgnore('.swamp-sources.yaml');\n    project.addGitIgnore('.claude/worktrees/');\n    project.addGitIgnore('.claude/settings.local.json');\n    project.addGitIgnore('.claude/scheduled_tasks.lock');\n    project.addGitIgnore('.claude/scheduled_tasks.json');\n  }\n}\n"]}

package/lib/SoftwareFactoryModels.d.ts

@@ -0,0 +1,25 @@
+import { NodeProject } from 'projen/lib/javascript';
+export interface SoftwareFactoryModelsOptions {
+    /**
+     * The bare repo name (e.g. `expense-tracker`), used to derive model names
+     * like `<repoName>-factory`, `<repoName>-shell`, `<repoName>-secrets`.
+     */
+    readonly repoName: string;
+    /**
+     * The GitHub org the repo lives in.
+     */
+    readonly githubOwner: string;
+    /**
+     * The branch the factory opens pull requests against.
+     */
+    readonly baseBranch: string;
+}
+/**
+ * Seed swamp model instances wiring the `@swamp/software-factory` state
+ * machine to this repo's GitHub issues/PRs and shell steps. These are
+ * `SampleFile`s (written once, then owned by the team) since the factory's
+ * stages/gates are the kind of thing a team tunes for its own workflow.
+ */
+export declare class SoftwareFactoryModels {
+    constructor(project: NodeProject, options: SoftwareFactoryModelsOptions);
+}

package/lib/SoftwareFactoryModels.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryModels = void 0;
+const crypto_1 = require("crypto");
+const projen_1 = require("projen");
+/**
+ * Seed swamp model instances wiring the `@swamp/software-factory` state
+ * machine to this repo's GitHub issues/PRs and shell steps. These are
+ * `SampleFile`s (written once, then owned by the team) since the factory's
+ * stages/gates are the kind of thing a team tunes for its own workflow.
+ */
+class SoftwareFactoryModels {
+    constructor(project, options) {
+        const { repoName, githubOwner, baseBranch } = options;
+        const repo = `${githubOwner}/${repoName}`;
+        const issuesModel = `${repoName}-issues`;
+        const prModel = `${repoName}-pr`;
+        const shellModel = `${repoName}-shell`;
+        const shellArchitectureModel = `${repoName}-shell-architecture`;
+        const shellManifestModel = `${repoName}-shell-manifest`;
+        const secretsVault = `${repoName}-secrets`;
+        const factoryModel = `${repoName}-factory`;
+        new projen_1.SampleFile(project, `models/@goodcraft/github/${prModel}.yaml`, {
+            contents: `type: '@goodcraft/github'
+typeVersion: 2026.06.14.1
+id: ${(0, crypto_1.randomUUID)()}
+name: ${prModel}
+version: 1
+tags: {}
+globalArguments:
+  token: '\${{ vault.get(${secretsVault}, GITHUB_TOKEN) }}'
+  owner: ${githubOwner}
+methods: {}
+`,
+        });
+        new projen_1.SampleFile(project, `models/@webframp/github/${issuesModel}.yaml`, {
+            contents: `type: '@webframp/github'
+typeVersion: 2026.08.28.1
+id: ${(0, crypto_1.randomUUID)()}
+name: ${issuesModel}
+version: 1
+tags: {}
+globalArguments: {}
+methods: {}
+`,
+        });
+        for (const name of [shellModel, shellArchitectureModel, shellManifestModel]) {
+            new projen_1.SampleFile(project, `models/command/shell/${name}.yaml`, {
+                contents: `type: command/shell
+typeVersion: 2026.02.09.1
+id: ${(0, crypto_1.randomUUID)()}
+name: ${name}
+version: 1
+tags: {}
+globalArguments: {}
+methods: {}
+`,
+            });
+        }
+        new projen_1.SampleFile(project, `models/@swamp/software-factory/${factoryModel}.yaml`, {
+            contents: `type: '@swamp/software-factory'
+typeVersion: 2026.06.24.1
+id: ${(0, crypto_1.randomUUID)()}
+name: ${factoryModel}
+version: 1
+tags: {}
+reports:
+  require:
+    - name: "@swamp/software-factory/work-item-summary"
+      methods: [summary]
+globalArguments:
+  stages:
+    - id: intake
+      initial: true
+      description: >-
+        Fetch the GitHub issue for this work item (workItem is the bare
+        issue number) and record its context.
+      work:
+        mode: interactive
+        systemPrompt: >-
+          Fetch the GitHub issue numbered \${{ self.workItem }} for
+          ${repo} using the ${issuesModel} model
+          (list_issues, then swamp data query filtered by number — see the
+          ${issuesModel} data), and record the issue-context artifact.
+      artifacts:
+        - name: issue-context
+          schema:
+            type: object
+            required: [number, title, url]
+            properties:
+              number: { type: integer }
+              title: { type: string, minLength: 1 }
+              body: { type: string }
+              url: { type: string, minLength: 1 }
+              labels: { type: array, items: { type: string } }
+      transitions:
+        - name: submit
+          to: planning
+          gates:
+            - type: artifact-exists
+              config: { artifact: issue-context }
+
+    - id: planning
+      description: >-
+        Turn the issue into a real OpenSpec change (proposal, design,
+        specs, tasks) — OpenSpec's task list is the plan, not a
+        freeform artifact.
+      work:
+        mode: interactive
+        systemPrompt: >-
+          Using the recorded issue-context artifact, use the
+          openspec-propose skill to create a complete OpenSpec change
+          (proposal.md, design.md, specs with deltas, tasks.md) for this
+          work item under openspec/changes/<changeSlug>/ — do not write a
+          freeform plan instead of this. Then record the plan artifact
+          with the change's slug and a one-line summary.
+      artifacts:
+        - name: plan
+          schema:
+            type: object
+            required: [changeSlug, summary]
+            properties:
+              changeSlug: { type: string, minLength: 1 }
+              summary: { type: string, minLength: 1 }
+      transitions:
+        - name: submit
+          to: openspec-plan-verify
+          gates:
+            - type: artifact-exists
+              config: { artifact: plan }
+
+    - id: openspec-plan-verify
+      description: >-
+        Verify the OpenSpec change is real and well-formed (not just an
+        artifact claiming one exists) before implementation starts.
+      work:
+        mode: workflow
+        workflow:
+          name: openspec-plan-verify
+          inputs:
+            changeSlug: '\${{ data.latest(self.name, "artifact-plan").payload.changeSlug }}'
+        resultEvidence: plan-verify-run
+      transitions:
+        - name: pass
+          to: implementing
+          gates:
+            - type: workflow-succeeded
+              config: { workflow: openspec-plan-verify }
+        - name: fail
+          to: planning
+          gates:
+            - type: evidence-recorded
+              config: { name: plan-verify-run, requireField: { status: failed } }
+
+    - id: implementing
+      description: Implement the OpenSpec change's tasks on a branch.
+      work:
+        mode: interactive
+        systemPrompt: >-
+          Use the openspec-apply-change skill against the change recorded
+          in the plan artifact's changeSlug — work through its tasks.md
+          one task at a time, checking each off (\`- [ ]\` -> \`- [x]\`) as
+          you complete it, until every task is done. Commit the work on a
+          feature branch. Record the change-summary artifact and the
+          change-request evidence (branch name and head commit sha — no
+          PR yet, that happens after pre-PR verification passes).
+      artifacts:
+        - name: change-summary
+          schema:
+            type: object
+            required: [summary, headSha]
+            properties:
+              summary: { type: string, minLength: 1 }
+              headSha: { type: string, minLength: 7 }
+      evidence:
+        - name: change-request
+          schema:
+            type: object
+            required: [branch, headSha]
+            properties:
+              branch: { type: string, minLength: 1 }
+              headSha: { type: string, minLength: 7 }
+              url: { type: string }
+      transitions:
+        - name: submit
+          to: openspec-tasks-verify
+          gates:
+            - type: artifact-exists
+              config: { artifact: change-summary }
+            - type: evidence-recorded
+              config: { name: change-request }
+
+    - id: openspec-tasks-verify
+      description: >-
+        Verify every task in the OpenSpec change is actually checked off
+        before pre-PR verification runs.
+      work:
+        mode: workflow
+        workflow:
+          name: openspec-tasks-verify
+          inputs:
+            changeSlug: '\${{ data.latest(self.name, "artifact-plan").payload.changeSlug }}'
+        resultEvidence: tasks-verify-run
+      transitions:
+        - name: pass
+          to: pre-pr-verify
+          gates:
+            - type: workflow-succeeded
+              config: { workflow: openspec-tasks-verify }
+        - name: fail
+          to: implementing
+          gates:
+            - type: evidence-recorded
+              config: { name: tasks-verify-run, requireField: { status: failed } }
+
+    - id: pre-pr-verify
+      description: >-
+        Pre-PR verification: build/synth/test/lint plus the architecture
+        rule registry, run before the PR is opened rather than relying on
+        CI after the fact.
+      work:
+        mode: workflow
+        workflow:
+          name: pre-pr-verify
+          inputs:
+            commit: '\${{ data.latest(self.name, "evidence-change-request").payload.headSha }}'
+            branch: '\${{ data.latest(self.name, "evidence-change-request").payload.branch }}'
+        resultEvidence: verify-run
+      transitions:
+        - name: pass
+          to: open-pr
+          gates:
+            - type: workflow-succeeded
+              config: { workflow: pre-pr-verify }
+        - name: fail
+          to: implementing
+          gates:
+            - type: evidence-recorded
+              config: { name: verify-run, requireField: { status: failed } }
+
+    - id: open-pr
+      description: Open the pull request now that pre-PR verification has passed.
+      work:
+        mode: interactive
+        systemPrompt: >-
+          Before opening the PR, fetch the real pre-pr-verify attestation
+          with \`swamp data get --workflow pre-pr-verify
+          report-swamp-verification-attestation --json\` and include its
+          \`content\` verbatim (as a markdown block, e.g. under a "Pre-PR
+          verification" heading) in the PR body — never just assert in
+          prose that checks passed. Also fetch this same run's manifest step
+          output (\`swamp data query 'modelName == "${shellManifestModel}" &&
+          name == "result"' --select attributes.stdout --json\`, take the
+          latest) and append it to the PR body as
+          \`<!-- attestation-manifest {"commit": "<headSha>", "status":
+          "succeeded", ...the manifest step's JSON, spread in...} -->\` — an
+          HTML comment so it's invisible when rendered but still present in
+          the raw body text verify-attestation.yml reads via the GitHub API.
+          Also fetch the plan artifact's changeSlug and include an explicit
+          "OpenSpec change" line in the PR body naming it and its path
+          (\`openspec/changes/<changeSlug>/\`) — every PR the factory opens
+          must call out which OpenSpec change(s) drove the session, not
+          just imply it. If planning cycled through more than one change
+          (a rework loop produced a new changeSlug), list every distinct
+          changeSlug recorded across the run's plan artifact versions, not
+          only the latest. Then call ${prModel}'s openPr method
+          (repo=${repo}, head=<the branch recorded in
+          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.
+      evidence:
+        - name: pr-opened
+          schema:
+            type: object
+            required: [url, number]
+            properties:
+              url: { type: string, minLength: 1 }
+              number: { type: integer }
+      transitions:
+        - name: submit
+          to: done
+          gates:
+            - type: evidence-recorded
+              config: { name: pr-opened }
+
+    - id: done
+      terminal: true
+
+    - id: aborted
+      terminal: true
+
+  globalTransitions:
+    - name: abort
+      to: aborted
+      gates:
+        - type: human-approval
+          config: { id: abort-confirmation }
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAwK+B,kBAAkB;;;;;;;;;;;;;;uCAcjC,OAAO;kBAC5B,IAAI;2CACqB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCpD;SACI,CAAC,CAAC;IACL,CAAC;CACF;AAxSD,sDAwSC","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.\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        - name: fail\n          to: planning\n          gates:\n            - type: evidence-recorded\n              config: { name: plan-verify-run, requireField: { status: failed } }\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.\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\n    - id: open-pr\n      description: Open the pull request now that pre-PR verification has passed.\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. 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\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/SoftwareFactoryOpenSpecGates.d.ts

@@ -0,0 +1,8 @@
+import { NodeProject } from 'projen/lib/javascript';
+/**
+ * Deterministic gate: fails unless every task in the named OpenSpec change's
+ * tasks.md is checked off. Fully generic — no per-repo parameterization.
+ */
+export declare class SoftwareFactoryOpenSpecGates {
+    constructor(project: NodeProject);
+}

package/lib/SoftwareFactoryOpenSpecGates.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryOpenSpecGates = void 0;
+const projen_1 = require("projen");
+/**
+ * Deterministic gate: fails unless every task in the named OpenSpec change's
+ * tasks.md is checked off. Fully generic — no per-repo parameterization.
+ */
+class SoftwareFactoryOpenSpecGates {
+    constructor(project) {
+        new projen_1.TextFile(project, 'openspec-gates/check-tasks-complete.ts', {
+            marker: true,
+            lines: [
+                '/**',
+                ' * Gate: fails unless every task in the named OpenSpec change\'s tasks.md is',
+                ' * checked off. `openspec validate`/`openspec status` don\'t check this (an',
+                ' * in-progress change is a normal, valid state) — this is the deterministic',
+                ' * check the pre-pr pipeline needs before letting implementation proceed.',
+                ' */',
+                "import { execFileSync } from 'node:child_process';",
+                '',
+                'interface OpenSpecChangeSummary {',
+                '  name: string;',
+                '  completedTasks: number;',
+                '  totalTasks: number;',
+                '  status: string;',
+                '}',
+                '',
+                'function main(): number {',
+                '  // pnpm\'s `-- <args>` forwarding (and projen\'s receiveArgs) can pass a',
+                '  // literal "--" through as an argv token ahead of the real argument.',
+                "  const slug = process.argv.slice(2).find((arg) => arg !== '--');",
+                '  if (!slug) {',
+                "    console.error('Usage: check-tasks-complete <change-slug>');",
+                '    return 1;',
+                '  }',
+                '',
+                "  const raw = execFileSync('openspec', ['list', '--json'], { encoding: 'utf8' });",
+                '  const { changes } = JSON.parse(raw) as { changes: OpenSpecChangeSummary[] };',
+                '  const change = changes.find((c) => c.name === slug);',
+                '',
+                '  if (!change) {',
+                '    console.error(`OpenSpec change "${slug}" not found (openspec list --json)`);',
+                '    return 1;',
+                '  }',
+                "  if (change.status !== 'complete') {",
+                '    console.error(',
+                '      `OpenSpec change "${slug}" has incomplete tasks: ${change.completedTasks}/${change.totalTasks}`,',
+                '    );',
+                '    return 1;',
+                '  }',
+                '',
+                '  console.log(`OpenSpec change "${slug}": all ${change.totalTasks} tasks complete`);',
+                '  return 0;',
+                '}',
+                '',
+                'process.exit(main());',
+            ],
+        });
+        new projen_1.JsonFile(project, 'openspec-gates/tsconfig.json', {
+            marker: false,
+            obj: {
+                extends: '../tsconfig.json',
+                compilerOptions: {
+                    noEmit: true,
+                    rootDir: '.',
+                },
+                include: ['*.ts'],
+                exclude: ['node_modules'],
+            },
+        });
+    }
+}
+exports.SoftwareFactoryOpenSpecGates = SoftwareFactoryOpenSpecGates;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SoftwareFactoryWorkflows.d.ts

@@ -0,0 +1,28 @@
+import { NodeProject } from 'projen/lib/javascript';
+import { WorkflowActionVersions } from './WorkflowActionVersions';
+export interface SoftwareFactoryWorkflowsOptions {
+    /**
+     * The bare repo name, used to derive the `<repoName>-shell[-architecture|-manifest]`
+     * model names these workflows dispatch shell commands through.
+     */
+    readonly repoName: string;
+    /**
+     * Overrides for the pinned action versions used by `verify-attestation.yml`.
+     */
+    readonly actionVersions?: WorkflowActionVersions;
+}
+/**
+ * The 3 swamp workflows the factory's gate stages run (openspec-plan-verify,
+ * openspec-tasks-verify, pre-pr-verify), plus the GitHub Action that
+ * re-verifies a PR's embedded attestation at merge time.
+ *
+ * The swamp workflow YAMLs carry a swamp-assigned `id` that must stay stable
+ * across synths (swamp uses it as the workflow's identity), so — like the
+ * model instances in `SoftwareFactoryModels` — they're `SampleFile`s, written
+ * once and then owned by the team. `verify-attestation.yml` has no such
+ * identity constraint and is a plain GitHub Actions workflow, so it's built
+ * the same managed way `PrDeployWorkflow` is.
+ */
+export declare class SoftwareFactoryWorkflows {
+    constructor(project: NodeProject, options: SoftwareFactoryWorkflowsOptions);
+}