@lardexx/arenacode 2.9.0 → 2.11.1

package/src/automation.js

@@ -1003,11 +1003,24 @@ let nativeKind = null;
 
 try {
   if (isLinux) {
+    // Linux has no fallback any more: the FFI backend *is* the backend (the old one
+    // shelled out to xdotool, which is exactly what we do not want).
     nativeBackend = require('./automation/linux').backend;
     nativeKind = 'x11';
   } else if (isWin) {
-    nativeBackend = require('./automation/win-dll').backend;
-    nativeKind = 'dll';
+    // The DLL ships in the package; PowerShell stays only as a safety net for the case
+    // where it cannot be loaded at all.
+    const dll = require('./automation/win-dll');
+    if (dll.load()) {
+      nativeBackend = dll.backend;
+      nativeKind = 'dll';
+    }
+  } else if (isMac) {
+    const mac = require('./automation/mac');
+    if (mac.available().ok) {
+      nativeBackend = mac.backend;
+      nativeKind = 'mac';
+    }
   }
 } catch (err) {
   nativeBackend = null;
@@ -1023,7 +1036,11 @@ if (nativeBackend) {
   };
 
   Object.assign(automation, {
-    native: { kind: nativeKind, name: nativeBackend.name, dll: nativeKind === 'dll' ? require('./automation/win-dll').locate() : null },
+    native: {
+      kind: nativeKind,
+      name: nativeBackend.name,
+      dll: nativeKind === 'dll' ? require('./automation/win-dll').locate() : null,
+    },
     available: () => nativeBackend.available(),
     screenSize: () => nativeBackend.screenSize(),
     windows: () => nativeBackend.windows(),

package/src/cli.js

@@ -14,6 +14,7 @@ const { attachRefs, decorate } = require('./attach');
 const { decide, dangerText, normaliseApproval } = require('./approval');
 const session = require('./session');
 const { buildMeta, readProjectContext } = require('./meta');
+const { ensureContextFile, shouldSend: shouldSendContext, markSent: markContextSent } = require('./context');
 const { followTask } = require('./turn');
 const { c, write, ask, banner, truncate, indentLines } = require('./ui');
 
@@ -103,6 +104,7 @@ function context(flags) {
     json: Boolean(flags.json),
     confirmWrites: Boolean(flags['confirm-writes']),
     approval: normaliseApproval(flags.proceed ? 'proceed' : flags.ask ? 'ask' : cfg.approval),
+    shell: String(flags.shell || process.env.ARENACODE_SHELL || cfg.shell || '').trim(),
     idleTimeout: Number(flags['idle-timeout'] || cfg.idle_timeout || 180),
     bridge: new Bridge(url, key, device),
   };
@@ -194,7 +196,7 @@ function cmdConfig(positional, flags) {
     const name = key;
     const val = rest.join(' ');
     if (!name || val === '') {
-      write(`usage: ${SELF} config set <url|key|lang|mode|approval|pc_access> <value>`);
+      write(`usage: ${SELF} config set <url|key|lang|mode|approval|pc_access|shell> <value>`);
       return 2;
     }
     if (name === 'approval' && !['ask', 'proceed'].includes(String(val))) {
@@ -285,16 +287,42 @@ function agentPrompt() {
 }
 
 /** POST /task exactly like the desktop client does. */
+/**
+ * The bridge says it itself: `started_at` in /health changes every time the bridge
+ * starts. That is how the client knows a session is new and the sheet has to be sent.
+ */
+const bridgeStarts = new Map();
+async function bridgeStartedAt(bridge, url) {
+  if (bridgeStarts.has(url)) return bridgeStarts.get(url);
+  let startedAt = null;
+  try {
+    const res = await bridge.health();
+    if (res.status === 200 && res.json) startedAt = res.json.started_at ?? null;
+  } catch {
+    startedAt = null;
+  }
+  bridgeStarts.set(url, startedAt);
+  return startedAt;
+}
+
 async function createTask(ctx, instruction, { extraInstructions = '' } = {}) {
   const meta = buildMeta(ctx.folder, { lang: ctx.lang, pcAccess: ctx.pcAccess, activeFile: '' });
-  const projectContext = readProjectContext(ctx.folder);
+  // the sheet exists from the moment the folder is used: the agent fills the block
+  // between the markers at the end of every task, the client only writes the frame
+  ensureContextFile(ctx.folder, { lang: ctx.lang, bridgeUrl: ctx.url });
+  const startedAt = await bridgeStartedAt(ctx.bridge, ctx.url);
+  const sendContext = shouldSendContext({ folder: ctx.folder, url: ctx.url, startedAt });
+  const projectContext = sendContext ? readProjectContext(ctx.folder) : '';
   const body = {
     instruction,
     wait: 0,
     meta,
     agent_prompt: agentPrompt(),
   };
-  if (projectContext) body.project_context = projectContext;
+  if (projectContext) {
+    body.project_context = projectContext;
+    markContextSent({ folder: ctx.folder, url: ctx.url, startedAt });
+  }
   if (extraInstructions) body.instruction = `${instruction}\n\n${extraInstructions}`;
 
   const res = await ctx.bridge.createTask(body);
@@ -337,6 +365,7 @@ async function runInstruction(ctx, text, { attachments = [] } = {}) {
     const result = await followTask(ctx.bridge, taskId, {
       folder: ctx.folder,
       lang: ctx.lang,
+      shell: ctx.shell,
       yes: ctx.yes,
       approval: ctx.approval,
       confirmWrites: ctx.confirmWrites,
@@ -400,6 +429,7 @@ async function cmdUi(flags) {
     yes: ctx.yes,
     approval: ctx.approval,
     confirmWrites: ctx.confirmWrites,
+    shell: ctx.shell,
   });
   await app.start();
   return 0;
@@ -688,7 +718,7 @@ async function cmdHandshake(flags) {
 const USAGE = {
   init:      [['init', 'configure bridge URL + API key, then test the connection']],
   config:    [['config [show|path]', 'read the saved configuration'],
-              ['config set <key> <value>', 'url · key · lang · mode · pc_access']],
+              ['config set <key> <value>', 'url · key · lang · mode · pc_access · shell']],
   ping:      [['ping', 'bridge status and API key check']],
   doctor:    [['doctor', 'local checks: node, platform, folder, git, bridge']],
   ask:       [['ask "instruction"', 'run one task and stream the timeline']],

package/src/config.js

@@ -34,6 +34,7 @@ const DEFAULTS = {
   device: '',
   vision: false,
   idle_timeout: 180,
+  shell: '',
 };
 
 function readConfig() {

package/src/context.js

@@ -0,0 +1,234 @@
+'use strict';
+
+// The project context sheet: `context_<project>.md` in the open folder.
+//
+// Mined from ArenaCode-x64.exe (the literals are the desktop client's own, UTF-16 in
+// .rdata, built by the function at 0x14002f7f0):
+//
+//   '# Contesto del progetto ' + name + '\n\n'
+//   'Sessione: ' + … + ' (' + … + ')\n'
+//   '_Nessun task ancora._\n'
+//   '<!-- agente:inizio -->\n'
+//   '<!-- agente:fine -->\n\n'
+//   'Aggiornato automaticamente da ArenaCode a fine di ogni job. La API key non è scritta qui.\n\n'
+//
+// The client creates the file when the folder opens or a session starts, sends the whole
+// file to the bridge with the first task of a new bridge session (bridge_server.py:
+// "arriva con il primo task di un bridge nuovo"), and never summarises it. The agent
+// rewrites the block between the two HTML comments at the end of every task — the client
+// only writes the frame, never the block.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const MARK_START = '<!-- agente:inizio -->';
+const MARK_END = '<!-- agente:fine -->';
+
+const TEXT = {
+  it: {
+    title: '# Contesto del progetto ',
+    session: 'Sessione: ',
+    noTask: '_Nessun task ancora._',
+    footer: 'Aggiornato automaticamente da ArenaCode a fine di ogni job. La API key non è scritta qui.',
+  },
+  en: {
+    title: '# Project context ',
+    session: 'Session: ',
+    noTask: '_No task yet._',
+    footer: 'Updated automatically by ArenaCode at the end of each job. The API key is not written here.',
+  },
+  es: {
+    title: '# Contexto del proyecto ',
+    session: 'Sesión: ',
+    noTask: '_Ningún trabajo todavía._',
+    footer: 'Actualizado automáticamente por ArenaCode al final de cada trabajo. La clave API no se escribe aquí.',
+  },
+};
+
+function pack(lang) {
+  return TEXT[lang] || TEXT.it;
+}
+
+/** `Progetto web` → `Progetto-web`; keeps the name readable, drops what a filesystem hates. */
+function projectName(folder) {
+  const base = path.basename(path.resolve(String(folder || '.'))) || 'progetto';
+  const clean = base
+    .replace(/[\\/:*?"<>|]/g, '-')
+    .replace(/\s+/g, '-')
+    .replace(/^[.-]+/, '')
+    .slice(0, 60);
+  return clean || 'progetto';
+}
+
+function contextFileName(folder) {
+  return `context_${projectName(folder)}.md`;
+}
+
+function contextFilePath(folder) {
+  return path.join(path.resolve(String(folder || '.')), contextFileName(folder));
+}
+
+function stamp(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+/** Where the session line's parenthetical comes from: the bridge, or the machine. */
+function sessionHost(bridgeUrl) {
+  const raw = String(bridgeUrl || '').trim();
+  if (raw) {
+    try {
+      return new URL(raw.includes('://') ? raw : `https://${raw}`).host;
+    } catch {
+      return raw;
+    }
+  }
+  return os.hostname();
+}
+
+/** The frame the client writes, byte for byte in the desktop's order. */
+function buildTemplate({ folder, lang = 'it', bridgeUrl = '', now = new Date() } = {}) {
+  const t = pack(lang);
+  return (
+    `${t.title}${projectName(folder)}\n` +
+    '\n' +
+    `${t.session}${stamp(now)} (${sessionHost(bridgeUrl)})\n` +
+    `${t.noTask}\n` +
+    `${MARK_START}\n` +
+    `${MARK_END}\n` +
+    '\n' +
+    `${t.footer}\n`
+  );
+}
+
+/**
+ * Creates the file if the folder does not have one yet. An existing file is never
+ * touched: it is the project's log and the agent's block lives inside it.
+ */
+function ensureContextFile(folder, { lang = 'it', bridgeUrl = '', now = new Date() } = {}) {
+  const root = path.resolve(String(folder || '.'));
+  const file = contextFilePath(root);
+  try {
+    const stat = fs.statSync(file);
+    if (stat.isFile()) return { ok: true, file, created: false, name: contextFileName(root) };
+  } catch {
+    /* not there yet */
+  }
+  try {
+    fs.mkdirSync(root, { recursive: true });
+    fs.writeFileSync(file, buildTemplate({ folder: root, lang, bridgeUrl, now }), { encoding: 'utf8', flag: 'wx' });
+    return { ok: true, file, created: true, name: contextFileName(root) };
+  } catch (err) {
+    // EEXIST: another window created it first — fine, nothing to do
+    if (err.code === 'EEXIST') return { ok: true, file, created: false, name: contextFileName(root) };
+    return { ok: false, file, created: false, error: err.message };
+  }
+}
+
+/** Reads the sheet the way the desktop sends it: whole, untouched. */
+function readContext(folder, { maxBytes = 200_000 } = {}) {
+  const root = path.resolve(String(folder || '.'));
+  let names = [];
+  try {
+    names = fs.readdirSync(root).filter((name) => /^context_.*\.md$/i.test(name));
+  } catch {
+    return '';
+  }
+  if (!names.length) return '';
+  // the one for this folder first, then any other context sheet
+  const file = names.find((name) => name === contextFileName(root)) || names[0];
+  try {
+    const full = path.join(root, file);
+    if (fs.statSync(full).size > maxBytes) return '';
+    return fs.readFileSync(full, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+// ------------------------------------------------------------------ sending it --
+// The bridge writes what it receives to runtime/project_context.txt and tells the agent
+// to read it in parts; it expects it once per bridge session, not on every task.
+
+const STATE_FILE = () => path.join(path.dirname(configDir()), 'context-state.json');
+
+function configDir() {
+  if (process.platform === 'win32') {
+    const base = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+    return path.join(base, 'ArenaCode', 'config.json');
+  }
+  return path.join(os.homedir(), '.arenacode', 'config.json');
+}
+
+function readState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE(), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeState(state) {
+  try {
+    fs.mkdirSync(path.dirname(STATE_FILE()), { recursive: true });
+    fs.writeFileSync(STATE_FILE(), JSON.stringify(state, null, 2), 'utf8');
+  } catch {
+    /* a read-only HOME only costs one extra send */
+  }
+}
+
+/**
+ * Should this task carry the project context? Yes on the first task of a bridge
+ * session and whenever the folder changes, no for the following tasks.
+ */
+function shouldSend({ folder, url = '', startedAt = null } = {}) {
+  const state = readState();
+  const project = path.resolve(String(folder || '.'));
+  if (state.folder !== project) return true;
+  if (!startedAt) return false; // same folder, bridge identity unknown: it already got it
+  return state.url !== String(url) || Number(state.startedAt) !== Number(startedAt);
+}
+
+function markSent({ folder, url = '', startedAt = null } = {}) {
+  writeState({ folder: path.resolve(String(folder || '.')), url: String(url), startedAt: startedAt ? Number(startedAt) : null });
+}
+
+/** Appends a session line to the sheet when the client opens it again later. */
+function touchSession(folder, { lang = 'it', bridgeUrl = '', now = new Date() } = {}) {
+  const file = contextFilePath(folder);
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return { ok: false, error: 'context file missing' };
+  }
+  const t = pack(lang);
+  const line = `${t.session}${stamp(now)} (${sessionHost(bridgeUrl)})\n`;
+  if (text.includes(line)) return { ok: true, file, added: false };
+  const at = text.indexOf('\n\n');
+  const updated = at >= 0 ? `${text.slice(0, at + 2)}${line}${text.slice(at + 2)}` : `${text}${line}`;
+  try {
+    fs.writeFileSync(file, updated, 'utf8');
+    return { ok: true, file, added: true };
+  } catch (err) {
+    return { ok: false, file, error: err.message };
+  }
+}
+
+module.exports = {
+  MARK_START,
+  MARK_END,
+  TEXT,
+  projectName,
+  contextFileName,
+  contextFilePath,
+  buildTemplate,
+  ensureContextFile,
+  readContext,
+  shouldSend,
+  markSent,
+  touchSession,
+  sessionHost,
+  stamp,
+};

package/src/local.js

@@ -39,6 +39,15 @@ function resolveInRoot(root, rel) {
   return abs;
 }
 
+/** `context_<project>.md` — the project log, never committed and never asked about. */
+function contextFiles(root) {
+  try {
+    return fs.readdirSync(root).filter((name) => /^context_.*\.md$/i.test(name));
+  } catch {
+    return [];
+  }
+}
+
 function relativize(root, abs) {
   const rel = path.relative(root, abs).replace(/\\/g, '/');
   return rel === '' ? '.' : rel;
@@ -48,22 +57,110 @@ function relativize(root, abs) {
 // Local terminal (local-exec)
 // --------------------------------------------------------------------------- //
 
-function shellCommand(shell, command) {
-  if (process.platform === 'win32') {
-    switch (shell) {
+// Every shell the client can drive. The bridge may ask for one by name (`shell` in the
+// local-exec request), the user can pin one (`arenacode config set shell zsh`, `/shell`),
+// and otherwise the client takes the user's login shell, like a terminal would.
+const UNIX_SHELLS = {
+  sh: '/bin/sh',
+  bash: '/bin/bash',
+  zsh: '/bin/zsh',
+  fish: '/usr/bin/fish',
+  dash: '/bin/dash',
+  ksh: '/bin/ksh',
+};
+
+const WINDOWS_SHELLS = ['powershell', 'pwsh', 'cmd', 'wsl', 'bash'];
+
+function shellExists(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** sh/bash/zsh/dash/ksh: -l login, -c command. fish spells the same as -l -c. */
+function unixShell(name) {
+  const wanted = String(name || '').toLowerCase().replace(/\.exe$/, '');
+  const alias = { 'git-bash': 'bash', gitbash: 'bash' }[wanted] || wanted;
+  let file = UNIX_SHELLS[alias];
+  if (!file && (alias === 'sh' || alias.startsWith('/'))) file = alias === 'sh' ? '/bin/sh' : alias;
+  if (!file) file = whichPath(alias);
+  if (!file) file = UNIX_SHELLS[alias] || null;
+  if (!file) return null;
+  const base = path.basename(file);
+  const args = base === 'fish' ? ['-l', '-c', null] : ['-lc', null];
+  return { file, args };
+}
+
+function whichPath(name) {
+  for (const dir of ['/bin', '/usr/bin', '/usr/local/bin', '/opt/homebrew/bin']) {
+    const file = path.join(dir, name);
+    if (shellExists(file)) return file;
+  }
+  return null;
+}
+
+/** The shell to use when nobody asked for a specific one. */
+function detectShell(platform = process.platform) {
+  if (platform === 'win32') {
+    if (shellExists('pwsh.exe') || whichPath('pwsh')) return 'pwsh';
+    return 'powershell';
+  }
+  const login = path.basename(process.env.SHELL || '');
+  if (login && (UNIX_SHELLS[login] || whichPath(login))) return login;
+  return 'sh';
+}
+
+/** What the client can offer on this machine — for `sysinfo`, `/shell` and the help. */
+function availableShells(platform = process.platform) {
+  if (platform === 'win32') {
+    return WINDOWS_SHELLS.filter((name) => name === 'powershell' || name === 'cmd' || Boolean(whichPath(name)));
+  }
+  const found = Object.keys(UNIX_SHELLS).filter((name) => shellExists(UNIX_SHELLS[name]) || Boolean(whichPath(name)));
+  return found.length ? found : ['sh'];
+}
+
+/**
+ * Command template for one shell. `command` is passed as its own argv entry, never
+ * through a second round of quoting, so quotes and `$` survive.
+ */
+function shellCommand(shell, command, platform = process.platform) {
+  const name = String(shell || detectShell(platform)).toLowerCase().replace(/\.exe$/, '');
+  if (platform === 'win32') {
+    switch (name) {
       case 'cmd':
         return { file: 'cmd.exe', args: ['/d', '/s', '/c', command] };
       case 'wsl':
         return { file: 'wsl.exe', args: ['sh', '-lc', command] };
+      case 'bash': {
+        // Git Bash when it is installed, otherwise the WSL bash
+        const gitBash = [
+          'C:\\Program Files\\Git\\bin\\bash.exe',
+          'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+        ].find((file) => {
+          try {
+            return fs.existsSync(file);
+          } catch {
+            return false;
+          }
+        });
+        return gitBash
+          ? { file: gitBash, args: ['-lc', command] }
+          : { file: 'wsl.exe', args: ['bash', '-lc', command] };
+      }
+      case 'pwsh':
+        return { file: 'pwsh.exe', args: ['-NoProfile', '-NonInteractive', '-Command', command] };
       case 'powershell':
+      case 'ps':
       default:
-        return {
-          file: shell === 'pwsh' ? 'pwsh.exe' : 'powershell.exe',
-          args: ['-NoProfile', '-NonInteractive', '-Command', command],
-        };
+        return { file: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-Command', command] };
     }
   }
-  return { file: '/bin/sh', args: ['-lc', command] };
+  const template = unixShell(name) || unixShell('sh');
+  const args = template.args.map((arg) => (arg === null ? command : arg));
+  return { file: template.file, args };
 }
 
 /** Runs a command and collects stdout+stderr and the exit code. */
@@ -96,9 +193,12 @@ async function handleLocalExec(bridge, taskId, request, opts) {
   const { rid, command, cwd: reqCwd, shell, admin, sandbox_reason: sandboxReason } = request;
   const lang = opts.lang;
   const dir = reqCwd ? resolveInRoot(opts.folder, reqCwd) : opts.folder;
+  // the bridge names the shell it wrote the command for; otherwise the user's choice
+  // from `arenacode config set shell …` / `/shell`, otherwise the login shell
+  const chosenShell = shell || opts.shell || detectShell();
 
   write('');
-  write(`  ${c.bold(c.yellow('⌘ terminal'))} ${c.dim('·')} ${c.cyan(shell || 'shell')} ${c.dim('·')} ${c.gray(dir)}`);
+  write(`  ${c.bold(c.yellow('⌘ terminal'))} ${c.dim('·')} ${c.cyan(chosenShell)} ${c.dim('·')} ${c.gray(dir)}`);
   write(indentLines(command, '    '));
   if (admin) write(`  ${c.yellow('!')} ${t(lang, 'Richiede i permessi di amministratore: qui il comando gira senza UAC.', 'Needs administrator rights: here it runs without UAC.', 'Necesita permisos de administrador: aquí se ejecuta sin UAC.')}`);
   if (sandboxReason) write(`  ${c.yellow('!')} ${t(lang, 'L’agente chiede di installare sul PC', 'The agent asks to install on the PC', 'El agente pide instalar en el PC')}: ${c.gray(sandboxReason)}`);
@@ -125,7 +225,7 @@ async function handleLocalExec(bridge, taskId, request, opts) {
     return true;
   }
 
-  const { output, code } = await runShell(command, { cwd: dir, shell });
+  const { output, code } = await runShell(command, { cwd: dir, shell: chosenShell });
   await bridge.localResult(taskId, { rid, output, code });
   write(`  ${code === 0 ? c.green('✓') : c.red('✗')} ${c.gray(`exit ${code}`)}`);
   return true;
@@ -335,6 +435,8 @@ function runFsOp(op, body, root) {
     case 'git_commit': {
       const add = git(['add', '-A'], root);
       if (!add.ok) return { ok: false, error: add.output };
+      // the project log stays out of the history, exactly like the desktop client does
+      for (const name of contextFiles(root)) git(['reset', '-q', '--', name], root);
       const commit = git(['commit', '-m', String(body.content || 'ArenaCode')], root);
       return { ok: commit.ok, output: commit.output };
     }
@@ -384,7 +486,9 @@ async function handleLocalFs(bridge, taskId, request, opts) {
   write(`  ${c.bold(c.yellow('▤ files'))} ${c.dim('·')} ${c.cyan(op)} ${c.gray(request.path || '.')}${request.to ? c.gray(` → ${request.to}`) : ''}`);
 
   const mutating = ['write', 'replace', 'rm', 'mv', 'mkdir'].includes(op);
-  const verdict = mutating
+  // the project log is saved at once: the card only shows what changed, like the desktop
+  const isProjectLog = /^context_.*\.md$/i.test(path.basename(String(request.path || '')));
+  const verdict = mutating && !isProjectLog
     ? decide({
         approval: opts.approval,
         mode: session.modeOf(taskId),
@@ -394,7 +498,7 @@ async function handleLocalFs(bridge, taskId, request, opts) {
       })
     : 'auto';
   // --confirm-writes keeps asking even when the client runs in Proceed
-  const mustAsk = mutating && (verdict === 'ask' || opts.confirmWrites);
+  const mustAsk = mutating && !isProjectLog && (verdict === 'ask' || opts.confirmWrites);
   if (mustAsk) {
     const key = await askKey(`  ${t(lang, 'Applico? [s] sì  [n] no', 'Apply? [y] yes  [n] no', '¿Aplico? [s] sí  [n] no')} `, ['s', 'y', 'n']);
     if (key === 'n') {
@@ -495,7 +599,8 @@ async function handleLocalUi(bridge, taskId, request, opts) {
       cpus: os.cpus().length,
       memory_mb: Math.round(os.totalmem() / 1048576),
       node: process.version,
-      shell: require('./meta').which('pwsh') ? 'pwsh' : process.platform === 'win32' ? 'powershell' : 'sh',
+      shell: detectShell(),
+      shells: availableShells(),
     };
     await bridge.localResult(taskId, { rid, output: JSON.stringify(info), code: 0 });
     write(`  ${c.green('✓')} ${c.gray('sysinfo')}`);
@@ -683,6 +788,9 @@ async function handleLocalFile(bridge, taskId, request, opts) {
 
 module.exports = {
   runUiAction,
+  shellCommand,
+  detectShell,
+  availableShells,
   REFUSED,
   resolveInRoot,
   runShell,

package/src/meta.js

@@ -3,6 +3,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { readContext } = require('./context');
 const { execFileSync } = require('node:child_process');
 
 const { CLIENT_NAME, VERSION } = require('./config');
@@ -118,26 +119,12 @@ function buildMeta(folder, { lang = 'it', pcAccess = true, activeFile = '', open
 }
 
 /**
- * Project context: the client sends the content of `context_<project>.md` from the
- * open folder when a bridge session starts, so the agent can resume the project.
+ * Project context: the content of `context_<project>.md` from the open folder, sent to
+ * the bridge with the first task of a new session (see src/context.js for the sheet and
+ * for the gating).
  */
 function readProjectContext(folder) {
-  const root = path.resolve(folder);
-  let names = [];
-  try {
-    names = fs.readdirSync(root).filter((n) => /^context_.*\.md$/i.test(n));
-  } catch {
-    return '';
-  }
-  if (!names.length) return '';
-  const file = path.join(root, names[0]);
-  try {
-    const stat = fs.statSync(file);
-    if (stat.size > MAX_CONTEXT_BYTES) return '';
-    return fs.readFileSync(file, 'utf8');
-  } catch {
-    return '';
-  }
+  return readContext(folder, { maxBytes: MAX_CONTEXT_BYTES });
 }
 
 module.exports = { POLICY, VERSION, buildMeta, workspaceMeta, readProjectContext, detectTools, which };