@ericrisco/rsc 2.2.0 → 3.0.0

package/targets/knowledge-wiring.js

@@ -0,0 +1,172 @@
+// Wiring for knowledge sync (`knowledge-sync.mjs`): two lifecycle events per assistant — the person
+// sends a message, the agent finishes — in the same project-local config files the session memory
+// uses, under a needle of its own so either can be wired or removed without touching the other.
+//
+// Kept apart from `memory.js` on purpose. The memory's promise is that it makes no network request,
+// and a test holds every file it wires to that; knowledge sync exists to talk to `origin`. Riding
+// inside the memory would have broken the promise and tied the two switches together.
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const NEEDLE = '.rsc/knowledge-sync.mjs';
+const PLUGIN_MARKER = 'rsc-knowledge:managed';
+
+/** Same files as the memory: project-local, untracked, the assistant's own hook config. */
+const CONFIG = Object.freeze({
+  claude: '.claude/settings.local.json',
+  codex: '.codex/hooks.json',
+  cursor: '.cursor/hooks.json',
+  gemini: '.gemini/settings.json',
+  opencode: '.opencode/plugins/rsc-knowledge.js',
+});
+
+const EVENTS = Object.freeze({
+  claude: [['UserPromptSubmit', 'request'], ['Stop', 'turn']],
+  codex: [['UserPromptSubmit', 'request'], ['Stop', 'turn']],
+  gemini: [['BeforeAgent', 'request'], ['AfterAgent', 'turn']],
+  cursor: [['beforeSubmitPrompt', 'request'], ['afterAgentResponse', 'turn']],
+});
+
+export const KNOWLEDGE_TARGETS = Object.freeze(Object.keys(CONFIG));
+
+const git = (cwd, args) => {
+  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+};
+const rel = (cwd, path) => relative(cwd, path).split(sep).join('/');
+const tracked = (cwd, path) => Boolean(git(cwd, ['ls-files', '--', rel(cwd, path)]));
+
+function exclude(cwd, path) {
+  if (git(cwd, ['rev-parse', '--is-inside-work-tree']) !== 'true') return;
+  const value = git(cwd, ['rev-parse', '--git-path', 'info/exclude']);
+  if (!value) return;
+  const file = isAbsolute(value) ? value : resolve(cwd, value);
+  const pattern = `/${rel(cwd, path)}`;
+  mkdirSync(dirname(file), { recursive: true });
+  const body = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  if (!body.split('\n').includes(pattern)) appendFileSync(file, `${body && !body.endsWith('\n') ? '\n' : ''}${pattern}\n`);
+}
+
+function readConfig(path) {
+  if (!existsSync(path)) return {};
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+const validHookConfig = (c) => Boolean(c) && typeof c === 'object' && !Array.isArray(c)
+  && (!Object.hasOwn(c, 'hooks') || (c.hooks && typeof c.hooks === 'object' && !Array.isArray(c.hooks) && Object.values(c.hooks).every(Array.isArray)));
+
+function handler(target, event) {
+  const script = target === 'claude'
+    ? '"${CLAUDE_PROJECT_DIR}/.rsc/knowledge-sync.mjs"'
+    : target === 'codex'
+      ? '"$(git rev-parse --show-toplevel)/.rsc/knowledge-sync.mjs"'
+      : '".rsc/knowledge-sync.mjs"';
+  const value = { type: 'command', command: `node ${script} hook ${target} ${event}`, timeout: target === 'gemini' ? 10000 : 10 };
+  if (target === 'codex') value.commandWindows = `node "$((git rev-parse --show-toplevel).Trim())/.rsc/knowledge-sync.mjs" hook ${target} ${event}`;
+  if (target === 'gemini') value.name = `rsc-knowledge-${event}`;
+  return value;
+}
+
+function strip(config) {
+  if (!validHookConfig(config) || !config.hooks) return config;
+  for (const event of Object.keys(config.hooks)) {
+    config.hooks[event] = config.hooks[event].filter((e) => !JSON.stringify(e).replaceAll('\\\\', '/').includes(NEEDLE));
+    if (!config.hooks[event].length) delete config.hooks[event];
+  }
+  if (!Object.keys(config.hooks).length) delete config.hooks;
+  return config;
+}
+
+const PLUGIN = `// ${PLUGIN_MARKER}
+// rsc knowledge sync for OpenCode. OpenCode has no prompt event and no channel to the person, so what
+// sync has to say goes to the model, to be relayed. Cheap on every call: the fetch is throttled and
+// every notice is said once. Turn it off with \`rsc knowledge-sync off\`.
+import { onRequest, onTurn } from '../../.rsc/knowledge-sync.mjs';
+
+export const RscKnowledgePlugin = async ({ directory, worktree }) => {
+  const cwd = worktree || directory;
+  const local = () => process.env.RSC_REMOTE_AGENT !== '1' && process.env.OPENCODE_REMOTE !== '1';
+  return {
+    'experimental.chat.system.transform': async (_input, output) => {
+      if (!local()) return;
+      try {
+        const said = onRequest(cwd);
+        if (said && Array.isArray(output?.system)) output.system.push(\`Cuéntale esto al usuario en una línea:\\n\${said}\`);
+      } catch { /* fail open */ }
+    },
+    event: async ({ event }) => {
+      if (event?.type === 'session.idle' && local()) { try { onTurn(cwd); } catch { /* fail open */ } }
+    },
+  };
+};
+`;
+
+export function knowledgeManagedPaths(target, cwd = process.cwd()) {
+  if (!CONFIG[target]) return [];
+  return [join(cwd, '.rsc', 'knowledge-sync.mjs'), join(cwd, '.rsc', 'trunk-policy.mjs'), join(cwd, ...CONFIG[target].split('/'))];
+}
+
+/** Wire it. Always, when the assistant supports it: being off is the runtime's `.no-knowledge-sync`. */
+export function wireKnowledge(target, cwd = process.cwd()) {
+  if (!CONFIG[target]) return { mode: 'unsupported', paths: [] };
+  const configPath = join(cwd, ...CONFIG[target].split('/'));
+  if (tracked(cwd, configPath)) return { mode: 'degraded', reason: 'config-tracked', paths: [] };
+  if (target === 'opencode' && existsSync(configPath) && !readFileSync(configPath, 'utf8').includes(PLUGIN_MARKER)) {
+    return { mode: 'degraded', reason: 'plugin-collision', paths: [] };
+  }
+  const config = target === 'opencode' ? null : readConfig(configPath);
+  if (target !== 'opencode' && !validHookConfig(config)) return { mode: 'degraded', reason: 'config-invalid', paths: [] };
+
+  const script = join(cwd, '.rsc', 'knowledge-sync.mjs');
+  mkdirSync(dirname(script), { recursive: true });
+  copyFileSync(join(HERE, 'knowledge-sync.mjs'), script);
+  // Its sibling import: whether the default branch is closed decides if sync may commit there.
+  copyFileSync(join(HERE, 'trunk-policy.mjs'), join(cwd, '.rsc', 'trunk-policy.mjs'));
+  mkdirSync(dirname(configPath), { recursive: true });
+  if (target === 'opencode') writeFileSync(configPath, PLUGIN);
+  else {
+    strip(config);
+    config.hooks ||= {};
+    if (target === 'cursor') config.version ||= 1;
+    for (const [event, op] of EVENTS[target]) {
+      config.hooks[event] ||= [];
+      const h = handler(target, op);
+      if (target === 'cursor') { delete h.type; delete h.timeout; config.hooks[event].push(h); }
+      else config.hooks[event].push({ hooks: [h] });
+    }
+    // A fixed event order. The memory rewires by stripping and re-appending its own events, which
+    // moves them behind ours; without this, install and re-install write the same hooks in a
+    // different order and the onboarding receipt reads it as drift ("governed content differs").
+    config.hooks = Object.fromEntries(Object.keys(config.hooks).sort().map((k) => [k, config.hooks[k]]));
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  }
+  const paths = knowledgeManagedPaths(target, cwd);
+  for (const path of paths) exclude(cwd, path);
+  return { mode: 'wired', paths };
+}
+
+export function unwireKnowledge(target, cwd = process.cwd()) {
+  if (!CONFIG[target]) return [];
+  const path = join(cwd, ...CONFIG[target].split('/'));
+  const touched = [];
+  if (target === 'opencode') {
+    if (existsSync(path) && readFileSync(path, 'utf8').includes(PLUGIN_MARKER)) { rmSync(path, { force: true }); touched.push(path); }
+  } else if (existsSync(path) && readFileSync(path, 'utf8').replaceAll('\\\\', '/').includes(NEEDLE)) {
+    const config = readConfig(path);
+    if (config) { strip(config); writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`); touched.push(path); }
+  }
+  return touched;
+}
+
+export function knowledgeArtifactsPresent(target, cwd = process.cwd()) {
+  if (!CONFIG[target]) return [];
+  const out = [join(cwd, '.rsc', 'knowledge-sync.mjs')].filter(existsSync);
+  const path = join(cwd, ...CONFIG[target].split('/'));
+  if (existsSync(path)) {
+    const body = readFileSync(path, 'utf8').replaceAll('\\\\', '/');
+    if (body.includes(NEEDLE) || body.includes(PLUGIN_MARKER)) out.push(path);
+  }
+  return out;
+}

package/targets/opt-outs.js

@@ -23,8 +23,11 @@ export const PROJECT_OPT_OUTS = [
   'danger-guard',     // foot-gun denial, keyed to the committed user profile
   'feature-gate',     // per-turn re-injection of the SDD gate
   'gitmoji',          // the commit-message convention
+  '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
   '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
 ];
 
 /** Decisions of one machine: never written to the manifest, never applied from it. */

package/targets/session-memory-adapter.mjs

@@ -2,7 +2,7 @@
 import { fileURLToPath } from 'node:url';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve, join, dirname } from 'node:path';
-import { capture, resume } from './session-memory-core.mjs';
+import { capture, otherActiveSessions, resume } from './session-memory-core.mjs';
 
 const LOCAL_TARGETS = new Set(['claude', 'codex', 'cursor', 'gemini', 'opencode']);
 
@@ -88,6 +88,23 @@ function nativeOutput(target, eventName, context = '', notice = null, compaction
   };
 }
 
+/**
+ * team-safe-default B, the half the skills act on: when another session is working in this same
+ * checkout, the model is told — every message, while it lasts — to do new work in a worktree. Local
+ * journal only, no network (the memory's promise stands). `.no-worktree-isolation` turns it off.
+ */
+export function isolationContext({ project, here, sessionId, target }) {
+  if (existsSync(join(project, '.rsc', '.no-worktree-isolation'))) return '';
+  const others = otherActiveSessions({ cwd: project, worktreeCwd: here, sessionId, target });
+  if (!others.length) return '';
+  const who = others.map((o) => `${o.target}${o.branch ? ` en «${o.branch}»` : ''}`).join(', ');
+  return `rsc · aislamiento: otra sesión está trabajando en esta misma carpeta (${who}). ` +
+    'Cualquier cambio de esta petición se hace en un worktree dentro del proyecto: ' +
+    '`git worktree add .worktrees/<rama> -b <rama>` y se trabaja dentro de `.worktrees/<rama>/`. ' +
+    'No cambies de rama en esta carpeta. Dile a la persona en una línea dónde estás trabajando, para que ' +
+    'abra o levante el proyecto desde allí.';
+}
+
 export function contextFromNativeOutput(target, output = {}) {
   if (target === 'cursor') return output.additional_context || '';
   if (target === 'opencode') return output.context || '';
@@ -135,8 +152,9 @@ export function handleLifecycle({ target, event, native = {}, cwd, settings } =
     // nine rounds of hook → "—" → hook before the client broke the loop. Record the turn, say
     // nothing.
     const silenced = event === 'turn' && Boolean(native?.stop_hook_active);
+    const isolation = event === 'request' ? isolationContext({ project, here, sessionId: id, target }) : '';
     return {
-      output: silenced ? {} : nativeOutput(target, eventName, '', captured.notice, captured.compactionHint),
+      output: silenced ? {} : nativeOutput(target, eventName, isolation, captured.notice, captured.compactionHint),
       capture: captured,
       remote: false,
       degraded: false,

package/targets/session-memory-core.mjs

@@ -258,6 +258,39 @@ function activeConcurrent(records, sessionId, target, worktree, now) {
     && !record?.timestamps?.completedAt && new Date(record?.timestamps?.updatedAt || 0).getTime() >= recent);
 }
 
+/** How long a session counts as "working here" after its last recorded event (team-safe-default B). */
+export const ACTIVE_WINDOW_MS = 30 * 60 * 1000;
+
+/**
+ * Other sessions working in THIS checkout right now: any assistant with rsc, same worktree, an event
+ * in the last 30 minutes, not closed, and not the asking session itself. It answers WHO is working,
+ * never WHAT is in the project (constitution P3), reads only the local journal (no network, no
+ * content), and its worst failure is one worktree too many or too few.
+ *
+ * A session that only talks has no record — the journal only writes when there is work — and that is
+ * the right blind spot: the harm this prevents is switching branches under a session that is EDITING.
+ */
+export function otherActiveSessions(input = {}) {
+  try {
+    const cwd = resolve(input.cwd || process.cwd());
+    const top = git(resolve(input.worktreeCwd || cwd), ['rev-parse', '--show-toplevel']);
+    if (!top.ok) return [];
+    const here = resolve(top.out);
+    const store = chooseMemoryRoot(cwd);
+    if (!existsSync(store.root)) return [];
+    const now = new Date(input.now || Date.now()).getTime();
+    const windowMs = Number.isFinite(input.windowMs) ? input.windowMs : ACTIVE_WINDOW_MS;
+    return readRecords(store.root)
+      .filter((r) => r.worktree === here)
+      .filter((r) => !(r.sessionId === input.sessionId && r.target === input.target))
+      .filter((r) => !r.timestamps?.completedAt)
+      .filter((r) => now - new Date(r.timestamps?.updatedAt || 0).getTime() <= windowMs)
+      .map((r) => ({ target: r.target, sessionId: r.sessionId, branch: r.branch, updatedAt: r.timestamps.updatedAt }));
+  } catch {
+    return [];
+  }
+}
+
 export function validateSessionRecord(record) {
   const errors = [];
   if (!record || typeof record !== 'object' || Array.isArray(record)) return ['record: object required'];

package/targets/session-start.mjs

@@ -253,6 +253,17 @@ A no holds for this session. Permanent off: .rsc/.no-worktree-cleanup
   } catch { /* reaper missing or git unhappy → say nothing; this is never worth breaking startup for */ }
 }
 
+// team-safe-default (3.0): rescue commits stranded on a closed default branch, move old sibling
+// worktrees inside the project, and say once what 3.0 changed. Each is silent when there is nothing.
+if (has('.git')) {
+  try {
+    const T = await import('./team-safe-start.mjs');
+    for (const said of [T.teamSafeAnnouncement(root), await T.rescueTrunkCommits(root), await T.relocateOldWorktrees(root)]) {
+      if (said) process.stdout.write(said.startsWith('\n') ? said : `\n${said}\n`);
+    }
+  } catch { /* module missing → nothing to do; never worth breaking startup for */ }
+}
+
 // Update check and auto-update: the rule lives in auto-update.mjs, shared with the other assistants.
 // Disable with RSC_NO_UPDATE_CHECK=1.
 if (!process.env.RSC_NO_UPDATE_CHECK) process.stdout.write(await updateNotice(root));

package/targets/team-safe-start.mjs

@@ -0,0 +1,115 @@
+// What a session start does for team-safe-default (rsc 3.0), beyond saying hello:
+//
+//   rescueTrunkCommits    — commits sitting on a CLOSED default branch that never reached the remote
+//                           (left there by an agent before 3.0) move to a `rescue/…` branch, and the
+//                           default branch goes back to what the remote has. Spec clarify P4.
+//   relocateOldWorktrees  — worktrees older versions made OUTSIDE the project (sibling folders) move
+//                           into `.worktrees/`. Only the ones rsc made, never one a session is working
+//                           in, and a failure leaves it where it was. Spec clarify P6.
+//   teamSafeAnnouncement  — once per project and machine, what changed in 3.0 and how to turn each
+//                           part off. Spec, global criterion.
+//
+// Each returns the text to say, or ''. None throws: a session start is never worth breaking.
+// Standalone siblings under `.rsc/`: trunk-policy.mjs, worktree-reaper.mjs, session-memory-core.mjs.
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, realpathSync, writeFileSync } from 'node:fs';
+import { basename, join, sep } from 'node:path';
+
+const git = (root, args) => {
+  try { return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 8000 }).trim(); }
+  catch { return null; }
+};
+const ok = (root, args) => git(root, args) !== null;
+const real = (p) => { try { return realpathSync(p); } catch { return p; } };
+const stamp = () => new Date().toISOString().slice(0, 16).replace(/[-:T]/g, '').replace(/^(\d{8})(\d{4})$/, '$1-$2');
+
+const RESCUE_MARK = '.team-safe-3-rescue';
+
+/** Once per project and machine, the first session with 3.0 (spec P4): after that, commits on the
+ *  default branch are the person's own business (P3), never moved again (review M1). */
+export async function rescueTrunkCommits(root) {
+  try {
+    const mark = join(root, '.rsc', RESCUE_MARK);
+    if (existsSync(mark)) return '';
+    mkdirSync(join(root, '.rsc'), { recursive: true });
+    writeFileSync(mark, `${new Date().toISOString()}\n`);
+    const { trunkPolicy, defaultBranchName } = await import(new URL('./trunk-policy.mjs', import.meta.url));
+    const branch = git(root, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const trunk = defaultBranchName(root);
+    if (!branch || !trunk || branch !== trunk || !trunkPolicy(root).closed) return '';
+    const remote = `refs/remotes/origin/${trunk}`;
+    if (!git(root, ['rev-parse', '--verify', '--quiet', remote])) return '';
+    const ahead = Number(git(root, ['rev-list', '--count', `${remote}..HEAD`]) || 0);
+    if (!ahead) return '';
+    const name = `rescue/${trunk}-${stamp()}`;
+    if (!ok(root, ['branch', name, 'HEAD'])) return '';
+    // --keep refuses instead of losing anything: a change in progress that the reset would touch.
+    if (!ok(root, ['reset', '--quiet', '--keep', remote])) {
+      return `rsc · ${ahead} commit(s) en «${trunk}» que no están en el remoto, y este proyecto tiene «${trunk}» cerrada para el agente. ` +
+        `Los he copiado a la rama «${name}», pero no he podido dejar «${trunk}» como en el remoto porque hay cambios sin guardar que se verían afectados. ` +
+        `Díselo a la persona en una línea; cuando esos cambios estén a salvo: \`git reset --keep origin/${trunk}\`.`;
+    }
+    return `rsc · Había ${ahead} commit(s) en «${trunk}» que nunca llegaron al remoto, y en este proyecto «${trunk}» está cerrada para el agente. ` +
+      `Los he movido a la rama «${name}» y «${trunk}» vuelve a estar igual que en el remoto. Díselo a la persona en una línea.`;
+  } catch { return ''; }
+}
+
+export async function relocateOldWorktrees(root) {
+  try {
+    const W = await import(new URL('./worktree-reaper.mjs', import.meta.url));
+    // Moving a folder is destructive, so this fails closed: without the memory nobody can be seen
+    // working, and then nothing is moved. A session in an old sibling keeps its journal in the
+    // sibling's own store (it has its own .rsc.json), so both stores are asked (review H3).
+    let M;
+    try { M = await import(new URL('./session-memory-core.mjs', import.meta.url)); } catch { return ''; }
+    const others = (path) => [
+      ...M.otherActiveSessions({ cwd: root, worktreeCwd: path }),
+      ...M.otherActiveSessions({ cwd: path, worktreeCwd: path }),
+    ];
+    const home = real(root);
+    const moved = [];
+    const left = [];
+    for (const wt of W.listWorktrees(root)) {
+      const path = real(wt.path);
+      if (path === home || path.startsWith(home + sep)) continue; // already inside
+      if (W.provenanceOf(root, { ...wt, path }) !== 'rsc') continue;
+      if (others(path).length) { left.push(`${path} (una sesión trabaja en él)`); continue; }
+      const name = basename(path);
+      const dest = join(home, '.worktrees', name.startsWith(`${basename(home)}-`) ? name.slice(basename(home).length + 1) : name);
+      if (existsSync(dest)) { left.push(`${path} (ya existe ${dest})`); continue; }
+      mkdirSync(join(home, '.worktrees'), { recursive: true });
+      if (ok(root, ['worktree', 'move', path, dest])) moved.push(`${path} → .worktrees/${basename(dest)}`);
+      else left.push(`${path} (git no ha podido moverlo)`);
+    }
+    if (!moved.length && !left.length) return '';
+    return [
+      moved.length ? `rsc · Worktrees de versiones antiguas movidos dentro del proyecto: ${moved.join('; ')}.` : '',
+      left.length ? `rsc · Sin mover, se reintenta en otra sesión: ${left.join('; ')}.` : '',
+      'Díselo a la persona en una línea.',
+    ].filter(Boolean).join(' ');
+  } catch { return ''; }
+}
+
+const MARK = '.team-safe-3';
+
+export function teamSafeAnnouncement(root) {
+  try {
+    const mark = join(root, '.rsc', MARK);
+    if (existsSync(mark)) return '';
+    mkdirSync(join(root, '.rsc'), { recursive: true });
+    writeFileSync(mark, `${new Date().toISOString()}\n`);
+    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».
+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
+   pedir el otro.
+4. 01-TOOLS/ y 02-DOCS/ viajan al equipo por la rama rsc/knowledge y llegan a la principal dentro de
+   las PRs. Para apagarlo: rsc knowledge-sync off.
+==============================================
+`;
+  } catch { return ''; }
+}

package/targets/trunk-policy.mjs

@@ -0,0 +1,69 @@
+// Is the default branch closed for the agent in this project? (team-safe-default, part A)
+//
+// The spec leaves the call to the agent, change by change: complex or in production → branches;
+// simple (scripts, research, personal) → straight on the default branch. That is judgement, and
+// constitution P1 sends judgement to the skills. This module is only the FLOOR: the signals anyone
+// can count — there is CI, there is a deployment, there is a team — which are the spec's own examples
+// of "complejo o con producción". No signal: the floor stays open and the skill decides. A signal: the
+// floor closes, and if the project is in fact simple the way out is the person asking to unlock it.
+//
+// `.rsc/.no-trunk-guard` is that unlock: a PROJECT switch (it travels in `.rsc.json` optOuts), set
+// when somebody asks the agent «desbloquea main».
+//
+// Standalone on purpose: copied next to `branch-guard.mjs` and `knowledge-sync.mjs` under `.rsc/`.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const UNLOCK = '.no-trunk-guard';
+
+const CI = ['.github/workflows', '.gitlab-ci.yml', '.circleci', 'azure-pipelines.yml', 'Jenkinsfile',
+  'bitbucket-pipelines.yml', '.buildkite', '.travis.yml', '.woodpecker.yml', '.drone.yml'];
+const DEPLOY = ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml',
+  'vercel.json', 'netlify.toml', 'fly.toml', 'render.yaml', 'railway.json', 'railway.toml', 'Procfile',
+  'app.yaml', 'serverless.yml', 'wrangler.toml', 'k8s', 'helm', 'Chart.yaml'];
+const TEAM_COMMITS = 50;
+
+function git(root, args) {
+  try {
+    return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000 }).trim();
+  } catch { return null; }
+}
+
+const present = (root, rel) => {
+  const path = join(root, rel);
+  if (!existsSync(path)) return false;
+  try { return readdirSync(path).length > 0; } catch { return true; } // a file, not a folder
+};
+
+/** The countable reasons this project looks complex or in production. Empty = looks simple. */
+export function trunkSignals(root) {
+  const out = [];
+  const ci = CI.find((rel) => present(root, rel));
+  if (ci) out.push(`CI (${ci})`);
+  const deploy = DEPLOY.find((rel) => present(root, rel));
+  if (deploy) out.push(`despliegue (${deploy})`);
+  const authors = new Set((git(root, ['log', `-${TEAM_COMMITS}`, '--format=%ae']) || '').split('\n').filter(Boolean));
+  if (authors.size >= 2) out.push(`equipo (${authors.size} personas en los últimos ${TEAM_COMMITS} commits)`);
+  return out;
+}
+
+/** The default branch's name: the remote's HEAD, else main/master, else null. */
+export function defaultBranchName(root) {
+  const head = git(root, ['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD']);
+  if (head) return head.replace(/^refs\/remotes\/origin\//, '');
+  for (const b of ['main', 'master']) {
+    if (git(root, ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${b}`])) return b;
+    if (git(root, ['rev-parse', '--verify', '--quiet', `refs/heads/${b}`])) return b;
+  }
+  return null;
+}
+
+/** `{ closed, reason, signals }` — reason: 'unlocked' | 'simple' | 'signals'. */
+export function trunkPolicy(root) {
+  if (existsSync(join(root, '.rsc', UNLOCK))) return { closed: false, reason: 'unlocked', signals: [] };
+  const signals = trunkSignals(root);
+  return signals.length ? { closed: true, reason: 'signals', signals } : { closed: false, reason: 'simple', signals };
+}
+
+export const trunkClosed = (root) => trunkPolicy(root).closed;