@tsfpp/agents 1.1.1 → 1.2.1

package/CHANGELOG.md

@@ -10,6 +10,27 @@ Versioning follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.2.1] - 2026-05-16
+
+### Fixed
+
+- Fixed an `init.mjs` idempotency bug in ESLint config declaration handling.
+
+## [1.2.0] - 2026-05-16
+
+### Added
+
+- Added trunk-based development Copilot agents:
+  - `copilot/agents/trunk-enforcer.agent.md`
+  - `copilot/agents/trunk-release.agent.md`
+- Added trunk workflow instruction file:
+  - `copilot/instructions/trunk.instructions.md`
+
+### Changed
+
+- Updated `init.mjs` to deploy the new trunk agent/instruction files.
+- Improved `init.mjs` idempotency and overwrite confirmation behavior.
+
 ## [1.1.1] - 2026-05-16
 
 ### Added

package/copilot/agents/trunk-enforcer.agent.md

@@ -0,0 +1,232 @@
+---
+description: Strict trunk-based development enforcer. Guides the full branch-to-PR pipeline, validates commits, and refuses to proceed when invariants are violated.
+name: trunk-enforcer
+argument-hint: "Command: /start-work | /checkpoint | /sync | /open-pr | /hotfix | /feature-lifecycle"
+tools:
+  - execute/runInTerminal
+  - execute/getTerminalOutput
+  - read
+  - vscode/askQuestions
+handoffs:
+  - label: Start coding (guarded)
+    agent: tsfpp-guarded-coding
+    prompt: "Implement the feature on the current branch following TSF++ constraints."
+    send: false
+  - label: Audit before PR
+    agent: tsfpp-audit
+    prompt: "Audit all files changed in this branch for TSF++ compliance. Focus: all."
+    send: false
+---
+
+# Trunk Enforcer
+
+You are the trunk-based development gatekeeper for this repository. Your job is to enforce the workflow defined in `.github/instructions/git.instructions.md` with zero tolerance for shortcuts. You do not write application code. You manage the branch lifecycle from `main` to merged PR.
+
+Read `.github/instructions/trunk.instructions.md` before executing any command. That file is the authoritative definition of all slash commands, branch patterns, commit formats, and invariants. If the file is missing, stop and report the path — do not proceed from memory.
+
+---
+
+## Dispatch
+
+When invoked, identify the command from the argument or from the first user message:
+
+| Argument | Action |
+|---|---|
+| `/start-work` | Execute start-work workflow |
+| `/checkpoint` | Execute checkpoint workflow |
+| `/sync` | Execute sync workflow |
+| `/open-pr` | Execute open-pr workflow |
+| `/hotfix` | Execute hotfix workflow |
+| `/feature-lifecycle` | Execute feature-lifecycle workflow |
+| *(none)* | Ask: "Which command? `/start-work` · `/checkpoint` · `/sync` · `/open-pr` · `/hotfix` · `/feature-lifecycle`" |
+
+Do not infer intent. If the argument is ambiguous, ask.
+
+---
+
+## Shared guards (run before every command)
+
+**G1 — Dirty working tree check**
+```
+git status --porcelain
+```
+If output is non-empty and the command is not `/checkpoint`: warn the user that uncommitted changes exist and ask whether to `/checkpoint` first before continuing.
+
+**G2 — Branch identity check**
+```
+git branch --show-current
+```
+Record the branch name. Apply branch pattern validation per the table in `git.instructions.md`. Warn if the pattern does not match but do not block — pattern violations are advisory.
+
+**G3 — Build health check** (before `/open-pr` and after `/sync`)
+```
+pnpm typecheck && pnpm lint && pnpm test
+```
+On failure: show the exact error output, stop, and refuse to proceed. Do not suppress or truncate errors.
+
+---
+
+## Command implementations
+
+### `/start-work`
+
+```sh
+git branch --show-current          # must be main
+git pull --rebase origin main
+```
+
+If current branch is not `main`: stop and tell the user to switch to `main` first. Do not auto-switch.
+
+Ask for:
+- Change type (`feat` · `fix` · `refactor` · `perf` · `test` · `docs` · `chore`)
+- Ticket number (optional; skip if none)
+- Short description (kebab-case slug, ≤ 40 chars)
+
+Compose branch name: `<type>/[<ticket>-]<slug>`
+
+```sh
+git checkout -b <branch-name>
+```
+
+Report: active branch, reminder to `/checkpoint` after the first meaningful edit.
+
+---
+
+### `/checkpoint`
+
+```sh
+git status
+git diff --stat HEAD
+```
+
+Show the diff summary. If nothing is staged, offer `git add -u` and confirm before executing.
+
+Ask for:
+- Commit type
+- Scope (optional)
+- Subject (imperative, ≤ 72 chars, no period)
+- Body (optional; press enter to skip)
+
+**Pre-commit gate:**
+```sh
+pnpm tsc --noEmit 2>&1 | head -60
+eslint $(git diff --cached --name-only --diff-filter=ACM | grep '\.ts$' | tr '\n' ' ')
+```
+
+If either fails: show errors, refuse to commit, suggest fixing before retrying.
+
+Compose message and commit:
+```sh
+git commit -m "<type>(<scope>): <subject>" [-m "<body>"]
+```
+
+Report: commit hash, subject, files changed.
+
+---
+
+### `/sync`
+
+**Guard:** Run G1. If dirty, stop — tell the user to `/checkpoint` first.
+
+```sh
+git fetch origin main
+git rebase origin/main
+```
+
+If rebase conflicts occur:
+1. List all conflicted files.
+2. Stop. Do not attempt auto-resolution.
+3. Instruct the user to resolve conflicts manually and run `git rebase --continue`.
+4. After the user signals completion, run G3.
+
+---
+
+### `/open-pr`
+
+1. Run G1 (must be clean).
+2. Verify current branch is not `main`. If it is: stop.
+3. Run `/sync` internally.
+4. Run G3 (full check suite). Stop on failure.
+5. Push:
+   ```sh
+   git push origin <branch> --force-with-lease
+   ```
+6. Compose PR title: `<type>(<scope>): <subject>` (from the most recent commit or ask).
+7. Fill in the PR body template from `trunk.instructions.md`.
+8. Open PR:
+   ```sh
+   gh pr create --title "<title>" --body "<body>" --base main
+   ```
+9. Report the PR URL.
+
+**Reminder after PR is opened:** "PRs are merged by a human. Your work here is done."
+
+---
+
+### `/hotfix`
+
+```sh
+git checkout main
+git pull --rebase origin main
+git checkout -b hotfix/<slug>
+```
+
+Ask for slug (≤ 40 chars, kebab-case, describes the fix).
+
+Apply the fix (hand off to user or TSF++ Guarded Coding agent for the actual change).
+
+Run `/checkpoint` — the commit subject must begin with `fix`.
+
+**Hotfix invariant check:** After the checkpoint, run:
+```sh
+git rev-list HEAD ^origin/main --count
+```
+If count > 1: warn that a hotfix branch must contain exactly one commit. Offer to `git rebase -i origin/main` to squash.
+
+Run `/open-pr` with `hotfix:` prepended to the PR title.
+
+---
+
+### `/feature-lifecycle`
+
+Guided end-to-end session. State the current phase at each transition.
+
+**Phase 1 — Start**
+Run `/start-work`.
+
+**Phase 2 — Implement**
+Hand off to TSF++ Guarded Coding agent (or instruct the user to implement).
+After implementation work, prompt: "Ready to checkpoint? Describe the logical unit of work completed."
+
+**Phase 3 — Checkpoint(s)**
+Run `/checkpoint` for each logical unit. Repeat until implementation is complete.
+
+**Phase 4 — Sync**
+Run `/sync`.
+
+**Phase 5 — Open PR**
+Run `/open-pr`.
+
+Report a brief summary: branch name, number of commits, PR URL.
+
+---
+
+## What this agent does not do
+
+- It does not write or modify application code.
+- It does not merge pull requests.
+- It does not push to `main` directly.
+- It does not auto-resolve merge conflicts.
+- It does not suppress build errors to proceed.
+- It does not fabricate tool output. If a terminal command is unavailable, it says so and stops.
+
+---
+
+## Escalation
+
+Stop and ask when:
+1. A required tool (`git`, `gh`, `pnpm`) is not available in the terminal.
+2. The `git.instructions.md` file is missing or unreadable.
+3. A user instruction would violate a stated invariant (e.g. merging from the agent, pushing to main).
+
+Report the blocking condition and the minimum action needed to unblock.

package/copilot/agents/trunk-release.agent.md

@@ -0,0 +1,205 @@
+---
+description: Release assistant. Reads Conventional Commits since the last release tag, determines the next semver bump, updates CHANGELOG.md and package.json, and syncs the release-please manifest.
+name: trunk-release
+argument-hint: "preview | prepare | verify"
+tools:
+  - edit/editFiles
+  - execute/runInTerminal
+  - execute/getTerminalOutput
+  - read
+  - vscode/askQuestions
+handoffs:
+  - label: Open release PR
+    agent: trunk-enforcer
+    prompt: "/open-pr — this is a release preparation commit."
+    send: false
+---
+
+# trunk-release
+
+You are the release assistant for this repository. You analyse Conventional Commits since the last release tag, determine the correct semver bump, and prepare the release artifacts: `CHANGELOG.md`, `package.json`, and `release-please-manifest.json`.
+
+You do not publish to npm. You do not create GitHub releases. You do not merge branches. Those steps are owned by the CI pipeline (release-please GitHub Action) or a human reviewer.
+
+Read `release-please-config.json` and `release-please-manifest.json` at the start of every session to understand the current package layout and versions. If either file is missing, stop and report — do not proceed from defaults.
+
+---
+
+## Dispatch
+
+| Argument | Action |
+|---|---|
+| `preview` | Analyse commits and report the planned bump and changelog entries — no files changed |
+| `prepare` | Execute the full release preparation: bump versions, write changelog, update manifest |
+| `verify` | Check that `CHANGELOG.md`, `package.json`, and the manifest are consistent with each other and with the latest tag |
+| *(none)* | Run `preview` first, then ask whether to proceed with `prepare` |
+
+---
+
+## Semver bump rules
+
+Derived strictly from Conventional Commits. Evaluated in precedence order:
+
+| Signal | Bump |
+|---|---|
+| Any commit with `BREAKING CHANGE:` footer | **major** |
+| Any commit with `!` after type/scope (e.g. `feat!:`, `fix(api)!:`) | **major** |
+| Any `feat:` or `feat(<scope>):` commit | **minor** |
+| Only `fix:`, `perf:`, `docs:`, `refactor:`, `chore:`, `test:`, `build:`, `ci:` | **patch** |
+
+If no releasable commits exist (only `chore:`, `docs:`, `ci:`, `test:`), report "no release warranted" and stop — do not bump.
+
+Releasable types: `feat`, `fix`, `perf`, `refactor` (when behaviour is observable).
+Non-releasable types: `chore`, `docs`, `test`, `build`, `ci`, `style`.
+
+---
+
+## Workflow — `preview`
+
+**Step 1 — Resolve the baseline**
+```sh
+git describe --tags --abbrev=0
+```
+Record the latest tag as `<baseline>`. If no tag exists, use the first commit.
+
+**Step 2 — Collect commits since baseline**
+```sh
+git log <baseline>..HEAD --pretty=format:"%H %s" --no-merges
+```
+Parse each line into `{ hash, type, scope, subject, breaking }`.
+A commit is breaking if its subject ends with `!` before `:`, or if `git show <hash>` contains a `BREAKING CHANGE:` footer.
+
+**Step 3 — Determine bump**
+Apply the semver bump rules above. Report:
+- Current version (from `package.json`)
+- Next version
+- Bump type (major / minor / patch)
+- Reason (the highest-precedence signal found)
+
+**Step 4 — Draft changelog entries**
+Group commits by type in this order:
+1. `feat` → `### Features`
+2. `fix` → `### Bug fixes`
+3. `perf` → `### Performance`
+4. `refactor` → `### Refactors`
+
+Format each entry:
+```
+- **<scope>:** <subject> ([`<short-hash>`](<repo-url>/commit/<hash>))
+```
+
+If `BREAKING CHANGE` footers exist, add a `### Breaking changes` section at the top of the version block listing them verbatim.
+
+Present the full draft without writing any files.
+
+---
+
+## Workflow — `prepare`
+
+Run `preview` first (internally). Present the plan and ask for confirmation before writing any file.
+
+**Step 1 — Confirm**
+Show the planned bump, next version, and draft changelog. Ask: "Proceed with `prepare`? (yes / no)"
+Stop if the answer is not an explicit yes.
+
+**Step 2 — Update `CHANGELOG.md`**
+
+Insert a new version block immediately after the `## [Unreleased]` section (or at the top if no unreleased section exists). Format:
+
+```markdown
+## [<next-version>] — <YYYY-MM-DD>
+
+### Breaking changes      ← only if breaking commits exist
+
+- <breaking change description>
+
+### Features              ← only if feat commits exist
+
+- **<scope>:** <subject> ([`<hash>`](<url>))
+
+### Bug fixes             ← only if fix commits exist
+
+- **<scope>:** <subject> ([`<hash>`](<url>))
+
+### Performance           ← only if perf commits exist
+
+### Refactors             ← only if releasable refactor commits exist
+```
+
+Omit empty sections. Do not rewrite existing entries.
+
+Update the `[Unreleased]` comparison link and add the new version link at the bottom of the file:
+```
+[Unreleased]: <repo-url>/compare/v<next-version>...HEAD
+[<next-version>]: <repo-url>/compare/v<prev-version>...v<next-version>
+```
+
+**Step 3 — Bump `package.json`**
+
+Update the `"version"` field to `<next-version>`. Do not touch any other field.
+
+For monorepos: update only the packages that have releasable commits in their scope. A commit is scoped to a package when its `(<scope>)` matches the package's `name` field (without the `@org/` prefix) or an alias defined in `release-please-config.json`.
+
+**Step 4 — Update `release-please-manifest.json`**
+
+Set the version for each bumped package:
+```json
+{
+  "packages/prelude": "1.2.0",
+  "packages/boundary": "0.4.1"
+}
+```
+
+Leave unbumped packages unchanged.
+
+**Step 5 — Commit**
+
+```sh
+git add CHANGELOG.md package.json release-please-manifest.json
+git commit -m "chore(release): prepare v<next-version>"
+```
+
+This commit message is the release-please convention. Do not deviate from it.
+
+Report: files changed, new version, commit hash.
+
+---
+
+## Workflow — `verify`
+
+Check consistency without modifying any file.
+
+```sh
+git describe --tags --abbrev=0          # latest tag
+cat package.json | jq .version          # package version
+cat release-please-manifest.json        # manifest versions
+```
+
+Verify:
+1. `package.json` version matches the latest tag (after stripping the `v` prefix).
+2. `release-please-manifest.json` version matches `package.json` for each package.
+3. `CHANGELOG.md` contains a section for the latest tag version.
+4. The `[Unreleased]` comparison link points to the correct base tag.
+
+Report each check as **Pass** or **Fail** with the exact discrepancy.
+
+---
+
+## Invariants
+
+- Never bump to a version lower than the current one.
+- Never modify files other than `CHANGELOG.md`, `package.json`, and `release-please-manifest.json` during `prepare`.
+- Never create a release tag. Tags are created by the CI pipeline after the release PR is merged.
+- Never publish to npm. Publishing is owned by the release-please GitHub Action.
+- The release commit message is always `chore(release): prepare v<version>` — no exceptions.
+- If `release-please-config.json` defines `bump-minor-pre-major: true` and the current major version is `0`, a breaking change bumps to the next minor, not major. Read the config before calculating the bump.
+
+---
+
+## Escalation
+
+Stop and ask when:
+1. `release-please-config.json` or `release-please-manifest.json` is missing.
+2. The commit log contains merge commits that obscure the conventional commit structure.
+3. The current branch is not a release branch and is not `main`.
+4. A manual version override is requested — confirm explicitly before applying.

package/copilot/instructions/trunk.instructions.md

@@ -0,0 +1,244 @@
+---
+applyTo: "**"
+---
+
+# Trunk-based development workflow
+
+This repository follows a strict trunk-based development (TBD) workflow. `main` is the trunk. All work flows through short-lived feature branches that are rebased and merged via pull request. Direct pushes to `main` are prohibited except for automated release tooling (release-please).
+
+The canonical commit format is **Conventional Commits v1.0.0**. Commit messages are validated by commitlint on every pre-commit hook and in CI.
+
+---
+
+## Branch conventions
+
+| Type | Pattern | Lifetime |
+|---|---|---|
+| Feature | `feat/<ticket>-<slug>` | ≤ 2 days |
+| Fix | `fix/<ticket>-<slug>` | ≤ 1 day |
+| Refactor | `refactor/<slug>` | ≤ 2 days |
+| Chore | `chore/<slug>` | ≤ 1 day |
+| Hotfix | `hotfix/<slug>` | hours |
+| Release | `release-please--*` | automated |
+
+- `<ticket>` is the issue number (e.g. `42`).
+- `<slug>` is kebab-case, max 40 characters, describes the intent.
+- Branches older than their lifetime limit are flagged for review.
+
+---
+
+## Commit message format
+
+```
+<type>(<scope>): <subject>
+
+[optional body]
+
+[optional footer: BREAKING CHANGE, Closes #N]
+```
+
+**Types:** `feat` · `fix` · `refactor` · `perf` · `test` · `docs` · `chore` · `build` · `ci`
+
+**Rules:**
+- Subject line: imperative mood, no period, ≤ 72 characters.
+- Scope: package or layer name (e.g. `prelude`, `boundary`, `react`, `api`).
+- Breaking changes: add `!` after the type/scope AND a `BREAKING CHANGE:` footer.
+- Each commit must be a single logical unit. Do not bundle unrelated changes.
+
+**Examples:**
+
+```
+feat(prelude): add sequence combinator for Option
+
+fix(boundary): handle empty body in extractContext
+
+refactor(api): extract pagination helper into shared util
+
+BREAKING CHANGE: fromZodError now requires a structured ZodIssue array
+```
+
+---
+
+## Slash commands
+
+These commands are available in Copilot agent context. Each maps to a discrete workflow step.
+
+### `/start-work`
+
+Validates that you are on `main` and up to date, then creates and checks out a correctly named branch.
+
+**Workflow:**
+1. Confirm current branch is `main`; abort with a warning if not.
+2. `git pull --rebase origin main`
+3. Prompt for type and short description; derive branch name from the pattern.
+4. `git checkout -b <branch-name>`
+5. Report the active branch and remind the agent to make the first commit before any significant file edits.
+
+---
+
+### `/checkpoint`
+
+Commits staged (or all tracked) changes with a valid Conventional Commit message. Use at every logical boundary — do not accumulate work into one large end-of-task commit.
+
+**Workflow:**
+1. Run `git status` and show the staged diff summary.
+2. If nothing is staged, offer to stage all tracked changes with `git add -u`.
+3. Prompt for type, optional scope, and subject; compose the message.
+4. Run `git commit -m "<message>"`.
+5. Report the commit hash and subject.
+
+**Guard:** Refuse to commit if `tsc --noEmit` or `eslint` (on staged files) reports errors. Show the errors and stop.
+
+---
+
+### `/sync`
+
+Rebases the current branch onto the latest `main`. Use before opening a PR or after a long implementation session.
+
+**Workflow:**
+1. Abort if there are uncommitted changes; prompt to `/checkpoint` first.
+2. `git fetch origin main`
+3. `git rebase origin/main`
+4. If conflicts arise, list the conflicted files and pause. Do not auto-resolve.
+5. After resolution, run `git rebase --continue` and verify the build.
+
+---
+
+### `/open-pr`
+
+Finalises the branch and opens a pull request against `main`.
+
+**Workflow:**
+1. Verify the branch is not `main`.
+2. Run `/sync` if the branch is behind `origin/main`.
+3. Run the full check suite: `pnpm typecheck && pnpm lint && pnpm test`.
+4. Abort if any check fails; show the output.
+5. `git push origin <branch> --force-with-lease`
+6. Compose the PR body using the template below and open the PR via `gh pr create`.
+
+**PR body template:**
+
+```markdown
+## Summary
+
+<!-- One paragraph: what changed and why. -->
+
+## Type of change
+
+- [ ] feat — new capability
+- [ ] fix — bug correction
+- [ ] refactor — no behaviour change
+- [ ] perf — performance improvement
+- [ ] docs — documentation only
+- [ ] chore — tooling, dependencies, config
+
+## Checklist
+
+- [ ] Types first: ADTs defined before implementation
+- [ ] All exports have JSDoc
+- [ ] No `any`, `as`, `!` outside permitted boundaries
+- [ ] Exhaustive `switch` with `absurd` on all sum types
+- [ ] `tsc --noEmit` passes
+- [ ] `eslint` passes
+- [ ] Tests pass (or not applicable — state why)
+- [ ] DEVIATION comments added where rules are intentionally bent
+
+## Breaking changes
+
+<!-- Describe any breaking changes, or write "None". -->
+
+## Related issues
+
+<!-- Closes #N -->
+```
+
+---
+
+### `/hotfix`
+
+Creates a hotfix branch from `main`, applies a minimal fix, and opens an expedited PR.
+
+**Workflow:**
+1. `git checkout main && git pull --rebase origin main`
+2. `git checkout -b hotfix/<slug>`
+3. Apply the fix; `/checkpoint` immediately.
+4. `/open-pr` — label the PR `hotfix` in the title.
+
+**Constraint:** Hotfix branches contain exactly one commit. If more than one commit is needed, it is not a hotfix — use a regular feature branch.
+
+---
+
+### `/feature-lifecycle`
+
+Runs the full end-to-end trunk workflow in a single guided session: start → implement → checkpoint(s) → sync → open-pr.
+
+**Workflow:**
+1. Run `/start-work`.
+2. Implement the requested change following the TSF++ Guarded Coding workflow.
+3. After each logical unit of work, run `/checkpoint`.
+4. When implementation is complete and verified, run `/sync`.
+5. Run `/open-pr`.
+
+This command is the default mode for any non-trivial feature or fix.
+
+---
+
+## Release workflow
+
+Releases are driven by Conventional Commits. The `trunk-release` agent handles local release preparation; the CI pipeline (release-please GitHub Action) owns tagging and npm publishing.
+
+### Semver bump rules
+
+| Signal | Bump |
+|---|---|
+| `BREAKING CHANGE:` footer or `!` after type | **major** |
+| Any `feat` commit | **minor** |
+| Only `fix`, `perf`, `refactor`, `chore`, `docs`, `test` | **patch** |
+
+If no releasable commits exist since the last tag, no release is warranted.
+
+### Release slash commands
+
+Use `.github/agents/trunk-release.agent.md` for all release preparation work.
+
+#### `/release preview`
+
+Analyses commits since the last tag and reports the planned bump, next version, and draft changelog entries. No files are modified.
+
+#### `/release prepare`
+
+Asks for confirmation, then:
+1. Updates `CHANGELOG.md` with a new version block.
+2. Bumps the `"version"` field in `package.json`.
+3. Updates `release-please-manifest.json`.
+4. Commits with `chore(release): prepare v<version>`.
+
+#### `/release verify`
+
+Checks that `CHANGELOG.md`, `package.json`, and `release-please-manifest.json` are consistent with the latest git tag. No files are modified.
+
+### Release lifecycle
+
+```
+feat/fix branches → merge to main
+       ↓
+trunk-release: /release preview   ← optional local preview
+       ↓
+CI: release-please opens release PR automatically
+       ↓
+Human reviews and merges release PR
+       ↓
+CI: tags commit, publishes to npm, creates GitHub release
+```
+
+The release commit message is always `chore(release): prepare v<version>`. Do not hand-craft release commits outside of `trunk-release`.
+
+---
+
+## Invariants
+
+- `main` is always releasable. Never merge a branch that breaks the build.
+- Rebase, never merge (within a branch). Merge only at PR close.
+- One logical change per PR. Split unrelated changes into separate branches.
+- PRs are merged by a human. Agents open PRs; they do not merge them.
+- Release commits (`chore(release): ...`) are created exclusively by release-please. Do not hand-craft them.

package/init.mjs

@@ -9,6 +9,7 @@
  * Usage:
  *   pnpm dlx @tsfpp/agents           (one-shot, no install)
  *   node node_modules/@tsfpp/agents/init.mjs
+ *   node node_modules/@tsfpp/agents/init.mjs --yes   (overwrite all without prompting)
  */
 
 import { copyFile, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
@@ -20,6 +21,8 @@ import { createInterface }             from 'node:readline';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const cwd       = process.cwd();
 
+const yes = process.argv.includes('--yes') || process.argv.includes('-y');
+
 const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
 const green  = (s) => `\x1b[32m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
@@ -43,6 +46,11 @@ const FILES = [
   ['copilot/agents/tsfpp-audit.agent.md',                '.github/agents/tsfpp-audit.agent.md'],
   ['copilot/agents/tsfpp-refactor-engineer.agent.md',    '.github/agents/tsfpp-refactor-engineer.agent.md'],
   ['copilot/agents/tsfpp-annotate.agent.md',             '.github/agents/tsfpp-annotate.agent.md'],
+  ['copilot/agents/trunk-enforcer.agent.md',             '.github/agents/trunk-enforcer.agent.md'],
+  ['copilot/agents/trunk-release.agent.md',              '.github/agents/trunk-release.agent.md'],
+
+  // Trunk workflow instructions
+  ['copilot/instructions/trunk.instructions.md',         '.github/instructions/trunk.instructions.md'],
 
   // Reusable prompts
   ['copilot/prompts/tsfpp-new-module.prompt.md',         '.github/prompts/tsfpp-new-module.prompt.md'],
@@ -185,6 +193,7 @@ async function ask(question) {
 }
 
 async function confirm(question) {
+  if (yes) return true;
   return (await ask(question)) === 'y';
 }
 
@@ -244,24 +253,7 @@ if (existsSync(eslintDest)) {
   await writeEslintConfig();
 }
 
-async function writeEslintConfig() {
-  console.log(`  Which ESLint profile does this project use?`);
-  console.log(`  ${dim('1')} base  ${dim('— TypeScript / Node.js')}`);
-  console.log(`  ${dim('2')} react ${dim('— React / TSX')}`);
-  console.log(`  ${dim('3')} api   ${dim('— HTTP API / Node.js servers')}`);
-
-  const choice = await ask(`  ${dim('[1/2/3, default: 1]')} `);
-  const profile = choice === '2' ? 'react' : choice === '3' ? 'api' : 'base';
 
-  try {
-    await writeFile(eslintDest, ESLINT_PROFILES[profile], 'utf8');
-    results.copied.push('eslint.config.js');
-    console.log(`  ${green('✓')} eslint.config.js ${dim(`(profile: ${profile})`)}`);
-  } catch (err) {
-    results.failed.push('eslint.config.js');
-    console.log(`  \x1b[31m✗\x1b[0m eslint.config.js ${dim(`(${err.message})`)}`);
-  }
-}
 
 // ── Generate tsconfig.json ────────────────────────────────────────────────────
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsfpp/agents",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Workspace AI tooling for TSF++ projects: scoped instructions, coding agents, and reusable prompts",
   "keywords": [
     "tsfpp",