@damiangilgonzalez/harness 1.3.17 → 1.3.19

package/targets/knowledge-wiring.js

@@ -0,0 +1,196 @@
+// 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, { windowsHide: true, 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\`.
+// One file for both plugin APIs (issue #289): V1 calls the named export or server(); V2 reads id + setup.
+import { onRequest, onTurn } from '../../.rsc/knowledge-sync.mjs';
+
+const local = () => process.env.RSC_REMOTE_AGENT !== '1' && process.env.OPENCODE_REMOTE !== '1';
+const tell = (cwd) => {
+  if (!local()) return '';
+  try { const said = onRequest(cwd); return said ? \`Cuéntale esto al usuario en una línea:\\n\${said}\` : ''; } catch { return ''; }
+};
+const turn = (cwd) => { if (local()) { try { onTurn(cwd); } catch { /* fail open */ } } };
+
+export const RscKnowledgePlugin = async ({ directory, worktree }) => {
+  const cwd = worktree || directory;
+  return {
+    'experimental.chat.system.transform': async (_input, output) => {
+      const text = tell(cwd);
+      if (text && Array.isArray(output?.system)) output.system.push(text);
+    },
+    event: async ({ event }) => { if (event?.type === 'session.idle') turn(cwd); },
+  };
+};
+
+// V2 has no session.idle: a turn ends with session.execution.succeeded (or .failed).
+export default {
+  id: 'rsc.knowledge',
+  server: RscKnowledgePlugin,
+  async setup(ctx) {
+    const cwd = ctx.location?.project?.directory || ctx.location?.directory || process.cwd();
+    await ctx.session.hook('context', async (event) => {
+      const text = tell(cwd);
+      if (text && Array.isArray(event?.system)) event.system.push({ type: 'text', text });
+    });
+    const stop = new AbortController();
+    (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: stop.signal })) {
+          if (event?.type === 'session.execution.succeeded' || event?.type === 'session.execution.failed') turn(cwd);
+        }
+      } catch { /* unloading, or the stream ended: fail open */ }
+    })();
+    return () => stop.abort();
+  },
+};
+`;
+
+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/memory.js

@@ -76,10 +76,15 @@ function handler(target, event) {
     : target === 'codex'
       ? '"$(git rev-parse --show-toplevel)/.rsc/session-memory-adapter.mjs"'
       : '".rsc/session-memory-adapter.mjs"';
+  // PreCompact gets more room than the per-turn events. It runs once, right before a compaction that
+  // itself takes tens of seconds, so a longer ceiling costs nothing in the normal case; and a
+  // cancelled PreCompact is the one that loses the budget reset. The per-turn events keep 5 s:
+  // they run on every tool call and must stay cheap.
+  const seconds = event === 'compact' ? 15 : event === 'end' && target === 'codex' ? 3 : 5;
   const value = {
     type: 'command',
     command: `node ${unixScript} ${target} ${event}`,
-    timeout: target === 'gemini' ? 5000 : event === 'end' && target === 'codex' ? 3 : 5,
+    timeout: target === 'gemini' ? seconds * 1000 : seconds,
   };
   if (target === 'codex') {
     value.commandWindows = `node \"$((git rev-parse --show-toplevel).Trim())/.rsc/session-memory-adapter.mjs\" ${target} ${event}`;
@@ -99,6 +104,7 @@ const nestedEvents = {
     ['PostToolUse', 'edit', 'apply_patch|Edit|Write'], ['PostToolUse', 'boundary', 'Bash'],
     ['Stop', 'turn'], ['PreCompact', 'compact'], ['SessionEnd', 'end'],
   ],
+  // DeepSeek Harness runs Codex-format hooks through rsc's bridge: only these five points exist there.
   gemini: [
     ['SessionStart', 'start'], ['BeforeAgent', 'request'], ['AfterTool', 'edit', 'write_file|replace'],
     ['AfterTool', 'boundary', 'run_shell_command'], ['AfterAgent', 'turn'], ['PreCompress', 'compact'], ['SessionEnd', 'end'],

package/targets/opencode-memory-plugin.js

@@ -1,4 +1,6 @@
 // rsc-memory:managed
+// One file for both OpenCode plugin APIs (issue #289). V1 (1.x) calls the named export, or the default
+// export's server(); V2 (2.x) reads the default export's id + setup(ctx) and ignores the rest.
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { capture, resume } from '../../.rsc/session-memory-core.mjs';
@@ -15,51 +17,94 @@ function memorySettings(cwd) {
 
 function sessionId(input) {
   return input?.sessionID || input?.session_id || input?.event?.properties?.info?.id
-    || input?.event?.properties?.sessionID || null;
+    || input?.event?.properties?.sessionID || input?.event?.data?.sessionID || null;
 }
 
-export const RscMemoryPlugin = async ({ directory, worktree }) => {
-  const cwd = worktree || directory;
+/** What the plugin does, whichever API delivers the moment. `put(text)` adds to the system prompt. */
+function memory(cwd) {
   const injected = new Set();
   const local = () => process.env.RSC_REMOTE_AGENT !== '1' && process.env.OPENCODE_REMOTE !== '1';
   const save = (id, event, editDelta = 0) => {
     if (!id || !local()) return;
     try { capture({ cwd, sessionId: id, target: 'opencode', event, editDelta, settings: memorySettings(cwd) }); } catch { /* fail open */ }
   };
-
   return {
-    'experimental.chat.system.transform': async (input, output) => {
-      const id = sessionId(input);
+    save,
+    context(id, put) {
       if (!id || injected.has(id) || !local()) return;
       injected.add(id);
       try {
-        const config = memorySettings(cwd);
         save(id, 'start');
-        const result = resume({ cwd, target: 'opencode', settings: config });
-        if (!result.context || !Array.isArray(output?.system)) return;
-        if (output.system.length === 0) output.system.push(result.context);
-        else output.system[0] = `${output.system[0]}\n\n${result.context}`;
+        const result = resume({ cwd, target: 'opencode', settings: memorySettings(cwd) });
+        if (result.context) put(result.context);
       } catch { /* fail open */ }
     },
-    'tool.execute.after': async (input) => {
-      const tool = String(input?.tool || '').toLowerCase();
-      save(sessionId(input), 'boundary', /write|edit|patch/u.test(tool) ? 1 : 0);
+    tool(id, name) {
+      save(id, 'boundary', /write|edit|patch/u.test(String(name || '').toLowerCase()) ? 1 : 0);
     },
-    'experimental.session.compacting': async (input, output) => {
-      const id = sessionId(input);
+    compact(id, put) {
       save(id, 'compact');
       try {
         const result = resume({ cwd, target: 'opencode', settings: memorySettings(cwd) });
-        if (result.context && Array.isArray(output?.context)) output.context.push(result.context);
+        if (result.context) put(result.context);
       } catch { /* fail open */ }
     },
+  };
+}
+
+// ---------------------------------------------------------------- OpenCode 1.x (V1 plugin API)
+
+export const RscMemoryPlugin = async ({ directory, worktree }) => {
+  const m = memory(worktree || directory);
+  return {
+    'experimental.chat.system.transform': async (input, output) => {
+      if (!Array.isArray(output?.system)) return;
+      m.context(sessionId(input), (text) => {
+        if (output.system.length === 0) output.system.push(text);
+        else output.system[0] = `${output.system[0]}\n\n${text}`;
+      });
+    },
+    'tool.execute.after': async (input) => m.tool(sessionId(input), input?.tool),
+    'experimental.session.compacting': async (input, output) => {
+      m.compact(sessionId(input), (text) => { if (Array.isArray(output?.context)) output.context.push(text); });
+    },
     event: async ({ event }) => {
       const id = sessionId({ event });
-      if (event?.type === 'session.created') save(id, 'start');
-      else if (event?.type === 'file.edited') save(id, 'edit', 1);
-      else if (event?.type === 'session.compacted') save(id, 'compact');
-      else if (event?.type === 'session.idle') save(id, 'turn');
-      else if (event?.type === 'session.deleted') save(id, 'sessionEnd');
+      if (event?.type === 'session.created') m.save(id, 'start');
+      else if (event?.type === 'file.edited') m.save(id, 'edit', 1);
+      else if (event?.type === 'session.compacted') m.save(id, 'compact');
+      else if (event?.type === 'session.idle') m.save(id, 'turn');
+      else if (event?.type === 'session.deleted') m.save(id, 'sessionEnd');
     },
   };
 };
+
+// ---------------------------------------------------------------- OpenCode 2.x (V2 plugin API)
+// Hooks register through the context; the end of a turn is `session.execution.*` (there is no
+// `session.idle`), and every event carries its session in `data.sessionID`.
+
+const TURN_END = new Set(['session.execution.succeeded', 'session.execution.failed']);
+
+export default {
+  id: 'rsc.memory',
+  server: RscMemoryPlugin,
+  async setup(ctx) {
+    const m = memory(ctx.location?.project?.directory || ctx.location?.directory || process.cwd());
+    const part = (event) => (text) => { if (Array.isArray(event?.system)) event.system.push({ type: 'text', text }); };
+    await ctx.session.hook('context', async (event) => m.context(event?.sessionID, part(event)));
+    await ctx.session.hook('compaction', async (event) => m.compact(event?.sessionID, part(event)));
+    await ctx.tool.hook('execute.after', async (event) => m.tool(event?.sessionID, event?.tool));
+    const stop = new AbortController();
+    (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: stop.signal })) {
+          const id = event?.data?.sessionID;
+          if (event?.type === 'session.created') m.save(id, 'start');
+          else if (TURN_END.has(event?.type)) m.save(id, 'turn');
+          else if (event?.type === 'session.deleted') m.save(id, 'sessionEnd');
+        }
+      } catch { /* unloading, or the stream ended: fail open */ }
+    })();
+    return () => stop.abort();
+  },
+};

package/targets/opt-outs.js

@@ -22,8 +22,12 @@ 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/ + 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»: the default branch 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
 ];
 
 /** Decisions of one machine: never written to the manifest, never applied from it. */

package/targets/session-memory-adapter.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 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 { resolve, join, dirname, isAbsolute, sep } from 'node:path';
+import { capture, otherActiveSessions, resume } from './session-memory-core.mjs';
 
 const LOCAL_TARGETS = new Set(['claude', 'codex', 'cursor', 'gemini', 'opencode']);
 
@@ -20,16 +20,39 @@ function projectSettings(cwd) {
 // The hook payload's `cwd` is only where the tool call happened to run; inside a container of child
 // repos that is routinely a subdirectory with no harness of its own, and anchoring there scatters
 // one session's journal across children. With no harness anywhere above, the cwd stays the project.
-function nearestHarness(dir) {
+//
+// One exception, and it is the team workflow: a worktree under `<project>/.worktrees/<branch>/`
+// checks out its OWN committed `.rsc.json`, so the walk stopped there and the session's later events
+// went to a second store inside the worktree — while its open record stayed in the project's store
+// and kept telling every later session in the main checkout that someone was working there (team
+// simulation W1). A worktree the project made belongs to the project: its journal lives in the
+// project's store, with the worktree recorded as WHERE the session works.
+export function nearestHarness(dir) {
   let current = dir;
   for (;;) {
-    if (existsSync(join(current, '.rsc.json'))) return current;
+    if (existsSync(join(current, '.rsc.json'))) return parentProjectOf(current) || current;
     const parent = dirname(current);
     if (parent === current) return dir;
     current = parent;
   }
 }
 
+function parentProjectOf(dir) {
+  const parts = resolve(dir).split(sep);
+  for (let index = 1; index < parts.length; index += 1) {
+    if (parts[index] !== '.worktrees') continue;
+    const project = parts.slice(0, index).join(sep) || sep;
+    if (existsSync(join(project, '.rsc.json'))) return project;
+  }
+  return null;
+}
+
+function editedPath(native) {
+  const input = native?.tool_input || native?.toolInput || {};
+  const path = input.file_path || input.notebook_path || input.path || native?.file_path || null;
+  return typeof path === 'string' && isAbsolute(path) ? path : null;
+}
+
 function sessionId(native, target) {
   return native?.session_id || native?.sessionId || native?.sessionID || native?.conversation_id
     || native?.thread_id || `${target}-${process.ppid}`;
@@ -88,6 +111,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 en `.worktrees/` de la raíz, nunca dentro de una carpeta de proyecto: ' +
+    '`git worktree add .worktrees/<rama> -b <rama>` (si el proyecto está en una subcarpeta, `git -C <proyecto> worktree add <raíz>/.worktrees/<proyecto>-<rama> -b <rama>`, con la ruta absoluta) y se trabaja dentro. ' +
+    '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 || '';
@@ -108,7 +148,10 @@ export function handleLifecycle({ target, event, native = {}, cwd, settings } =
     const id = sessionId(native, target);
     const eventName = hookEventName(target, event, native);
     if (event === 'start') {
-      const started = capture({ cwd: project, worktreeCwd: here, sessionId: id, target, event: 'start', settings: config });
+      // `source: "compact"` is the SessionStart that follows a compaction. It resets the edit budget
+      // on its own, so the count still restarts when the PreCompact hook itself never finished.
+      const reset = native?.source === 'compact';
+      const started = capture({ cwd: project, worktreeCwd: here, sessionId: id, target, event: 'start', reset, settings: config });
       const resumed = resume({ cwd: project, worktreeCwd: here, target, settings: config });
       return {
         output: nativeOutput(target, eventName, resumed.context),
@@ -127,6 +170,7 @@ export function handleLifecycle({ target, event, native = {}, cwd, settings } =
       editDelta: event === 'edit' ? 1 : 0,
       settings: config,
     };
+    if (event === 'edit' && editedPath(native)) captureInput.filePath = editedPath(native);
     if (typeof native.cost === 'number') captureInput.cost = native.cost;
     if (Number.isInteger(native.tool_calls)) captureInput.toolCalls = native.tool_calls;
     const captured = capture(captureInput);
@@ -135,8 +179,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,