@ericrisco/rsc 3.0.4 → 3.0.5

package/README.md

@@ -70,7 +70,7 @@ rsc 3.0 fixes all four, by default, with no new commands to learn:
 
 | | What happens | Turn it off |
 | --- | --- | --- |
-| **You decide where each change goes** | Before every change that writes code, the agent asks: a new branch, or straight on `main`? It never opens a branch on its own. In a project that is complex or in production (CI, a deployment, several people), a commit on `main` is refused, and the agent asks whether to open a branch or unlock `main`. | Say **«unlock main»**, or `rsc main unlock` |
+| **You choose how the project works** | The install asks once: straight on `main`, or branches and pull requests? Branches are recommended only for long-lived, complex code. With `main` the agent works on it and never asks about branches. With branches a commit on `main` is refused, and before each code change the agent asks: this branch, a new one, or unlock `main`? It never opens a branch on its own. | Say **«unlock main»** / **«lock main»**, or `rsc main unlock` / `lock` |
 | **One workspace per agent** | If another assistant session is working in the same folder, new work goes to a worktree under `.worktrees/<branch>/`. It stays inside the project, is never committed, and is removed once that branch is merged. | `rsc isolation off` |
 | **The agent picks the method** | A simple change takes Fast-Track (one document, proof for every task). Something big or complex takes the spec-driven chain. The agent decides and says why. You still approve *what* gets built: the spec and the clarifications, then step by step or autopilot. | Ask for the other lane |
 | **Knowledge reaches everyone** | `01-TOOLS/` and `02-DOCS/` travel through one exchange branch, `rsc/knowledge`. They go up when your turn ends and come down into whatever branch each person is on. They reach `main` inside your normal pull requests. | `rsc knowledge-sync off` |
@@ -100,7 +100,8 @@ rsc git-permissions on       # turn it on, also for a project adopted before
 what anyone can check: a CI setup, a deployment file (`Dockerfile`, `vercel.json`, `fly.toml`…) or
 at least two people in the last 50 commits. If any of those is there, a commit on the default branch
 is refused before it runs, and the agent asks you whether to open a branch or unlock it. If none is,
-`main` is open, and the agent still asks before each change whether you want a branch. If the hook gets it wrong and the project really is simple, «unlock main» opens it for
+`main` is open and the agent simply works on it. **The answer you gave at install always wins over
+this detection**; it only decides for projects installed before the question existed. If the hook gets it wrong and the project really is simple, «unlock main» opens it for
 the project. That decision is saved in `.rsc.json`, so the whole team gets it.
 
 Every refusal says how to carry on, and the choice between a branch and unlocking goes back to you.

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.4",
+  "version": "3.0.5",
   "counts": {
     "skills": 270,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {

package/scripts/lib/onboarding-apply.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { appendFileSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, writeFileSync } from 'node:fs';
+import { appendFileSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { applyInstall, pruneSharedBases, removeTargetInstall } from '../install-apply.js';
@@ -96,6 +96,7 @@ function recoveryCommand(plan, planId) {
     `--project-kind ${record.projectKind}`,
     `--goal-base64 ${encodeGoal(record.goal)}`,
     ...(record.softwareScope ? [`--software-scope ${record.softwareScope}`] : []),
+    ...(record.workflow ? [`--workflow ${record.workflow}`] : []),
     `--target ${record.targets.join(',')}`,
     `--accept-plan ${planId}`,
   ].join(' ');
@@ -226,6 +227,22 @@ export function verifyOnboarding(cwd, plan, planId) {
   return differences;
 }
 
+/**
+ * The install-time answer «main | branches» becomes the project's trunk decision, as the same two
+ * markers `rsc main unlock|lock` writes (both PROJECT opt-outs, recorded in .rsc.json by the install
+ * below, rebuilt in a clone): main → `.no-trunk-guard` (open), branches → `.no-trunk-open` (closed
+ * even where nothing in the project looks complex yet).
+ */
+export function applyWorkflowDecision(cwd, workflow) {
+  if (workflow !== 'main' && workflow !== 'branches') return;
+  const dir = join(cwd, '.rsc');
+  mkdirSync(dir, { recursive: true });
+  const open = join(dir, '.no-trunk-guard');
+  const closed = join(dir, '.no-trunk-open');
+  writeFileSync(workflow === 'main' ? open : closed, '');
+  rmSync(workflow === 'main' ? closed : open, { force: true });
+}
+
 export async function applyAcceptedOnboarding({ cwd = process.cwd(), plan, planId, now = new Date(), apply = applyInstall }) {
   if (identifyPlan(plan) !== planId) throw new Error('RSC_PLAN_CHANGED: regenerate the plan and ask the user to accept the new id');
   const previousManifest = readManifest(cwd);
@@ -259,6 +276,7 @@ export async function applyAcceptedOnboarding({ cwd = process.cwd(), plan, planI
     },
   };
   try {
+    applyWorkflowDecision(cwd, plan.record.workflow);
     for (const target of previousPlan?.policy?.targets || []) {
       if (!plan.policy.targets.includes(target)) removeTargetInstall({ cwd, target });
     }

package/scripts/lib/onboarding.js

@@ -13,6 +13,8 @@ export const ONBOARDING_VALUES = Object.freeze({
   technicalLevel: ['non-technical', 'mixed', 'technical'],
   projectKind: ['software', 'operations', 'research', 'content', 'mixed'],
   softwareScope: ['small', 'growing', 'complex'],
+  // How code changes land: straight on the default branch, or on branches closed with a pull request.
+  workflow: ['main', 'branches'],
 });
 
 const ignored = new Set([
@@ -29,6 +31,9 @@ const oneOf = (field, value, values) => {
   return value;
 };
 
+/** The workflow to recommend at install: branches + PR only for complex code. */
+export const recommendedWorkflow = (softwareScope) => (softwareScope === 'complex' ? 'branches' : 'main');
+
 export function normalizeOnboarding(raw = {}) {
   const schemaVersion = Number(raw.schemaVersion ?? ONBOARDING_SCHEMA_VERSION);
   if (schemaVersion !== ONBOARDING_SCHEMA_VERSION) throw new Error(`invalid schemaVersion: expected ${ONBOARDING_SCHEMA_VERSION}`);
@@ -47,12 +52,18 @@ export function normalizeOnboarding(raw = {}) {
   const needsScope = projectKind === 'software' || projectKind === 'mixed';
   const softwareScope = clean(raw.softwareScope).toLowerCase();
   if (needsScope) oneOf('software-scope', softwareScope, ONBOARDING_VALUES.softwareScope);
+  // Asked at install (2026-10-06, Eric): branches and PRs are for long-lived, complex code; research,
+  // content and simple scripts work on the default branch. Absent → the recommendation for the scope.
+  const workflow = needsScope
+    ? (clean(raw.workflow) ? oneOf('workflow', clean(raw.workflow).toLowerCase(), ONBOARDING_VALUES.workflow) : recommendedWorkflow(softwareScope))
+    : 'main';
   return {
     schemaVersion,
     technicalLevel,
     projectKind,
     goal,
     ...(needsScope ? { softwareScope } : {}),
+    workflow,
     targets,
   };
 }
@@ -296,6 +307,8 @@ export function buildOnboardingPlan(record, evidence) {
     '02-DOCS/wiki/harness/decisions.md',
     '02-DOCS/wiki/harness/installation-plan.md',
     '.rsc/.no-context7',
+    // The install-time workflow answer (applyWorkflowDecision): the one marker it writes.
+    ...(normalized.workflow === 'branches' ? ['.rsc/.no-trunk-open'] : normalized.workflow === 'main' ? ['.rsc/.no-trunk-guard'] : []),
     ...normalized.targets.flatMap((target) => managedPathsForInstall({ skillIds: skills, target, cwd: root, policy })
       .map((path) => relative(root, path).split(sep).join('/'))),
   ])].sort() : ['.rsc.json', '.rsc/', '02-DOCS/wiki/harness/'];

package/scripts/rsc.js

@@ -42,7 +42,7 @@ if (['--version', '-v', 'version'].includes(rawArgv[0])) {
 // `--accompaniment` stays listed although the dial is retired: old scripts and agents still pass it,
 // and its value must keep being skipped rather than read as a command or a skill id.
 const GLOBAL_VALUE_FLAGS = new Set([
-  '--target', '--technical-level', '--accompaniment', '--project-kind', '--goal', '--goal-base64', '--software-scope', '--accept-plan',
+  '--target', '--technical-level', '--accompaniment', '--project-kind', '--goal', '--goal-base64', '--software-scope', '--workflow', '--accept-plan',
 ]);
 const COMMANDS = new Set(['onboard', 'reassess', 'add', 'install', 'consult', 'catalog', 'audit', 'list', 'doctor', 'memory', 'knowledge-sync', 'git-permissions', 'main', 'isolation', 'sync', 'backups', 'restore', 'upgrade', 'registry', 'worktrees', 'capabilities', 'sello', 'repair', 'uninstall', 'purge']);
 function positionalTokens(input) {
@@ -84,6 +84,7 @@ function onboardingInput(targets) {
     projectKind: value('project-kind'),
     goal: value('goal') || (value('goal-base64') ? decodeGoal(value('goal-base64')) : undefined),
     softwareScope: value('software-scope'),
+    workflow: value('workflow'),
     targets,
   };
 }
@@ -93,7 +94,17 @@ function onboardingRequired(raw, action = 'onboard') {
     code: 'RSC_ONBOARDING_REQUIRED',
     schemaVersion: 1,
     missing: missingOnboardingFields(raw),
-    recovery: `Run npx @ericrisco/rsc@latest ${action} --technical-level <non-technical|mixed|technical> --project-kind <software|operations|research|content|mixed> --goal "<what you want>" --target <assistant>`,
+    recovery: `Run npx @ericrisco/rsc@latest ${action} --technical-level <non-technical|mixed|technical> --project-kind <software|operations|research|content|mixed> --goal "<what you want>" --target <assistant> (software or mixed also: --software-scope <small|growing|complex> --workflow <main|branches>)`,
+    // Each value is the person's own answer, asked as a question. Never infer one from the code or
+    // from a nearby answer: a field test mapped «mixto» to technical and «growing» to small.
+    ask: {
+      'technical-level': 'Technical terms, or plain words with analogies? (non-technical | mixed | technical)',
+      'project-kind': 'What is this project? (software | operations | research | content | mixed)',
+      goal: 'What do you want this project to achieve?',
+      'software-scope': 'How much software work is expected? (small | growing | complex)',
+      workflow: 'Code changes: straight on main, or on branches closed with a pull request? (main | branches — recommended: branches only for complex, long-lived code)',
+      target: 'Which assistants? (claude, codex, gemini, cursor, opencode, …)',
+    },
   };
   console.error(`RSC_ONBOARDING_REQUIRED ${JSON.stringify(payload)}`);
   process.exitCode = 2;
@@ -135,6 +146,10 @@ function renderPlan(plan, planId) {
   say('RSC_ONBOARDING_PLAN');
   say(`Plan id: ${planId}`);
   say(`Project: ${plan.record.projectKind}${plan.record.softwareScope ? ` (${plan.record.softwareScope})` : ''}`);
+  say(`Technical level: ${plan.record.technicalLevel}`);
+  say(`Workflow: ${plan.record.workflow === 'branches' ? 'branches + pull request (the default branch is closed for the agent; it asks before each code change where it goes)' : 'straight on the default branch (no branch questions)'}`);
+  if (plan.record.softwareScope) say('AGENT: ask the person «¿Los cambios de código van directos a main, o con ramas y pull request?» (main | branches; branches is for long-lived, complex code). If their answer differs from the line above, generate the plan again with --workflow <answer>.');
+  say('AGENT: before accepting, read these values back to the person and check each one is what they answered.');
   say(`Targets: ${plan.policy.targets.join(', ')}`);
   say('Selected:');
   for (const decision of plan.decisions.filter((d) => d.state === 'selected')) say(`  + ${decision.kind}/${decision.id} — ${decision.reason}`);
@@ -157,6 +172,7 @@ function renderPlan(plan, planId) {
     `--project-kind ${plan.record.projectKind}`,
     `--goal-base64 ${encodeGoal(plan.record.goal)}`,
     ...(plan.record.softwareScope ? [`--software-scope ${plan.record.softwareScope}`] : []),
+    ...(plan.record.workflow ? [`--workflow ${plan.record.workflow}`] : []),
     `--target ${plan.record.targets.join(',')}`,
     `--accept-plan ${planId}`,
   ];
@@ -189,6 +205,14 @@ async function runOnboarding(targets) {
         { key: 'complex', label: 'Complex — multiple systems, teams or critical behavior' },
       ]);
     }
+    if ((raw.projectKind === 'software' || raw.projectKind === 'mixed') && !raw.workflow) {
+      const branchesFirst = raw.softwareScope === 'complex';
+      const options = [
+        { key: 'main', label: 'Straight on main — research, content, scripts, simple projects' },
+        { key: 'branches', label: 'Branches + pull request — long-lived, complex code' },
+      ];
+      raw.workflow = await select('How should code changes land?', branchesFirst ? options.reverse() : options);
+    }
     if (!raw.targets?.length) raw.targets = await selectAgents();
     if (!raw.technicalLevel || !raw.projectKind || !raw.goal || !raw.targets?.length) {
       say('Cancelled — nothing was touched.');
@@ -288,6 +312,7 @@ function runReassessment() {
     `--project-kind ${record.projectKind}`,
     `--goal-base64 ${encodeGoal(record.goal)}`,
     ...(record.softwareScope ? [`--software-scope ${record.softwareScope}`] : []),
+    ...(record.workflow ? [`--workflow ${record.workflow}`] : []),
     `--target ${record.targets.join(',')}`,
   ].join(' '));
   say('Show the new plan and ask the user to accept its id before applying it.');
@@ -784,11 +809,17 @@ async function main() {
         mkdirSync(join(root, '.rsc'), { recursive: true });
         if (sub === OFF) writeFileSync(marker, '');
         else rmSync(marker, { force: true });
+        // main: lock and unlock are the two answers to «main or branches?», so each clears the other.
+        // A lock is a decision, not a return to guessing: closed even where nothing looks complex.
+        if (isMain) {
+          const lock = join(root, '.rsc', '.no-trunk-open');
+          if (sub === ON) writeFileSync(lock, ''); else rmSync(lock, { force: true });
+        }
         for (const t of targets) await syncInstalled({ target: t, cwd: root });
         say(isMain
           ? (sub === OFF
             ? 'rsc main unlock: the agent may now work on the default branch in this project. Commit .rsc.json so the team gets the same decision.'
-            : 'rsc main lock: the default branch is closed for the agent again where the project looks complex or in production. Commit .rsc.json so the team gets the same decision.')
+            : 'rsc main lock: branches and pull requests for this project — the default branch is closed for the agent, and it asks before each code change where it goes. Commit .rsc.json so the team gets the same decision.')
           : (sub === OFF
             ? 'rsc isolation off: sessions may share this folder without a worktree. Commit .rsc.json so the team gets the same decision.'
             : 'rsc isolation on: with another session active in this folder, new work goes to .worktrees/<branch>/. Commit .rsc.json so the team gets the same decision.'));

package/skills/ftd/SKILL.md

@@ -53,13 +53,16 @@ the chain: a result asserted without evidence is treated as not done.
 
 ## Isolation
 
-Where the work runs is the person's call, asked change by change — never a branch opened on your own:
-
-- **Before each change that writes code**, ask in one line: «¿Lo hago en una rama nueva o directamente
-  en `<default branch>`?». A branch is named by intent and closes with a pull request.
-- **Default branch closed for the agent** (rsc refuses the commit there: CI, a deployment or several
-  people committing) → ask: «¿Abro una rama o desbloqueo `<default branch>`?». Unlocking is
-  `rsc main unlock`, a project decision; never run it without that answer.
+Where the work runs follows the project's decision (asked at install: «main» or «ramas y PR»; rsc
+says which on every turn) — never a branch opened on your own:
+
+- **Default branch open** (research, content, scripts, simple projects) → work straight on it. Do not
+  ask about branches.
+- **Default branch closed for the agent** (long-lived code: «ramas y PR» chosen at install, CI, a
+  deployment or several people) → before EACH change that writes code, ask in one line: «¿Lo hago en
+  esta rama (`<current>`), en una nueva, o desbloqueo `<default branch>`?». Already on another branch
+  is no exception: an unrelated change does not go into it without asking. A new branch is named by
+  intent and closes with a pull request. Unlocking is `rsc main unlock`; never without that answer.
 - **Docs, wiki or config only** → no question, no branch.
 - **Another session working in this same folder** → a worktree in `.worktrees/<branch>/`, never a
   branch switch under the other session. Not a question: rsc tells you when that is the case.

package/skills/implement/SKILL.md

@@ -45,9 +45,9 @@ back — you do not write feature code anyway.
 4. **Read the register.** Open `02-DOCS/wiki/harness/user-profile.md` and read `technical_level`.
    It picks technical terms or plain words with analogies at each checkpoint (see "Checkpoints"
    below). No profile yet → use analogies, and ask before any irreversible step.
-5. **Confirm isolation.** On `main`/`master`, stop before the first commit and ask the person: a
-   feature branch, or straight on the default branch (`worktrees`)? Never branch on your own; another
-   session in this folder makes the worktree mandatory.
+5. **Confirm isolation.** Default branch open for this project → work on it. Closed → stop before
+   the first commit and ask: this branch, a new one, or unlock (`worktrees`)? Never branch on your
+   own; another session in this folder makes the worktree mandatory.
 6. **Scan the tasks for independence.** Mark which tasks share files/state and which are disjoint.
    Disjoint clusters are candidates for `parallel`; everything else runs in order.
 

package/skills/suggest/SKILL.md

@@ -32,9 +32,9 @@ Big, or decisions that affect each other → **SDD**: enter the chain; the perso
 clarify, then picks manual or autopilot. Say which and why in one line; switch if asked.
 → `../ftd/SKILL.md` · `../sdd/SKILL.md`.
 
-**Where.** Before each change that writes code, ask: a branch, or straight on the default branch? Never
-branch on your own. Default branch closed (CI, deploy, team) → ask: a branch, or `rsc main unlock`?
-Another session in this checkout → `.worktrees/<branch>`; «no uses worktrees» = `rsc isolation off`.
+**Where.** Default branch open (chosen at install, or nothing complex) → work on it, no branch
+question. Closed («ramas y PR», CI, team) → before each code change ask: this branch, a new one, or
+`rsc main unlock`? Never branch alone. Another session here → `.worktrees/<branch>`.
 
 Judge the **meaning**, not the wording: the trigger is semantic in any language. A bug fix restoring
 intended behaviour is `debug`. Autopilot consent covers a whole run — advance without re-asking.

package/skills/worktrees/SKILL.md

@@ -27,12 +27,11 @@ constitution → specify → clarify → plan → tasks → analyze → [ worktr
 
 ## The one rule that defines this step
 
-**Never run `implement` on the default branch without asking.** The moment a plan is about to become
-commits, if `git rev-parse --abbrev-ref HEAD` says `main` or `master`, you stop and ask the person
-*first* — «¿rama nueva o directamente en `main`?» — before the first edit, not after the diff already
-exists. Never branch on your own; if rsc refuses commits there (closed default branch), the question
-is «¿abro una rama o desbloqueo `main`?». The one exception is another session in this folder: then
-the worktree is mandatory, not a question.
+**Never open a branch on your own; follow the project's decision.** Where the default branch is open
+(chosen at install, or nothing complex), `implement` runs on it. Where it is closed («ramas y PR»,
+CI, team), stop before the first edit and ask «¿esta rama, una nueva, o desbloqueo `main`?» — not
+after the diff already exists. The one exception is another session in this folder: then the
+worktree is mandatory, not a question.
 
 ## The decision: branch vs. worktree
 

package/targets/clone-bootstrap.mjs

@@ -43,7 +43,7 @@ const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/i;
  * nothing checks is just drift with a head start.
  */
 export const PROJECT_OPT_OUTS = [
-  'audit', 'auto-update', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'knowledge-sync', 'ship-guard', 'trunk-guard', 'worktree-cleanup', 'worktree-isolation',
+  'audit', 'auto-update', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'knowledge-sync', 'ship-guard', 'trunk-guard', 'trunk-open', 'worktree-cleanup', 'worktree-isolation',
 ];
 
 /**

package/targets/hook-once.mjs

@@ -97,8 +97,8 @@ Classify this turn before acting, and name the lane in one line.
 - Authorises a change? YOU pick the lane, say it and why: simple -> FTD (one
   feature document, tasks checked off against observed proof); big or
   interlocking decisions -> SDD (spec + clarify approved, then autopilot or not).
-- Code change? Ask first, every time: a branch or the default branch? Never
-  branch on your own. Another session here: .worktrees/<branch>.
+- Code change: the line below says where it goes in this project. Never open
+  a branch on your own. Another session here: .worktrees/<branch>.
 Method: \`ftd\` · chain: \`sdd\` · full decisor in the always-on \`suggest\` body.
 =================================================
 `;

package/targets/opt-outs.js

@@ -26,6 +26,7 @@ export const PROJECT_OPT_OUTS = [
   'knowledge-sync',   // 01-TOOLS/ + 02-DOCS/ sync: one person off and the team stops seeing their work
   'ship-guard',       // branch/trunk discipline
   'trunk-guard',      // «desbloquea main»: the default branch open for the agent, for the whole team
+  'trunk-open',       // «ramas y PR» chosen at install / `rsc main lock`: closed even with nothing that looks complex
   'worktree-cleanup', // the reaper's notice (it only ever names, never acts)
   'worktree-isolation', // «no uses worktrees»: same-folder sessions allowed to share a checkout
 ];

package/targets/team-safe-start.mjs

@@ -101,9 +101,9 @@ export function teamSafeAnnouncement(root) {
     return `
 ===== rsc 3.0 · equipo seguro por defecto =====
 ACTION: díselo a la persona en pocas líneas, una vez, antes de su petición:
-1. Antes de cada cambio de código, el agente pregunta: ¿rama nueva o directamente en la principal?
-   Nunca abre una rama por su cuenta. Si la principal está cerrada (CI, despliegue o equipo), pregunta
-   si abre una rama o la desbloquea («desbloquea main»).
+1. Si la rama principal está abierta (proyectos sencillos), el agente trabaja en ella sin preguntar.
+   Si está cerrada (código a largo plazo, CI o equipo), pregunta antes de cada cambio: ¿esta rama,
+   una nueva, o desbloquear? Nunca abre una rama por su cuenta. Cambiarlo: «desbloquea main» o «bloquea main».
 2. Si otra sesión de un asistente está trabajando en esta misma carpeta, el trabajo nuevo va a un
    worktree en .worktrees/<rama>/. Para no hacerlo: «no uses worktrees».
 3. El agente elige solo entre FTD (lo sencillo) y SDD (lo grande o complejo) y lo dice; se puede

package/targets/trunk-policy.mjs

@@ -16,6 +16,8 @@ import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 export const UNLOCK = '.no-trunk-guard';
+/** «ramas y PR», chosen at install or with `rsc main lock`: closed whatever the signals say. */
+export const LOCK = '.no-trunk-open';
 
 const CI = ['.github/workflows', '.gitlab-ci.yml', '.circleci', 'azure-pipelines.yml', 'Jenkinsfile',
   'bitbucket-pipelines.yml', '.buildkite', '.travis.yml', '.woodpecker.yml', '.drone.yml'];
@@ -59,11 +61,26 @@ export function defaultBranchName(root) {
   return null;
 }
 
-/** `{ closed, reason, signals }` — reason: 'unlocked' | 'simple' | 'signals'. */
+/** `{ closed, reason, signals }` — reason: 'unlocked' | 'locked' | 'simple' | 'signals'. */
 export function trunkPolicy(root) {
   if (existsSync(join(root, '.rsc', UNLOCK))) return { closed: false, reason: 'unlocked', signals: [] };
+  if (existsSync(join(root, '.rsc', LOCK))) return { closed: true, reason: 'locked', signals: ['ramas y PR, decidido para este proyecto'] };
   const signals = trunkSignals(root);
   return signals.length ? { closed: true, reason: 'signals', signals } : { closed: false, reason: 'simple', signals };
 }
 
 export const trunkClosed = (root) => trunkPolicy(root).closed;
+
+/**
+ * The branch rule for THIS project, said every turn (2026-10-06, Eric): where the default branch is
+ * open the agent works on it and never asks; where it is closed it asks before each code change —
+ * this branch, a new one, or unlocking — and never branches on its own.
+ */
+export function branchRuleLine(root) {
+  const trunk = defaultBranchName(root) || 'main';
+  const policy = trunkPolicy(root);
+  if (!policy.closed) return `- Here "${trunk}" is OPEN: code changes go straight on it. Do not ask about branches.\n`;
+  const here = git(root, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+  const options = here && here !== trunk ? `this branch ("${here}"), a new branch, or unlock "${trunk}"` : `a new branch, or unlock "${trunk}"`;
+  return `- Here "${trunk}" is CLOSED (${policy.signals.join(', ')}): before EACH code change ask: ${options}? Never choose alone.\n`;
+}

package/targets/userprompt-gate.mjs

@@ -28,4 +28,11 @@ const hook = readHookInput();
 const turnKey = hook.prompt_id || (hook.prompt ? `p${hook.prompt.length}:${hook.prompt.slice(0, 64)}` : null);
 if (hook.session_id && turnKey && !claimOnce(`up:${hook.session_id}:${turnKey}`)) process.exit(0);
 
-process.stdout.write(SDD_GATE_TEXT);
+// The branch rule depends on THIS project (open or closed default branch), so it is computed here and
+// said right after the gate. trunk-policy.mjs is a sibling under .rsc/; without it, the safe default.
+let rule = '- Default branch state unknown: ask before a code change where it goes.\n';
+try {
+  const { branchRuleLine } = await import(new URL('./trunk-policy.mjs', import.meta.url));
+  rule = branchRuleLine(root);
+} catch { /* fail-open */ }
+process.stdout.write(SDD_GATE_TEXT + rule);