@frontfactory/brigade 0.0.0-stage → 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Front Factory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# brigade
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Version](https://flat.badgen.net/npm/v/@frontfactory/brigade)](https://www.npmjs.com/package/@frontfactory/brigade)
+[![Downloads](https://flat.badgen.net/npm/dt/@frontfactory/brigade)](https://www.npmjs.com/package/@frontfactory/brigade)
+[![License](https://flat.badgen.net/npm/license/@frontfactory/brigade)](https://www.npmjs.com/package/@frontfactory/brigade)
+
+Sets up a Claude Code architecture in any project, new or existing, without fuss.
+
+```sh
+npx @frontfactory/brigade init
+```
+
+## What you get
+
+Three roles, each limited to its mission:
+
+| Role | Model (default effort) | Mission |
+|---|---|---|
+| Main session | Opus in Plan Mode (medium) | Discuss, think, orchestrate, verify, propose, answer. Goes back and forth with the subagents. |
+| `implementer` | Sonnet (medium) | Development, nothing else. |
+| `git-operator` | Haiku (low) | Git, nothing else, once the work is done. |
+
+Plus base rules for work, security and efficiency, adapted to the stack (web for now). The setup is shared with the
+project and committed with it. Each developer can override their own effort locally with `/brigade-effort`.
+
+The rest of the kit, all under `.claude/`:
+
+- Skills: `session-start` (where things stand before the first task), `feature` (branch + state file for multi-step work),
+  `audit` (keep an audit file between sessions).
+- Commands: `/brigade-effort` (your effort per role) and `/brigade-language` (your reply language), both local and
+  not committed.
+- Shared context in `context/`: `decisions.md` (team decisions), `architecture.md` (optional, read on demand), one
+  state file per feature in `context/features/`, audits in `context/audits/`.
+- A git guard hook (`hooks/git-guard.mjs`) and the permissions in `settings.json`.
+
+## Install
+
+`init` detects the default branch, the package manager, the commit convention and the language, and asks you to
+validate each one. `--yes` (or `-y`) accepts everything detected. `--stack <name>` forces the stack instead of
+detecting it (only `web` for now).
+
+Brigade never touches your `CLAUDE.md`: its instructions live in `.claude/rules/brigade.md`, which Claude Code loads
+at launch like a `CLAUDE.md`.
+
+When Brigade is already installed, `init` asks whether to keep the installed version or update to the one you run. On
+the same version it offers to change your options (the questions are asked again, files only change if an answer
+does) or to leave everything as it is. Without a terminal, it updates.
+
+An existing file is never overwritten. If it differs from the kit, a `.proposed` file is written next to it; if it is
+identical, nothing happens. A file Brigade wrote and nobody touched is updated. `.gitignore` and `.gitattributes` only
+get the lines they miss. `.claude/context/decisions.md` is written once and then belongs to the team: it is never
+updated nor proposed over.
+
+## Git
+
+Only `git-operator` writes to git, enforced by a hook. Writing on the default or reference branch, `push`, `merge` and
+`rebase` ask for confirmation; destructive commands are denied. Brigade proposes a commit once a piece of work is
+finished and never commits without your go.
+
+A feature (work over several steps or sessions) gets its own branch and a state file `.claude/context/features/<branch>.md` (slashes become dashes), committed with the branch, so
+the work survives between developers and machines. `CLAUDE.local.md` stays personal.
+
+## Add a stack
+
+Create `templates/<name>/` with the same layout as `templates/web/`, then add one entry in `src/stacks.js`. Placeholders:
+`__DEFAULT_BRANCH__`, `__BASE_BRANCH__`, `__PACKAGE_MANAGER__`, `__COMMIT_FORMAT__`, `__REPLY_LANGUAGE__`,
+`__CODE_LANGUAGE__`, `__DOCS_LANGUAGE__`.
+
+## Develop
+
+`npm test` runs the tests (`node --test`, no dependency). Commits follow Conventional Commits, checked by commitlint. Node >= 24 is required.
+
+Releases are automatic: on a push to `main` or `beta`, once the tests pass, the CI runs semantic-release, which
+derives the version from the commits, updates the changelog and publishes `@frontfactory/brigade` to npm.

package/bin/brigade.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from '../src/cli.js';
+
+process.exitCode = await main(process.argv.slice(2));

package/package.json

@@ -1,6 +1,55 @@
 {
-  "name": "@frontfactory/brigade",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@frontfactory/brigade",
+    "version": "1.0.0",
+    "description": "Sets up a Claude Code architecture in any web project: a main session, a Sonnet implementer, a Haiku git-operator and a git guard.",
+    "type": "module",
+    "scripts": {
+        "prepare": "husky",
+        "test": "node --test \"test/*.test.js\"",
+        "release": "semantic-release"
+    },
+    "engines": {
+        "node": ">=24"
+    },
+    "bin": {
+        "brigade": "bin/brigade.js"
+    },
+    "devDependencies": {
+        "@commitlint/cli": "^21.2.4",
+        "@commitlint/config-conventional": "^21.2.4",
+        "@semantic-release/changelog": "^7.0.0",
+        "@semantic-release/git": "^11.0.1",
+        "@semantic-release/github": "^12.0.10",
+        "conventional-changelog-conventionalcommits": "^9.3.1",
+        "husky": "^9.1.7",
+        "semantic-release": "^25.0.9"
+    },
+    "dependencies": {
+        "@clack/prompts": "^1.8.1"
+    },
+    "keywords": [
+        "claude-code",
+        "claude",
+        "cli",
+        "scaffold",
+        "git-hooks"
+    ],
+    "license": "MIT",
+    "homepage": "https://github.com/front-factory/brigade#readme",
+    "bugs": {
+        "url": "https://github.com/front-factory/brigade/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/front-factory/brigade.git"
+    },
+    "files": [
+        "bin",
+        "src",
+        "templates"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    }
+}

package/src/cli.js

@@ -0,0 +1,88 @@
+import { CONVENTIONS } from './conventions.js';
+import { runInit } from './init.js';
+import { STACKS } from './stacks.js';
+
+const HELP = `Usage: brigade init [--yes] [--stack <name>]
+
+  --yes           accept every detected or default answer, ask nothing
+  --stack <name>  force the stack (${Object.keys(STACKS).join(', ')}); detected otherwise
+`;
+
+const WORDS = {
+    created: 'added',
+    updated: 'updated',
+    unchanged: 'already up to date',
+    kept: 'yours kept',
+    proposed: 'yours kept, proposal written'
+};
+
+function parse(args) {
+    const options = { yes: false, stack: undefined };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--yes' || args[i] === '-y') options.yes = true;
+        else if (args[i] === '--stack') options.stack = args[++i];
+        else throw new Error(`Unknown option: ${args[i]}`);
+    }
+    if (options.stack && !STACKS[options.stack]) throw new Error(`Unknown stack: ${options.stack}`);
+    return options;
+}
+
+function summary({ version, answers, report, ignored, repo, personal, local }) {
+    const lines = report.map(({ path, status }) => `${WORDS[status].padEnd(28)} ${path}${status === 'proposed' ? '.proposed' : ''}`);
+    for (const { path, status, added } of ignored) {
+        if (status === 'updated') lines.push(`${'lines added'.padEnd(28)} ${path} (${added.join(', ')})`);
+    }
+
+    const settings = [
+        `Brigade          ${version}`,
+        `Default branch   ${answers.defaultBranch}`,
+        `Reference branch ${answers.baseBranch}`,
+        `Package manager  ${answers.packageManager}`,
+        `Commit format    ${CONVENTIONS[answers.commitConvention]?.label ?? 'Custom'}`,
+        `Replies          ${answers.replyLanguage} (project default)`,
+        `Code             ${answers.codeLanguage}`,
+        `Documentation    ${answers.docsLanguage}`,
+        `Replies for you  ${personal.language && local?.status === 'written' ? `${personal.language} (your machine only)` : 'project default'}`
+    ];
+    return { files: lines.join('\n'), settings: settings.join('\n'), kept: report.some(({ status }) => status === 'proposed'), repo };
+}
+
+function print(result, interactive) {
+    const { prompter } = result;
+    if (result.kept) {
+        if (interactive) prompter.outro(`Kept Brigade ${result.kept}. Nothing was written.`);
+        else console.log(`Brigade ${result.kept} kept. Nothing was written.`);
+        return;
+    }
+
+    const { files, settings, kept, repo } = summary(result);
+
+    if (!interactive) {
+        console.log(`Brigade installed (stack: ${result.stack}).\n\n${files}\n\n${settings}`);
+        return;
+    }
+
+    prompter.note(files, 'Files');
+    prompter.note(settings, 'Your setup');
+    if (kept) prompter.warn('Some files of yours differ from the kit: they were kept. Merge the .proposed version if you want it.');
+    if (!repo) prompter.warn('Remember to run `git init` before your first commit.');
+    prompter.outro('Done. Run `claude` here, use Plan Mode (Shift+Tab) to discuss, and /brigade-language and /brigade-effort for your own settings.');
+}
+
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    if (command !== 'init') {
+        console.log(HELP);
+        return command === undefined || command === '--help' ? 0 : 1;
+    }
+
+    try {
+        const options = parse(rest);
+        const interactive = Boolean(process.stdin.isTTY) && !options.yes;
+        print(await runInit({ cwd: process.cwd(), interactive, ...options }), interactive);
+        return 0;
+    } catch (error) {
+        console.error(`brigade: ${error.message}`);
+        return 1;
+    }
+}

package/src/conventions.js

@@ -0,0 +1,22 @@
+export const CONVENTIONS = {
+    conventional: {
+        label: 'Conventional Commits',
+        example: 'feat(auth): add login form',
+        format: 'Conventional Commits: `type(scope): description` (`feat`, `fix`, `chore`, `refactor`, `docs`, `test`), imperative mood, 72 characters max.'
+    },
+    angular: {
+        label: 'Angular',
+        example: 'fix(core): handle empty list',
+        format: 'Angular: `type(scope): description` with the types `build`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `test`, imperative mood, 72 characters max.'
+    },
+    gitmoji: {
+        label: 'Gitmoji',
+        example: '✨ Add login form',
+        format: 'Gitmoji: `<emoji> Description` (e.g. `✨ Add login form`), imperative mood, 72 characters max.'
+    },
+    imperative: {
+        label: 'Simple imperative',
+        example: 'Add login form',
+        format: 'A single imperative sentence without prefix (e.g. `Add login form`), 72 characters max.'
+    }
+};

package/src/detect.js

@@ -0,0 +1,80 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const LOCKFILES = {
+    'pnpm-lock.yaml': 'pnpm',
+    'yarn.lock': 'yarn',
+    'bun.lock': 'bun',
+    'bun.lockb': 'bun',
+    'package-lock.json': 'npm'
+};
+
+const LANGUAGES = {
+    en: 'English',
+    fr: 'French',
+    es: 'Spanish',
+    de: 'German',
+    it: 'Italian',
+    pt: 'Portuguese'
+};
+
+function git(cwd, ...args) {
+    try {
+        return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    } catch {
+        return '';
+    }
+}
+
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+export function isGitRepo(cwd) {
+    return git(cwd, 'rev-parse', '--is-inside-work-tree') === 'true';
+}
+
+export function localBranches(cwd) {
+    return git(cwd, 'for-each-ref', '--format=%(refname:short)', 'refs/heads').split('\n').filter(Boolean);
+}
+
+// Remote HEAD first, then `init.defaultBranch`, then the current branch. Empty when nothing is found.
+export function detectDefaultBranch(cwd) {
+    const remote = git(cwd, 'symbolic-ref', '--short', 'refs/remotes/origin/HEAD').replace(/^origin\//, '');
+    if (remote) return remote;
+
+    const configured = git(cwd, 'config', 'init.defaultBranch');
+    if (configured) return configured;
+
+    return git(cwd, 'symbolic-ref', '--short', 'HEAD');
+}
+
+// `packageManager` wins; several lockfiles are a leftover, so `value` stays empty and the candidates are listed.
+export function detectPackageManager(cwd) {
+    const declared = readJson(join(cwd, 'package.json'))?.packageManager?.split('@')[0];
+    if (declared) return { value: declared, candidates: [declared] };
+
+    const candidates = [...new Set(
+        Object.entries(LOCKFILES).filter(([file]) => existsSync(join(cwd, file))).map(([, name]) => name)
+    )];
+    return { value: candidates.length === 1 ? candidates[0] : '', candidates };
+}
+
+// commitlint counts only when it is a dependency and wired to a `commit-msg` hook.
+export function detectCommitConvention(cwd) {
+    const pkg = readJson(join(cwd, 'package.json'));
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    if (!existsSync(join(cwd, '.husky', 'commit-msg'))) return '';
+    if (deps['@commitlint/config-angular']) return 'angular';
+    return deps['@commitlint/config-conventional'] ? 'conventional' : '';
+}
+
+export function detectLanguage(env = process.env) {
+    const code = (env.LC_ALL || env.LC_MESSAGES || env.LANG || '').slice(0, 2).toLowerCase();
+    return LANGUAGES[code] ?? '';
+}

package/src/init.js

@@ -0,0 +1,161 @@
+import { CONVENTIONS } from './conventions.js';
+import {
+    detectCommitConvention,
+    detectDefaultBranch,
+    detectLanguage,
+    detectPackageManager,
+    isGitRepo,
+    localBranches
+} from './detect.js';
+import { appendMissingLines, installFiles, readManifest, writeLocalSettings, writeManifest } from './install.js';
+import { createPrompter } from './prompt.js';
+import { DEFAULT_STACK, STACKS, detectStack } from './stacks.js';
+import { VERSION, compareVersions } from './version.js';
+
+const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun'];
+const LANGUAGES = ['English', 'French'];
+
+// Every answer is detected first, then validated by the dev. A previous answer wins over detection.
+async function ask({ cwd, prompter, previous = {} }) {
+    const { validate, choose, text } = prompter;
+    const branches = localBranches(cwd);
+
+    const defaultBranch = await validate(
+        'Default branch of the repository',
+        previous.defaultBranch || detectDefaultBranch(cwd),
+        () => text('Default branch of the repository', 'main')
+    );
+
+    const baseCandidates = [previous.baseBranch, defaultBranch, branches.includes('develop') && 'develop'].filter(Boolean);
+    const baseBranch = await choose(
+        'Reference branch of the work',
+        [...new Set(baseCandidates)].map((value) => ({
+            value,
+            label: value,
+            hint: value === defaultBranch ? 'default branch' : 'feature branches start from it'
+        }))
+    );
+
+    const manager = detectPackageManager(cwd);
+    const managers = [...new Set([...manager.candidates, ...PACKAGE_MANAGERS])];
+    const packageManager = await validate(
+        'Package manager',
+        previous.packageManager || manager.value,
+        () => choose(
+            'Package manager',
+            managers.map((value) => ({ value, label: value, hint: manager.candidates.includes(value) ? 'found in the project' : undefined })),
+            { other: false }
+        )
+    );
+
+    const conventionKey = await validate(
+        'Commit convention',
+        previous.commitConvention || detectCommitConvention(cwd) || 'conventional',
+        () => choose(
+            'Commit convention',
+            [
+                ...Object.entries(CONVENTIONS).map(([value, { label, example }]) => ({ value, label, hint: example })),
+                { value: 'custom', label: 'Custom', hint: 'you describe it in one sentence' }
+            ],
+            { other: false }
+        ),
+        CONVENTIONS[previous.commitConvention || detectCommitConvention(cwd) || 'conventional']?.label
+    );
+    const commitFormat = conventionKey === 'custom'
+        ? await text('Describe your commit format in one sentence', previous.commitFormat)
+        : CONVENTIONS[conventionKey].format;
+
+    const languages = (current) => [...new Set([current, ...LANGUAGES].filter(Boolean))].map((value) => ({ value, label: value }));
+
+    const replyLanguage = await validate(
+        "Default language of Claude's replies for this project (each developer can use their own later)",
+        previous.replyLanguage || detectLanguage(),
+        () => choose("Default language of Claude's replies for this project", languages())
+    );
+    const mine = await choose(
+        'And for you? This stays on your machine',
+        [
+            { value: 'keep', label: `Keep the project language (${replyLanguage || LANGUAGES[0]})` },
+            { value: 'own', label: 'Use another language for me' }
+        ],
+        { other: false }
+    );
+    const ownLanguage = mine === 'own'
+        ? await choose('Your own reply language', languages().filter(({ value }) => value !== replyLanguage))
+        : '';
+
+    const codeLanguage = await choose(
+        'Language of the code, comments and commit messages (shared by the team)',
+        languages(previous.codeLanguage)
+    );
+    const docsLanguage = await choose(
+        'Language of the documentation (shared by the team)',
+        languages(previous.docsLanguage || codeLanguage)
+    );
+
+    const answers = {
+        defaultBranch,
+        baseBranch,
+        packageManager,
+        commitConvention: conventionKey,
+        commitFormat,
+        replyLanguage: replyLanguage || LANGUAGES[0],
+        codeLanguage,
+        docsLanguage
+    };
+    return { answers, personal: { language: ownLanguage } };
+}
+
+// Asked whenever Brigade is already installed. The first option is the answer when nothing can be asked.
+async function chooseVersion({ prompter, installed, version }) {
+    if (installed === version) {
+        prompter.info(`Brigade ${installed} is already installed here and up to date.`);
+        return prompter.choose(
+            'What do you want to do?',
+            [
+                { value: 'update', label: 'Change my options', hint: 'the questions are asked again, files only change if an answer does' },
+                { value: 'keep', label: 'Leave it as it is', hint: 'nothing is written' }
+            ],
+            { other: false }
+        );
+    }
+
+    const newer = compareVersions(version, installed) > 0;
+    prompter.info(`Brigade ${installed} is installed here, this is Brigade ${version}.`);
+    return prompter.choose(
+        newer ? 'A newer version is available' : 'This Brigade is older than the installed one',
+        [
+            { value: 'update', label: `${newer ? 'Update' : 'Switch'} to ${version}`, hint: 'new kit files, and the questions are asked again. Files you edited are kept' },
+            { value: 'keep', label: `Keep ${installed}`, hint: 'nothing is written' }
+        ],
+        { other: false }
+    );
+}
+
+export async function runInit({ cwd, yes = false, stack, stackDir, version = VERSION, interactive = process.stdin.isTTY && !yes, prompter }) {
+    const name = stack ?? detectStack(cwd);
+    const dir = stackDir ?? (STACKS[name] ?? STACKS[DEFAULT_STACK]).dir;
+    const previous = readManifest(cwd);
+
+    prompter ??= createPrompter({ interactive: Boolean(interactive) });
+    const repo = isGitRepo(cwd);
+    prompter.intro(`Brigade ${version}`);
+    prompter.info(`Stack: ${name}${stack ? '' : ' (the only one available for now)'}.`);
+
+    const installed = previous?.version;
+    if (installed && await chooseVersion({ prompter, installed, version }) === 'keep') {
+        return { kept: installed, stack: previous.stack ?? name, answers: previous.answers, report: [], ignored: [], repo, prompter, personal: {}, local: null };
+    }
+
+    if (!repo) {
+        prompter.warn('No git repository here. Brigade will not create one: run `git init` when you are ready. The branch names below are kept for then.');
+    }
+    const { answers, personal } = await ask({ cwd, prompter, previous: previous?.answers });
+
+    const { report, hashes } = installFiles({ cwd, stackDir: dir, answers, previous });
+    writeManifest({ cwd, version, stack: name, answers, hashes });
+    const ignored = appendMissingLines(cwd);
+    const local = personal.language ? writeLocalSettings(cwd, { language: personal.language }) : null;
+
+    return { version, stack: name, answers, report, ignored, repo, prompter, personal, local };
+}

package/src/install.js

@@ -0,0 +1,134 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+
+export const MANIFEST = '.claude/brigade.json';
+
+// Lines Brigade appends to the project files when missing. Existing lines are never touched or duplicated.
+const APPENDS = {
+    '.gitignore': ['.claude/settings.local.json', 'CLAUDE.local.md'],
+    '.gitattributes': ['.claude/hooks/* text eol=lf']
+};
+
+// Written once, then the team's own: never updated, never proposed over.
+const WRITE_ONCE = new Set(['.claude/context/decisions.md']);
+
+const sha = (content) => createHash('sha256').update(content).digest('hex');
+
+function listFiles(dir) {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const abs = join(dir, entry.name);
+        if (entry.isDirectory()) return listFiles(abs);
+        return entry.name === '.DS_Store' ? [] : [abs];
+    });
+}
+
+export function render(content, answers) {
+    const values = {
+        DEFAULT_BRANCH: answers.defaultBranch,
+        BASE_BRANCH: answers.baseBranch,
+        PACKAGE_MANAGER: answers.packageManager,
+        COMMIT_FORMAT: answers.commitFormat,
+        REPLY_LANGUAGE: answers.replyLanguage,
+        CODE_LANGUAGE: answers.codeLanguage,
+        DOCS_LANGUAGE: answers.docsLanguage
+    };
+    return content.replace(/__([A-Z_]+)__/g, (match, key) => values[key] ?? match);
+}
+
+export function readManifest(cwd) {
+    try {
+        return JSON.parse(readFileSync(join(cwd, MANIFEST), 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+// Never overwrites a file that differs from what Brigade last wrote: that one gets a `.proposed` next to it.
+export function installFiles({ cwd, stackDir, answers, previous }) {
+    const report = [];
+    const hashes = {};
+
+    for (const source of listFiles(stackDir)) {
+        const path = relative(stackDir, source).split('\\').join('/');
+        const target = join(cwd, path);
+        const content = render(readFileSync(source, 'utf8'), answers);
+        const mode = statSync(source).mode & 0o777;
+
+        const write = (file) => {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, content, { mode });
+            chmodSync(file, mode);
+        };
+
+        if (!existsSync(target)) {
+            write(target);
+            hashes[path] = sha(content);
+            report.push({ path, status: 'created' });
+            continue;
+        }
+
+        const current = sha(readFileSync(target, 'utf8'));
+        if (WRITE_ONCE.has(path)) {
+            report.push({ path, status: current === sha(content) ? 'unchanged' : 'kept' });
+            continue;
+        }
+        if (current === sha(content)) {
+            hashes[path] = current;
+            report.push({ path, status: 'unchanged' });
+        } else if (previous?.files?.[path] === current) {
+            write(target);
+            hashes[path] = sha(content);
+            report.push({ path, status: 'updated' });
+        } else {
+            const proposed = `${target}.proposed`;
+            const same = existsSync(proposed) && sha(readFileSync(proposed, 'utf8')) === sha(content);
+            if (!same) write(proposed);
+            if (previous?.files?.[path]) hashes[path] = previous.files[path];
+            report.push({ path, status: 'proposed' });
+        }
+    }
+
+    return { report, hashes };
+}
+
+const normalize = (line) => line.trim().replace(/^\//, '');
+
+export function appendMissingLines(cwd) {
+    return Object.entries(APPENDS).map(([path, lines]) => {
+        const file = join(cwd, path);
+        const existing = existsSync(file) ? readFileSync(file, 'utf8') : '';
+        const known = new Set(existing.split('\n').map(normalize));
+        const missing = lines.filter((line) => !known.has(normalize(line)));
+
+        if (missing.length === 0) return { path, status: 'unchanged' };
+
+        const separator = existing === '' || existing.endsWith('\n') ? '' : '\n';
+        const heading = existing === '' ? '' : '\n';
+        writeFileSync(file, `${existing}${separator}${heading}## Claude\n${missing.join('\n')}\n`);
+        return { path, status: 'updated', added: missing };
+    });
+}
+
+export function writeManifest({ cwd, version, stack, answers, hashes }) {
+    const file = join(cwd, MANIFEST);
+    mkdirSync(dirname(file), { recursive: true });
+    const files = Object.fromEntries(Object.entries(hashes).sort(([a], [b]) => a.localeCompare(b)));
+    writeFileSync(file, `${JSON.stringify({ version, stack, answers, files }, null, 4)}\n`);
+}
+
+// Personal answers go to the developer's own local settings, never to the shared files. A broken file is left alone.
+export function writeLocalSettings(cwd, patch) {
+    const file = join(cwd, '.claude', 'settings.local.json');
+    let current = {};
+    if (existsSync(file)) {
+        try {
+            current = JSON.parse(readFileSync(file, 'utf8'));
+        } catch {
+            return { status: 'skipped' };
+        }
+    }
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify({ ...current, ...patch }, null, 4)}\n`);
+    return { status: 'written' };
+}

package/src/prompt.js

@@ -0,0 +1,55 @@
+import * as p from '@clack/prompts';
+
+const OTHER = Symbol('other');
+
+// Non-interactive (no TTY or `--yes`): every question resolves to its default and nothing is printed.
+export function createPrompter({ interactive }) {
+    // Nothing is written before the last question, so cancelling leaves the project untouched.
+    const answer = async (pending) => {
+        const value = await pending;
+        if (p.isCancel(value)) {
+            p.cancel('Cancelled. Nothing was written.');
+            process.exit(1);
+        }
+        return value;
+    };
+
+    async function text(message, fallback = '') {
+        if (!interactive) return fallback;
+        return (await answer(p.text({ message, placeholder: fallback, defaultValue: fallback }))).trim();
+    }
+
+    // `options`: [{ value, label, hint? }]. The first one is preselected.
+    async function choose(message, options, { other = true } = {}) {
+        if (!interactive) return options[0].value;
+
+        const items = options.map(({ value, label, hint }) => ({ value, label, hint }));
+        if (other) items.push({ value: OTHER, label: 'Other…' });
+
+        const value = await answer(p.select({ message, options: items, initialValue: options[0].value }));
+        return value === OTHER ? text(`${message} (type it)`) : value;
+    }
+
+    // A detected value is proposed first; Enter keeps it, "no" goes on to `pick`.
+    async function validate(message, detected, pick, shown = detected) {
+        if (!detected) return pick();
+        if (!interactive) return detected;
+
+        const keep = await answer(p.confirm({ message: `${message}: ${shown}. Is that right?`, initialValue: true }));
+        return keep ? detected : pick();
+    }
+
+    const when = (fn) => (...args) => interactive && fn(...args);
+
+    return {
+        text,
+        choose,
+        validate,
+        intro: when((title) => p.intro(title)),
+        info: when((message) => p.log.info(message)),
+        warn: when((message) => p.log.warn(message)),
+        note: when((message, title) => p.note(message, title)),
+        outro: when((message) => p.outro(message)),
+        close: () => {}
+    };
+}

package/src/stacks.js

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const TEMPLATES = join(dirname(fileURLToPath(import.meta.url)), '..', 'templates');
+
+// A stack is a folder in `templates/` plus one entry here. `match` tells whether a project looks like it.
+export const STACKS = {
+    web: {
+        label: 'Web',
+        dir: join(TEMPLATES, 'web'),
+        match: (cwd) => existsSync(join(cwd, 'package.json'))
+    }
+};
+
+export const DEFAULT_STACK = 'web';
+
+export function detectStack(cwd) {
+    return Object.keys(STACKS).find((name) => STACKS[name].match(cwd)) ?? DEFAULT_STACK;
+}

package/src/version.js

@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs';
+
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+
+const parts = (version) => version.split('-')[0].split('.').map((part) => Number.parseInt(part, 10) || 0);
+
+// Positive when `a` is newer than `b`, negative when older, 0 when equal. Pre-release tags are ignored.
+export function compareVersions(a, b) {
+    const [left, right] = [parts(a), parts(b)];
+    for (let i = 0; i < Math.max(left.length, right.length); i++) {
+        const diff = (left[i] ?? 0) - (right[i] ?? 0);
+        if (diff !== 0) return diff;
+    }
+    return 0;
+}

package/templates/web/.claude/agents/git-operator.md

@@ -0,0 +1,17 @@
+---
+name: git-operator
+description: Git only, once a piece of work is done and the user has approved the commit. The only role allowed to write to git. Never edits code.
+model: haiku
+effort: low
+tools: Bash, Read, Glob, Grep
+---
+
+You are the git role. You do what the brief asks on git and nothing else. You never edit files.
+
+- Protected branches: `__DEFAULT_BRANCH__` and `__BASE_BRANCH__`. Writing on them asks the user for confirmation; do not work around it.
+- **Commits**: compare the changes with the file list in the brief. If an unexpected file changed, or a sensitive file is present (`.env*`, key, token), stop and report it without committing. Never stage `CLAUDE.local.md`. Stage explicit files (never `git add .` or `-A`). If the changes cover several goals, make several atomic commits.
+- **Message**: in __CODE_LANGUAGE__. Format: __COMMIT_FORMAT__ Add a body when the "why" is not obvious.
+- **Branches**: create a branch only when the brief asks, from `__BASE_BRANCH__` after a fetch, named `type/short-description`.
+- `push`, `merge` and `rebase` always ask the user. Destructive commands are denied.
+
+Report back: the branch, the commits (hash and message), and anything that was left undone.

package/templates/web/.claude/agents/implementer.md

@@ -0,0 +1,18 @@
+---
+name: implementer
+description: Development only. Writes and changes code, dependencies and config as briefed by the main session. Use for every code change. Never runs git write commands.
+model: sonnet
+effort: medium
+tools: Read, Edit, Write, Glob, Grep, Bash
+---
+
+You are the development role. You do the work described in the brief and nothing else.
+
+- Work on the branch given in the brief. If it is not the current one, stop and say so.
+- Keep changes small and focused on the brief. Match the style of the surrounding code.
+- Use the project's package manager: `__PACKAGE_MANAGER__`.
+- Run lint, build or tests only if the brief asks for it.
+- At important steps, update the feature file `.claude/context/features/<branch-with-slashes-as-dashes>.md` if the work is a feature (see skill `feature`); no file for small work.
+- Never run git write commands (the git guard blocks them). Never read or write secrets.
+
+Report back briefly: what you changed (files), what you did not do and why, and any question that needs the user's decision. Do not commit.

package/templates/web/.claude/commands/brigade-effort.md

@@ -0,0 +1,11 @@
+---
+description: Set your own effort for the main session and the subagents (local, not committed)
+allowed-tools: Read, Write, Edit
+---
+
+Ask the developer, in one question, which role and which level they want (`low`, `medium`, `high`):
+
+- **main session**: set `effortLevel` in `.claude/settings.local.json`.
+- **implementer** or **git-operator**: write the line `Effort for <role>: <level>` in `CLAUDE.local.md`, replacing the existing line for that role if there is one.
+
+Read the file first and keep everything else in it. Create it if it does not exist. Only change the effort. Tell the developer what was written and that the shared project files were not touched.

package/templates/web/.claude/commands/brigade-language.md

@@ -0,0 +1,11 @@
+---
+description: Choose the language of Claude's replies for you only (local, not committed)
+allowed-tools: Read, Write, Edit
+---
+
+The project sets a default reply language in `.claude/settings.json` (key `language`). Read it, then ask the developer one question: keep the project language, or use their own?
+
+- **Keep**: remove the `language` key from `.claude/settings.local.json` if it is there.
+- **Their own**: ask which language, then set `language` in `.claude/settings.local.json`.
+
+Read the file first and keep every other key. Create it if it does not exist. Only change `language`. Tell the developer what was written and that the shared project files were not touched.

package/templates/web/.claude/context/architecture.md

@@ -0,0 +1,9 @@
+# Architecture
+
+<!-- Optional. Not loaded by default: read on demand. Keep it short. -->
+
+## Overview
+<!-- Main modules, data flow, external services (API, database, auth, CDN) -->
+
+## Conventions
+<!-- Naming, folder layout, patterns specific to this project -->

package/templates/web/.claude/context/audits/_template.md

@@ -0,0 +1,12 @@
+# Audit: <topic>
+
+Date: YYYY-MM-DD
+Baseline commit: <hash>
+Scope: <files / folders / question>
+Status: open
+
+## Findings
+
+| ID | Severity | File | Problem | Status | Notes (commit / reason) |
+|----|----------|------|---------|--------|-------------------------|
+| A1 | high | src/... | ... | open | |

package/templates/web/.claude/context/decisions.md

@@ -0,0 +1,6 @@
+# Team decisions
+
+<!-- Shared by everyone. Written once by Brigade at install, then yours: never overwritten. -->
+<!-- One line per decision: what + why. Newest at the bottom. -->
+<!-- To change a decision, edit it in place (git keeps the history). -->
+<!-- Keep this file under ~30 lines: move details and replaced decisions to decisions-archive.md. -->

package/templates/web/.claude/context/features/_template.md

@@ -0,0 +1,29 @@
+# Feature: <name> (branch <branch name>)
+
+Date: YYYY-MM-DD
+Last commit: <hash>
+Base branch: <branch>
+Parent branch: <feature branch if stacked> (only if any)
+Uncommitted / stash: <WIP description> (only if any)
+
+## Goal
+
+<one or two sentences>
+
+## Steps
+
+- [x] done step
+- [ ] remaining step
+
+## Decisions and open questions
+
+-
+
+## Notes
+
+-
+
+## Active audit (only if any)
+
+Path: <.claude/context/audits/YYYY-MM-DD-topic.md>
+Open IDs: <A1, A2>

package/templates/web/.claude/context/local-template.md

@@ -0,0 +1,14 @@
+# My preferences (personal, not committed)
+
+<!-- Copy to CLAUDE.local.md at the project root (git-ignored). Effort lines for the roles live here too. -->
+<!-- The feature state does NOT live here: it is in .claude/context/features/<branch>.md, shared with the branch. -->
+
+## Effort
+Effort for implementer: medium
+Effort for git-operator: low
+
+## Preferences
+-
+
+## Scratch
+-

package/templates/web/.claude/hooks/git-guard.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// Git guard (PreToolUse on Bash): only `git-operator` writes to git.
+// Reads the hook payload on stdin; `agent_type` is set for subagents and absent for the main session.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const READ = new Set(['status', 'diff', 'log', 'show', 'blame', 'rev-parse', 'ls-files', 'ls-tree', 'grep', 'describe', 'shortlog', 'cat-file']);
+const ASK = new Set(['push', 'merge', 'rebase']);
+const ON_PROTECTED = new Set(['commit', 'cherry-pick', 'revert', 'am', 'pull', 'reset', 'rm']);
+const RANK = { allow: 0, ask: 1, deny: 2 };
+
+// Quoted text (commit messages) must not be read as commands.
+const strip = (command) => command.replace(/"(?:[^"\\]|\\.)*"|'[^']*'/g, '""');
+
+function gitCommands(command) {
+    return strip(command)
+        .split(/&&|\|\||;|\||\n/)
+        .map((segment) => segment.trim().match(/^(?:\w+=\S+\s+)*git\s+((?:-\S+\s+)*)([\w-]+)\s*(.*)$/))
+        .filter(Boolean)
+        .map(([, , sub, rest]) => ({ sub, rest }));
+}
+
+// `git branch` and `git remote` only read when given no mutating flag.
+function writes({ sub, rest }) {
+    if (READ.has(sub)) return false;
+    if (sub === 'branch') return /(^|\s)(-[dDmMcC]|--delete|--move|--copy)\b/.test(rest) || /(^|\s)[^-\s]/.test(rest);
+    if (sub === 'remote') return !/^(-v|--verbose)?\s*$/.test(rest);
+    if (sub === 'config') return !/(^|\s)(--get|--list|-l)\b/.test(rest);
+    if (sub === 'stash') return !/^list\b/.test(rest);
+    return true;
+}
+
+function destructive({ sub, rest }) {
+    return (sub === 'reset' && /--hard/.test(rest))
+        || (sub === 'push' && /(^|\s)(--force|--force-with-lease|-f)\b/.test(rest))
+        || (sub === 'clean' && /(^|\s)-\w*f/.test(rest))
+        || (sub === 'branch' && /(^|\s)-D\b/.test(rest));
+}
+
+export function decide({ command, agent, branch, protectedBranches }) {
+    let decision = { permissionDecision: 'allow', reason: '' };
+    const raise = (permissionDecision, reason) => {
+        if (RANK[permissionDecision] > RANK[decision.permissionDecision] || decision.reason === '') decision = { permissionDecision, reason };
+    };
+
+    const found = gitCommands(command).filter(writes);
+    if (found.length === 0) return null;
+
+    for (const git of found) {
+        if (agent !== 'git-operator') {
+            raise('deny', 'Only git-operator writes to git: delegate to it, after the user\'s go.');
+        } else if (destructive(git)) {
+            raise('deny', `git ${git.sub}: destructive command, not allowed.`);
+        } else if (ASK.has(git.sub)) {
+            raise('ask', `git ${git.sub} always needs the user's confirmation.`);
+        } else if (ON_PROTECTED.has(git.sub) && protectedBranches.includes(branch)) {
+            raise('ask', `"${branch}" is a protected branch: confirm before writing on it.`);
+        } else {
+            raise('allow', 'git-operator: git write on an unprotected branch.');
+        }
+    }
+    return decision;
+}
+
+function currentBranch(cwd) {
+    try {
+        return execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    } catch {
+        return '';
+    }
+}
+
+function protectedBranches(root) {
+    try {
+        const { answers } = JSON.parse(readFileSync(join(root, '.claude', 'brigade.json'), 'utf8'));
+        return [answers.defaultBranch, answers.baseBranch].filter(Boolean);
+    } catch {
+        return [];
+    }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const input = JSON.parse(readFileSync(0, 'utf8'));
+    const root = process.env.CLAUDE_PROJECT_DIR || input.cwd || process.cwd();
+
+    const decision = decide({
+        command: input.tool_input?.command ?? '',
+        agent: input.agent_type ?? '',
+        branch: currentBranch(input.cwd || root),
+        protectedBranches: protectedBranches(root)
+    });
+
+    if (decision) {
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: 'PreToolUse',
+                permissionDecision: decision.permissionDecision,
+                permissionDecisionReason: decision.reason
+            }
+        }));
+    }
+}

package/templates/web/.claude/rules/brigade.md

@@ -0,0 +1,42 @@
+# Brigade
+
+Rules of the Brigade setup of this web project. Work is split between three roles.
+
+## Roles
+
+- **Main session (you)**: discuss, think, plan, orchestrate, verify, propose, answer questions. You do not write code and you do not run git write commands. Delegate development to `implementer`, git to `git-operator`, and go back and forth between them based on their reports.
+- **`implementer`** (Sonnet): development only.
+- **`git-operator`** (Haiku): git only, once the work is done.
+
+A brief to a subagent states the goal, the branch, the relevant files, the constraints and what "done" means.
+
+## Git
+
+- Default branch: `__DEFAULT_BRANCH__`. Reference branch of the work: `__BASE_BRANCH__`. Both are protected: writing on them needs the user's confirmation.
+- Check the current branch before any code.
+- A feature (several steps, sessions or files) = its own branch + a state file. Small work (a fix, a few files, one sitting) has neither: it ends with a commit on the current branch. Before any code, judge which it is and follow the skill `feature`: propose, wait for the user's answer, then `git-operator` creates the branch (with the user's go).
+- When the work is finished and its open questions are settled, propose the commit in one sentence. Never call `git-operator` without the user's go. The user can ask for a commit at any moment.
+- The feature file `.claude/context/features/<branch-with-slashes-as-dashes>.md` is shared and travels with the branch. `implementer` updates it at important steps; mention it in the `git-operator` brief so it goes in the same commit.
+- Pushing needs the user's confirmation. At the end of a session, or on pause/handoff, if commits are not pushed, propose the push in one sentence: without a push nothing survives.
+- Commit format, for `git-operator`: __COMMIT_FORMAT__
+
+## Rules
+
+- At the start of a session, read `.claude/context/decisions.md` (team decisions, shared).
+- Keep changes small and focused.
+- Use the project's package manager: `__PACKAGE_MANAGER__`.
+- Run lint, build or tests only when the user asks or the task needs them. Do not assume they exist.
+- Never read or write secrets (`.env*`, keys, tokens).
+- Say so before adding a dependency.
+- Validate input on the server side. Never log sensitive data.
+- Do not read `node_modules`, lockfiles or build output.
+
+## Languages
+
+- Code, comments and commit messages: __CODE_LANGUAGE__.
+- Documentation: __DOCS_LANGUAGE__.
+- Replies: set by the `language` setting. The project default is __REPLY_LANGUAGE__; each developer can use their own with `/brigade-language`.
+
+## Local effort
+
+If `CLAUDE.local.md` gives an effort for a role (`implementer` or `git-operator`), pass it as the `effort` parameter when you delegate to that role. Change it with `/brigade-effort`.

package/templates/web/.claude/settings.json

@@ -0,0 +1,51 @@
+{
+    "model": "opusplan",
+    "effortLevel": "medium",
+    "language": "__REPLY_LANGUAGE__",
+    "permissions": {
+        "defaultMode": "acceptEdits",
+        "allow": [
+            "Bash(git status:*)",
+            "Bash(git diff:*)",
+            "Bash(git log:*)",
+            "Bash(git show:*)",
+            "Bash(__PACKAGE_MANAGER__ run:*)"
+        ],
+        "ask": [
+            "Bash(git push:*)",
+            "Bash(git merge:*)",
+            "Bash(git rebase:*)"
+        ],
+        "deny": [
+            "Bash(git reset --hard:*)",
+            "Bash(git push --force:*)",
+            "Bash(git push -f:*)",
+            "Bash(git clean -f:*)",
+            "Bash(git branch -D:*)",
+            "Bash(rm -rf /:*)",
+            "Bash(rm -rf ~:*)",
+            "Read(./.env*)",
+            "Read(./**/*.pem)",
+            "Read(./**/*.key)",
+            "Read(./node_modules/**)",
+            "Read(./package-lock.json)",
+            "Read(./pnpm-lock.yaml)",
+            "Read(./yarn.lock)",
+            "Read(./dist/**)",
+            "Read(./build/**)"
+        ]
+    },
+    "hooks": {
+        "PreToolUse": [
+            {
+                "matcher": "Bash",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/git-guard.mjs\""
+                    }
+                ]
+            }
+        ]
+    }
+}

package/templates/web/.claude/skills/audit/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: audit
+description: "Use after any code audit or review and BEFORE fixing anything, or when resuming one: writes, maintains and hands off the audit file for commit."
+---
+
+An audit must survive between sessions, machines and developers: it is a committed, shared file.
+
+- Right after an audit, BEFORE any fix, have `implementer` write `.claude/context/audits/YYYY-MM-DD-topic.md` from `.claude/context/audits/_template.md`: scope, baseline commit (`git rev-parse --short HEAD`), one table row per finding.
+- Statuses: `open`, `fixed`, `wontfix` (reason), `deferred`. Set a row to `fixed` as soon as its fix is verified, BEFORE the commit, so the audit file goes in the same commit as the fix (no hash: it does not exist yet; `git log -- <file>` finds it).
+- **Commit**: an audit file is never left uncommitted. Audit only (no fix yet): propose the commit to the user, then ask `git-operator` to commit it on the current branch. On the default or reference branch, ask the user which branch to use first. With fixes: include it in the task commit.
+- Audit files are NOT loaded by default: read them on demand. Never delete one; when every row is closed, set `Status: closed` (and commit it).
+- Keep the active audit's path and open IDs in the feature file (`.claude/context/features/<branch-with-slashes-as-dashes>.md`).
+- To resume: work only on `open`/`deferred` rows, and run `git diff <baseline>..HEAD -- <files>` to find findings the code changed since. Re-audit only those.
+- A `wontfix` that sets a team-wide rule also goes in `.claude/context/decisions.md`.

package/templates/web/.claude/skills/feature/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: feature
+description: "Use on each development request, before any code, to judge whether it is a feature (several steps, sessions or files); also when pausing, handing off, ending a session, resuming or finishing a feature."
+---
+
+A feature = work with several steps, sessions or files. Only features get a branch and a state file. Small work (a fix, a doc tweak, a few files, one sitting) has no branch requirement, no file, no handoff: it ends with a commit on the current branch (`main` and `develop` still need the user's confirmation).
+
+- **Detection**: before any code, judge whether the request is a feature. If not, say nothing and continue. If yes, say in 1-2 lines that it looks like a feature and propose to handle it as one (branch `feat/<name>` + state file). Wait for the answer: yes / no / "small work".
+- **Yes**: `git-operator` creates the branch (with the user's go). Create the file at once from `.claude/context/features/_template.md` with the goal and the planned steps. File name: the branch with slashes as dashes (`feat/login` -> `feat-login.md`), in `.claude/context/features/`.
+- **No / small work**: continue on the current branch, no file, do not ask again for that work. If it grows into a feature, tell the user and re-propose.
+- **During the feature**: `implementer` updates the file at important steps. It goes in the same commit as the work (mention it in the `git-operator` brief).
+- **Pause / handoff / end of session**: make sure the file is up to date (have `implementer` fix it), propose the commit, then propose the push in one sentence: without a push nothing survives. Pushing needs the user's confirmation.
+- **Resume**: `session-start` reads the file and reports it, then runs the resume check: new commits on the base branch (`git log HEAD..<base> --oneline`) and conflict risk, changes to `.claude/context/decisions.md` since the saved date, audit rows still open.
+- **End**: remove the file in the last commit before the branch is merged.
+- The file is versioned with the branch, so it is shared between developers and machines. `CLAUDE.local.md` stays personal.

package/templates/web/.claude/skills/session-start/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: session-start
+description: "Use before the first coding task of a session (not for plain questions): checks the git branch, its feature file and remote sync, reports where things stand."
+---
+
+Check the current branch (`git branch --show-current`, `git status -sb`), read `.claude/context/decisions.md`, `CLAUDE.local.md` (if present, personal preferences only) and `.claude/context/features/<branch-with-slashes-as-dashes>.md` (if present).
+
+- **Feature file present**: read it and report in 2-3 lines the goal, what is done, the next step. Then run the resume check (see `feature`, "Resume"): new commits on base, `decisions.md` changes since the saved date, open audit rows. Ask whether to continue or start something new, and do not start coding before the user has confirmed.
+- **No file**: just report the branch and the remote sync. No file is created.
+
+Also report the sync with the remote: `git status -sb` (ahead/behind) and `git log @{u}..HEAD --oneline` for unpushed commits. If the branch is behind or has no upstream, say so. If commits are unpushed, propose the push in one sentence.