@macedon-technologies/batman 1.17.2 → 1.18.0

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);
+}