@ericrisco/rsc 3.0.3 → 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 |
 | --- | --- | --- |
-| **Main is closed where it matters** | In a project that is complex or in production, the agent never commits on the default branch. It opens a branch on its own (`feat/…`, `fix/…`) and finishes with a pull request. In a project of scripts or research it works on `main`, because a branch there is only ceremony. | 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` |
@@ -99,12 +99,13 @@ rsc git-permissions on       # turn it on, also for a project adopted before
 **How does it know a project is "complex or in production"?** There are two layers. A hook counts
 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. If none is, the agent decides change by change, using the same rule from
-its skills. If the hook gets it wrong and the project really is simple, «unlock main» opens it for
+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 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: which branch to open, how to create the worktree, or how to
-unlock. An agent is never left stuck. The rules only see what the **agent** runs; a person
+Every refusal says how to carry on, and the choice between a branch and unlocking goes back to you.
+An agent is never left stuck. The rules only see what the **agent** runs; a person
 committing in their own terminal is never touched.
 
 **The first session after upgrading** does three things, once:
@@ -467,6 +468,8 @@ new    · clones main    has it all after the first message
   only its `01-TOOLS/` and `02-DOCS/` part, under a `docs(auto) … [skip ci]` message.
 - **Before each message**, what teammates sent is brought into **the branch you are on**, and you are
   told in one line. Only the knowledge folders are touched.
+  A branch you open later catches up on its first message: everything on `rsc/knowledge` since it
+  left `main` comes down, including what you wrote yourself on another branch.
 - **It reaches `main` the normal way.** Your feature branch now carries the team's knowledge, so it
   arrives in `main` inside the pull request you were going to open anyway. There is no extra pull
   request from `rsc/knowledge`, and nobody has to merge it.

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.3",
+  "version": "3.0.5",
   "counts": {
     "skills": 270,
     "agents": 33,
@@ -1911,7 +1911,7 @@
     },
     {
       "id": "ftd",
-      "description": "Use for ordinary authorised change — the default lane once the decisor has ruled out a question and not selected the chain. Keeps one feature document per feature in 02-DOCS holding intent, scope, checklist, evidence and next step, checks tasks off only against observed proof, and branches when the work writes code. NOT the ten-phase chain (that is `sdd`), NOT the classification itself (that is the decisor in `suggest`), NOT a request for information, which writes nothing.",
+      "description": "Use for ordinary authorised change — the default lane once the decisor has ruled out a question and not selected the chain. Keeps one feature document per feature in 02-DOCS holding intent, scope, checklist, evidence and next step, checks tasks off only against observed proof, and asks whether to branch before the work writes code. NOT the ten-phase chain (that is `sdd`), NOT the classification itself (that is the decisor in `suggest`), NOT a request for information, which writes nothing.",
       "tags": [
         "ftd",
         "lane",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.3",
+  "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

@@ -1,6 +1,6 @@
 ---
 name: ftd
-description: "Use for ordinary authorised change — the default lane once the decisor has ruled out a question and not selected the chain. Keeps one feature document per feature in 02-DOCS holding intent, scope, checklist, evidence and next step, checks tasks off only against observed proof, and branches when the work writes code. NOT the ten-phase chain (that is `sdd`), NOT the classification itself (that is the decisor in `suggest`), NOT a request for information, which writes nothing."
+description: "Use for ordinary authorised change — the default lane once the decisor has ruled out a question and not selected the chain. Keeps one feature document per feature in 02-DOCS holding intent, scope, checklist, evidence and next step, checks tasks off only against observed proof, and asks whether to branch before the work writes code. NOT the ten-phase chain (that is `sdd`), NOT the classification itself (that is the decisor in `suggest`), NOT a request for information, which writes nothing."
 tags: [ftd, lane, default, feature-document, evidence]
 recommends: [worktrees, debug, verify]
 profiles: [minimal, core, full]
@@ -53,14 +53,19 @@ the chain: a result asserted without evidence is treated as not done.
 
 ## Isolation
 
-Where the work runs depends on the project, judged change by change (team-safe-default):
-
-- **Complex or in production** (deploys, CI, several people committing, a protected default branch)
-  → a branch, never the default branch. Open it yourself, named by intent, and close it with a pull
-  request. Something unrelated to the current branch gets its own branch from the default one.
-- **Simple** (scripts, research, personal) → the default branch is fine.
+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. rsc tells you when that is the case.
+  branch switch under the other session. Not a question: rsc tells you when that is the case.
 
 A worktree only when another session is there: alone, setting one up costs more than it protects.
 

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.** Implementation happens on a feature branch or worktree, never directly on
-   the default branch. If you are on `main`/`master`, stop and hand to `worktrees` before the first
-   commit.
+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.
 
@@ -314,7 +314,7 @@ outranks the plan, and the plan outranks your in-the-moment preference.
 - **Unresolved `analyze` findings** (contradiction between constitution ↔ spec ↔ plan ↔ tasks) →
   resolve them before any code; they will only get more expensive after the diff exists.
 - **A task forces a constitution violation** → surface it, stop, kick it back to `analyze`/`plan`.
-- **You're on the default branch** → stop before the first commit; hand to `worktrees`.
+- **You're on the default branch** → stop before the first commit and ask: branch or default branch (`worktrees`).
 - **A test won't go red** (wrong reason — import error, syntax) → fix the test before trusting it.
 - **The combined suite is red after a parallel merge** → do not checkpoint as done; debug with
   `debug` before continuing.

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.** Complex or in production → never commit on the default branch: branch yourself, close with
-a PR. Simple → the default branch. Another session in this checkout → `.worktrees/<branch>`. «desbloquea
-main» = `rsc main unlock`; «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,11 +27,11 @@ constitution → specify → clarify → plan → tasks → analyze → [ worktr
 
 ## The one rule that defines this step
 
-**Never run `implement` on the default branch.** The moment a plan is about to become commits, the
-work belongs in isolation. If `git rev-parse --abbrev-ref HEAD` says `main` or `master`, you stop
-and create the isolated workspace *first* — before the first edit, not after the diff already exists
-on the wrong branch. Recovering a half-built feature off `main` is strictly more expensive than
-branching one command earlier.
+**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/branch-guard.mjs

@@ -152,14 +152,16 @@ async function othersHere({ root, here, sessionId, self }) {
 }
 
 async function trunkDenial({ root, here, sessionId, self, trunk, policy }) {
-  // Where the branch goes depends on rule B: alone → this same folder; with company → .worktrees/.
+  // Where a branch would go depends on rule B: alone → this same folder; with company → .worktrees/.
+  // Whether to branch at all is the person's call: the agent asks, it never branches on its own.
   const others = existsSync(join(root, '.rsc', '.no-worktree-isolation')) ? [] : await othersHere({ root, here, sessionId, self });
-  const where = others.length
-    ? 'Another session is working in this folder, so open it as a worktree inside the project: `git worktree add .worktrees/<branch> -b feat/<what-you-are-doing>` and commit inside `.worktrees/<branch>/`'
-    : 'You are the only session here, so stay in this same folder, no worktree: `git switch -c feat/<what-you-are-doing>` (or fix/…, docs/…) and commit there';
-  return `This project keeps its default branch "${trunk}" closed for the agent (it looks complex or in production: ${policy.signals.join(', ')}). ` +
-    `Do this work on a branch instead. ${where}; it reaches "${trunk}" through a pull request. ` +
-    'If this project is actually simple and the person asks to unlock it, run `npx @ericrisco/rsc main unlock` (a project decision, saved in .rsc.json).';
+  const branch = others.length
+    ? '`git worktree add .worktrees/<branch> -b feat/<what>` and commit inside `.worktrees/<branch>/` (another session is working in this folder)'
+    : '`git switch -c feat/<what>` in this same folder, no worktree';
+  return `This project keeps its default branch "${trunk}" closed for the agent (it looks complex or in production: ${policy.signals.join(', ')}), so this commit was not made. ` +
+    `Do not choose for the person: ask them in one line whether to open a branch for this change or to unlock "${trunk}". ` +
+    `Branch → ${branch}; it reaches "${trunk}" through a pull request. ` +
+    'Unlock → only on their explicit answer, `npx @ericrisco/rsc main unlock` (a project decision, saved in .rsc.json), then commit again.';
 }
 
 async function isolationDenial({ root, here, sessionId, self }) {

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).
-- Complex/production: no commits on the default branch, branch + PR. Simple:
-  default branch. 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/knowledge-sync.mjs

@@ -104,7 +104,7 @@ const worktreeBlob = (root, path) => (existsSync(join(root, path)) ? line(root,
 function readState(root) {
   let s = {};
   try { s = JSON.parse(readFileSync(join(root, '.rsc', STATE), 'utf8')); } catch { /* first run */ }
-  return { announced: false, seen: null, queue: [], ours: [], notices: [], lastFetch: 0, snap: null, head: null, ...s };
+  return { announced: false, seenBy: {}, queue: [], ours: [], notices: [], lastFetch: 0, snap: null, head: null, ...s };
 }
 
 function writeState(root, s) {
@@ -375,30 +375,35 @@ export function applyIncoming(root, s) {
   if (!branch || branch === 'HEAD') return said;
   const tip = line(root, ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${KNOWLEDGE_BRANCH}`]);
   if (!tip) return said;
-  if (!s.seen || !line(root, ['rev-parse', '--verify', '--quiet', `${s.seen}^{commit}`])) {
-    s.seen = line(root, ['merge-base', 'HEAD', tip]) || tip;
+  // Per branch, not per repo: a branch opened from main after the last sync starts behind what
+  // rsc/knowledge already has, and a single "last seen" made it look up to date (2026-10-06). A branch
+  // seen for the first time catches up from where it left rsc/knowledge.
+  s.seenBy = s.seenBy && typeof s.seenBy === 'object' ? s.seenBy : {};
+  let seen = s.seenBy[branch];
+  if (!seen || !line(root, ['rev-parse', '--verify', '--quiet', `${seen}^{commit}`])) {
+    seen = line(root, ['merge-base', 'HEAD', tip]) || tip;
   }
-  if (s.seen === tip) return said;
+  if (seen === tip) { s.seenBy[branch] = tip; return said; }
   const paths = [...KNOWLEDGE];
-  const theirs = git(root, ['rev-list', `${s.seen}..${tip}`, '--', ...paths]).split('\n').filter(Boolean)
-    .filter((c) => !s.ours.includes(c));
-  if (!theirs.length) { s.seen = tip; return said; }
+  const commits = git(root, ['rev-list', `${seen}..${tip}`, '--', ...paths]).split('\n').filter(Boolean);
+  if (!commits.length) { s.seenBy[branch] = tip; return said; }
 
-  const know = zlist(git(root, ['diff', '--name-only', '--no-renames', '-z', s.seen, tip, '--', ...paths]))
+  const know = zlist(git(root, ['diff', '--name-only', '--no-renames', '-z', seen, tip, '--', ...paths]))
     .filter(isKnowledge).slice(0, MAX_FILES);
-  const who = authorsOf(root, theirs);
   const closed = branch === defaultBranch(root) && trunkClosed(root);
+  const touchedBy = (f) => git(root, ['rev-list', `${seen}..${tip}`, '--', f]).split('\n').filter(Boolean);
   const take = [];
   const clash = [];
   for (const f of know) {
     const incoming = blob(root, tip, f);
     const mine = worktreeBlob(root, f);
     if (mine === incoming) continue;
-    const base = blob(root, s.seen, f);
+    const base = blob(root, seen, f);
     // On a closed trunk HEAD lags behind on purpose (what came in was not committed), so only the
     // working tree says whether you touched it (review H2).
     if (mine === base && (closed || blob(root, 'HEAD', f) === base)) take.push(f);
-    else clash.push(f);
+    // Touched here and changed only by your own uploads: your newer version, not a clash.
+    else if (touchedBy(f).some((c) => !s.ours.includes(c))) clash.push(f);
   }
 
   if (take.length) {
@@ -414,12 +419,16 @@ export function applyIncoming(root, s) {
     } else {
       git(root, ['--literal-pathspecs', 'reset', '--quiet', '--', ...take]); // updated, not staged
     }
-    said.push(`📥 Traídos ${theirs.length} cambio(s) de conocimiento de ${who}: ${listed(take)}.`);
+    const from = [...new Set(take.flatMap(touchedBy))];
+    const theirs = from.filter((c) => !s.ours.includes(c));
+    const who = theirs.length ? authorsOf(root, theirs) : 'ti, desde otra rama';
+    said.push(`📥 Traídos ${from.length} cambio(s) de conocimiento de ${who}: ${listed(take)}.`);
   }
   if (clash.length) {
+    const who = authorsOf(root, [...new Set(clash.flatMap(touchedBy))].filter((c) => !s.ours.includes(c)));
     said.push(`${who} cambió ${listed(clash)}, que tú también has tocado. No lo traigo solo: tu versión sigue intacta.`);
   }
-  s.seen = tip;
+  s.seenBy[branch] = tip;
   return said;
 }
 

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,8 +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. En proyectos complejos o con producción, el agente no trabaja en la rama principal: abre ramas y
-   cierra con PR. En proyectos sencillos trabaja en la principal. Para abrirla: «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);