ai_co_discuss 0.3.71 → 0.3.72

package/runner/adapters/index.mjs

@@ -4,8 +4,9 @@
  * - its static facts in `profiles.mjs` (label, platform, config fields, efforts, access levels, capabilities), plain data
  *   the web page reads as well;
  * - its behaviour in its own module, a descriptor with the same shape for every software:
- *   - `deliver(config, binding, task, spawn_process, user_home)` → `{session_id, status, capabilities}`, where
- *     `capabilities` `{stoppable, progress}` says what this one delivery can do;
+ *   - `deliver(config, binding, task, spawn_process, user_home)` → `{session_id, status, capabilities, steer?}`, where
+ *     `capabilities` `{stoppable, progress}` says what this one delivery can do, and `steer(text)` (when the running
+ *     software can take an interjection without ending its turn) passes one in, resolving false once the turn is over;
  *   - `session`: `{path, exists, branch, settings}` for the software's own session store, or null;
  *   - `models`: `{list, effort?, defaults}` read from the installed software, or null when it is chosen inside the App;
  *   - optional `receipt(config, id)` for deliveries confirmed later (`status: 'sidecar_pending'`),
@@ -80,6 +81,37 @@ export function stored_delivery(value) {
   return Object.hasOwn(legacy, value) ? legacy[value] : JSON.parse(value);
 }
 
+// What one execution-detail answer carries: the latest entries, each body cut to a readable length.
+const DETAIL_ENTRY_LIMIT = 300;
+const DETAIL_BODY_LIMIT = 4000;
+
+/**
+ * What an agent did in one execution, rebuilt from the raw event log its adapter's process wrote: messages, commands
+ * with their output, searches, edits and tool calls in order. Each adapter's `events.detail(event)` turns one event into
+ * entries `{id?, kind, title?, body?, append?, state?}`; an entry with a known id updates the earlier one in place
+ * (a command's result fills in its start), `append` extends its body. Returns null when the adapter keeps no such log.
+ */
+export function execution_details(adapter_id, text) {
+  const detail = adapter_of(adapter_id)?.events?.detail;
+  if (!detail) return null;
+  const entries = new Map();
+  for (const line of text.split('\n')) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    // The runner marks where an interjection went into the turn; it reads the same for every software.
+    const parts = event.type === 'codiscuss.interjection' ? [{ kind: 'interjection', body: String(event.text || '') }] : detail(event);
+    for (const { append, ...fields } of parts || []) {
+      const id = fields.id ?? `entry-${entries.size}`;
+      const entry = { ...entries.get(id), ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)), id };
+      if (append) entry.body = (entry.body || '') + append;
+      entries.set(id, entry);
+    }
+  }
+  const all = [...entries.values()].filter(entry => entry.kind);
+  return { total: all.length, entries: all.slice(-DETAIL_ENTRY_LIMIT).map(entry => entry.body?.length > DETAIL_BODY_LIMIT
+    ? { ...entry, body: entry.body.slice(0, DETAIL_BODY_LIMIT), truncated: true } : entry) };
+}
+
 /** Adapters whose sessions this machine can cut or branch; the website lists taken-back executions only for these. */
 export const BRANCHABLE_ADAPTERS = Object.values(ADAPTERS).filter(adapter => adapter.session?.branch).map(adapter => adapter.id);
 

package/runner/adapters/profiles.mjs

@@ -26,7 +26,9 @@
  *   (the runner cuts the session), `fresh` (context rebuilt each time) or `kept` (cannot be cut here); `project` (works in
  *   a project directory); `access_env` (its process takes the credential file by environment); `enforces_read_only`
  *   (its sandbox enforces a read-only project); `ripgrep` (bundles rg for reading on Windows); `file_tools` (works on
- *   the project only through the runner's file tools, running no commands).
+ *   the project only through the runner's file tools, running no commands); `limits_directories` (a directory it may
+ *   only read stays read-only even while it may write elsewhere and run commands: a sandbox or file tools, not rules
+ *   that a command could bypass).
  * - `session_family`: profiles sharing one session store; switching among them keeps the conversation.
  * - `windows_command`: how its shell names the codiscuss CLI on Windows.
  * - `task_rules(cli, {runs_commands})`: fixed task text this software needs, added by the runner so no member prompt drops it.
@@ -45,7 +47,7 @@ export const ADAPTER_PROFILES = {
     access_hints: { read: '只读沙箱', write: '项目可写的沙箱，命令在沙箱内运行、可联网',
       auto: '沙箱外的操作由模型申请提权，Codex 自动审核代替人工批准', full: '无沙箱、无审批（--dangerously-bypass-approvals-and-sandbox）' },
     client: 'codex', adopt: 'session', host_existing: true, session_family: 'codex',
-    capabilities: { delivery: PROCESS, rewind: 'cut', project: true, access_env: true, enforces_read_only: true, ripgrep: true },
+    capabilities: { delivery: PROCESS, rewind: 'cut', project: true, access_env: true, enforces_read_only: true, limits_directories: true, ripgrep: true },
   },
   codex: {
     platform: 'Codex', label: 'Codex App', kind: 'app', location: 'executable', fields: ['source_thread_id', 'project_id', 'project_name'],
@@ -92,7 +94,7 @@ export const ADAPTER_PROFILES = {
     efforts: null, models: false, access_levels: ['read', 'write'], per_tool_allow: false, adopt: '', host_existing: false,
     access_hints: { read: '用接入程序的文件工具读取、搜索项目文件', write: '还可新建、覆盖、局部编辑项目文件；没有命令行' },
     unsupported_hints: { auto: 'API 成员没有命令行，没有需要软件审批的操作', full: 'API 成员没有命令行，没有需要软件审批的操作' },
-    capabilities: { delivery: PROCESS, rewind: 'fresh', project: true, file_tools: true },
+    capabilities: { delivery: PROCESS, rewind: 'fresh', project: true, file_tools: true, limits_directories: true },
   },
 };
 

package/runner/device_auth.mjs

@@ -35,8 +35,6 @@ const LABEL_LIMIT = 60;
 const CODE_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
 const CODE_LENGTH = 12;
 const PAIR_CONTEXT = 'codiscuss-pair-v1';
-// What an expired (not yet removed) device may still ask for: only to renew itself.
-const EXPIRED_ACTIONS = new Set(['passkey-challenge', 'device-renew']);
 // What a locked device may still ask for: only to unlock (or renew) itself with its passkey.
 const LOCKED_ACTIONS = new Set(['passkey-challenge', 'device-unlock', 'device-renew']);
 // The one action an unpaired browser may send, unsigned: proving it holds a pairing code.
@@ -136,25 +134,35 @@ export function machine_fingerprint(link) {
   return createHash('sha256').update(`${ecdh.x}.${ecdh.y}.${sign.x}.${sign.y}`).digest('hex').slice(0, 32);
 }
 
-/** Start a pairing at this computer's own screen: a 12-character code, valid two minutes, and the link a camera can open. */
-export function start_pairing(home, { site, fingerprint = '', temporary = false, by = 'computer' }) {
+/**
+ * Start a pairing at this computer's own screen: a 12-character code, valid two minutes, and the link a camera can open.
+ * `without_passkey` lets this one pairing go without a passkey (a browser that cannot create one); only the person at
+ * this computer can allow it, never the new device's page.
+ */
+export function start_pairing(home, { site, fingerprint = '', temporary = false, without_passkey = false, by = 'computer' }) {
   const bytes = randomBytes(CODE_LENGTH);
   const code = Array.from(bytes, byte => CODE_ALPHABET[byte & 31]).join('');
-  audit(home, { event: 'pairing.started', by, temporary: Boolean(temporary) });
+  audit(home, { event: 'pairing.started', by, temporary: Boolean(temporary), without_passkey: Boolean(without_passkey) });
   return with_lock(home, (registry, now) => {
     const id = randomBytes(8).toString('hex');
-    registry.pairings[id] = { code, temporary: Boolean(temporary), by, expires_at: now + PAIRING_MS, failures: 0 };
+    registry.pairings[id] = { code, temporary: Boolean(temporary), without_passkey: Boolean(without_passkey), by, expires_at: now + PAIRING_MS, failures: 0 };
     return { code: `${code.slice(0, 4)}-${code.slice(4, 8)}-${code.slice(8)}`, expires_at: now + PAIRING_MS, temporary: Boolean(temporary),
-      ...(site ? { url: `${site}/#pair=${code}${fingerprint ? `&fp=${fingerprint}` : ''}` } : {}) };
+      without_passkey: Boolean(without_passkey), ...(site ? { url: `${site}/#pair=${code}${fingerprint ? `&fp=${fingerprint}` : ''}` } : {}) };
   });
 }
 
-/** Record a paired device with its passkey: thirty days, or one day for a temporary one. */
+/** Whether a device may renew itself with its passkey after expiring: kept devices with a passkey only. */
+const renewable = device => device.passkeys.length > 0 && !device.temporary;
+
+/**
+ * Record a paired device with its passkey, if it has one: thirty days, or one day for a temporary one. A device paired
+ * without a passkey (allowed at this computer for that pairing) is trusted by its device key alone and never locks.
+ */
 function add_device(registry, now, { public_key, label, temporary, by, passkey }) {
   const id = device_id_of(public_key);
   registry.devices[id] = { public_key: { kty: 'EC', crv: 'P-256', x: public_key.x, y: public_key.y }, label: clean_label(label), by,
-    temporary: Boolean(temporary), created_at: now, expires_at: now + (temporary ? TEMPORARY_DAYS : DEVICE_DAYS) * DAY_MS, passkeys: [passkey],
-    // Pairing itself was confirmed with the passkey, so the device starts unlocked.
+    temporary: Boolean(temporary), created_at: now, expires_at: now + (temporary ? TEMPORARY_DAYS : DEVICE_DAYS) * DAY_MS, passkeys: passkey ? [passkey] : [],
+    // Pairing itself was confirmed at this computer, so the device starts unlocked.
     unlocked_until: Math.min(now + UNLOCK_MS, now + (temporary ? TEMPORARY_DAYS : DEVICE_DAYS) * DAY_MS) };
   return { device_id: id, expires_at: registry.devices[id].expires_at, temporary: Boolean(temporary) };
 }
@@ -165,7 +173,6 @@ function add_device(registry, now, { public_key, label, temporary, by, passkey }
  */
 export function pair_device(home, machine_id, site, { public_key, label, proof, passkey: credential }) {
   if (typeof proof !== 'string' || !proof) throw new Error('缺少配对证明');
-  if (!credential) throw new Error('配对须同时创建这台设备的通行密钥');
   device_id_of(public_key);
   const { origin, rp_id } = relying_party(site);
   const paired = with_lock(home, (registry, now) => {
@@ -173,10 +180,14 @@ export function pair_device(home, machine_id, site, { public_key, label, proof,
     for (const [id, pairing] of Object.entries(registry.pairings)) {
       const expected = Buffer.from(pairing_proof(pairing.code, machine_id, public_key));
       if (expected.length === supplied.length && timingSafeEqual(expected, supplied)) {
+        // Going without a passkey drops the daily confirmation, so only the person at this computer may allow it.
+        if (!credential && !pairing.without_passkey) {
+          throw Object.assign(new Error('这台设备没有创建通行密钥。如果它的浏览器确实不支持，请在电脑上添加设备时勾选“允许不用通行密钥”，再重新扫码'), { need: 'passkey' });
+        }
         delete registry.pairings[id];
-        const passkey = verify_registration(credential, { challenge: pairing_passkey_challenge(pairing.code, public_key), origin, rp_id });
+        const passkey = credential && verify_registration(credential, { challenge: pairing_passkey_challenge(pairing.code, public_key), origin, rp_id });
         const added = add_device(registry, now, { public_key, label, temporary: pairing.temporary, by: pairing.by, passkey });
-        audit(home, { event: 'device.paired', device: added.device_id, label: clean_label(label), by: pairing.by, temporary: pairing.temporary });
+        audit(home, { event: 'device.paired', device: added.device_id, label: clean_label(label), by: pairing.by, temporary: pairing.temporary, passkey: Boolean(passkey) });
         return added;
       }
     }
@@ -206,29 +217,36 @@ export async function open_signed_request(home, id, sealed, machine_id) {
   if (!valid) throw new Error('设备签名无效');
   // The signature names the computer it was meant for, so a request cannot be passed on to another paired computer.
   if (request.machine !== machine_id) throw new Error('这条请求是发给另一台电脑的');
-  if (device.expires_at <= Date.now() && !EXPIRED_ACTIONS.has(request.action)) {
-    throw Object.assign(new Error(device.temporary ? '临时设备授权已到期，请重新配对' : '设备授权已到期，请用通行密钥续期'), { need: device.temporary ? 'pairing' : 'renew' });
+  // An expired device may only renew itself, and only if it can: the website lets it through for that alone, so the
+  // limit is checked again here rather than trusted.
+  if (device.expires_at <= Date.now()) {
+    if (!renewable(device)) throw Object.assign(new Error('设备授权已到期，请在电脑前重新配对'), { need: 'pairing' });
+    const renewing = request.action === 'device-renew' || (request.action === 'passkey-challenge' && request.payload?.purpose === 'renew');
+    if (!renewing) throw Object.assign(new Error('设备授权已到期，请用通行密钥续期'), { need: 'renew' });
   }
-  if (!(device.unlocked_until > Date.now()) && !LOCKED_ACTIONS.has(request.action)) {
+  // A device without a passkey has nothing to unlock with, so it skips the daily confirmation.
+  if (device.passkeys.length > 0 && !(device.unlocked_until > Date.now()) && !LOCKED_ACTIONS.has(request.action)) {
     throw Object.assign(new Error('请用通行密钥确认这台设备（每天一次）'), { need: 'unlock' });
   }
   return { request, device_id: sealed.device_id };
 }
 
 /**
- * The device list this computer signs for the website: each device's public key and expiry, nothing else. The website
- * checks requests against it and cannot add a device of its own.
+ * The device list this computer signs for the website: each device's public key, expiry and, for a device that may renew
+ * itself, how long after expiry it may still reach this computer to do so. The website checks requests against it and
+ * cannot add a device of its own.
  */
 export async function signed_device_list(home, link, now = Date.now()) {
   const { devices } = read_registry(home);
   const body = JSON.stringify({ machine: link.id, issued_at: now, devices: Object.entries(devices)
-    .map(([id, device]) => ({ id, x: device.public_key.x, y: device.public_key.y, expires_at: device.expires_at })) });
+    .map(([id, device]) => ({ id, x: device.public_key.x, y: device.public_key.y, expires_at: device.expires_at,
+      ...(renewable(device) ? { renew_until: device.expires_at + RENEW_GRACE_DAYS * DAY_MS } : {}) })) });
   const key = await crypto.subtle.importKey('jwk', link.sign_private_key, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
   const signature = await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, key, new TextEncoder().encode(body));
   return { body, signature: b64url(new Uint8Array(signature)) };
 }
 
-/** List paired devices with their passkeys and write grants, newest first, and the recent audit entries. */
+/** List paired devices with their passkey counts and unlock times, newest first, and the recent audit entries. */
 export function list_devices(home, current = null) {
   const { devices } = read_registry(home);
   return { audit: recent_audit(home), devices: Object.entries(devices).map(([id, device]) => ({ id, label: device.label, temporary: device.temporary, created_at: device.created_at,
@@ -238,7 +256,7 @@ export function list_devices(home, current = null) {
 }
 
 /**
- * Remove a device with its passkeys and grants; a device may also remove itself. Returns the removed passkey ids so the
+ * Remove a device with its passkeys; a device may also remove itself. Returns the removed passkey ids so the
  * page can remove the same passkeys from the website's login list.
  */
 export function revoke_device(home, device_id) {

package/runner/discussion_launch.mjs

@@ -1,7 +1,7 @@
 /** Shared launch configuration for an existing AI conversation and the local website. */
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -10,18 +10,18 @@ import { pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
 
 import { atomic_json } from './files.mjs';
-import { read_project_files } from './project_files.mjs';
+import { outside_directory, read_only_enforced, read_project_files, room_directories, search_project_roots } from './project_files.mjs';
 import { guard_remote_request, list_remote_directories } from './remote_policy.mjs';
 import { list_devices, machine_fingerprint, revoke_device, start_pairing } from './device_auth.mjs';
 import { setup_sidecar } from './adapters/antigravity_app.mjs';
-import { adapter_of, adoption_adapter, BRANCHABLE_ADAPTERS, branch_session, session_settings, software_defaults, software_effort, software_models } from './adapters/index.mjs';
+import { adapter_of, adoption_adapter, BRANCHABLE_ADAPTERS, branch_session, execution_details, session_settings, software_defaults, software_effort, software_models } from './adapters/index.mjs';
 import { ADAPTER_IDS, ADAPTER_PROFILES, adapter_profile, DEFAULT_API_MAX_REQUESTS, MAX_API_MAX_REQUESTS, platform_adapters, same_session_family } from './adapters/profiles.mjs';
 import { API_PROVIDERS, api_check, api_models, save_api_key, saved_api_keys, validate_api_profile } from './discussion_api.mjs';
 import { DEFAULT_SCHEDULER_MODE, SCHEDULER_MODES, SCHEDULER_PROVIDERS, scheduler_check } from './scheduler.mjs';
 import { save_tts_settings, tts_settings, tts_speak } from './tts.mjs';
 import { stt_part } from './stt.mjs';
 import { access_levels, BUILTIN_EXPERT_PRESETS, MAX_EXPERT_PROMPT, PROJECT_ACCESS } from './expert_prompts.mjs';
-import { acquire_lock, api, DiscussionStore, service_drafts, validate_config } from './discussion_runner.mjs';
+import { acquire_lock, api, check_extra_directories, DiscussionStore, service_drafts, validate_config } from './discussion_runner.mjs';
 import { FreeRoomRunner, free_task_files } from './free_runner.mjs';
 import { bind_room_workflow, delete_workflow, get_workflow, list_workflows, load_room_workflow, parse_workflow_draft, preview_workflow, save_workflow, workflow_directory, WORKFLOW_ID_PATTERN } from './workflows.mjs';
 import { assert_shared_home, CONNECTION_FIELDS, configuration_snapshot, read_registry, registered_identity, register_room, service_home, service_pid, start_service } from './discussion_service.mjs';
@@ -59,6 +59,7 @@ const HELP = `用法：codiscuss launch settings [--file FILE]
       codiscuss launch room-config --file FILE
       codiscuss launch room-models --file FILE
       codiscuss launch room-files --file FILE
+      codiscuss launch execution-details --file FILE
       codiscuss launch models --file FILE
       codiscuss launch api-key --file FILE
       codiscuss launch api-check --file FILE
@@ -91,6 +92,7 @@ start 使用启动 JSON 创建或接入房间并启动；--dry-run 只校验和
 room-config 修正已暂停房间的软件路径或切换 Codex App / CLI，不启动讨论；须提供 site、room_id、token。
 room-models 只读指定 site、room_id 的本机登记模型与思考强度，不启动讨论；quick 为 true 时不查询 agy 的默认模型（较慢），该成员标 defaults_pending。
 room-files 只读房间已保存的项目目录，须提供 site、room_id、token，可选相对 path 和目录分页 offset；文件返回最多前 128 KiB 文本；给 query 时改为按名称搜索整个项目（含 / 时按路径），最多返回 50 项。
+execution-details 只读房间某次执行的过程细节（中间说明、命令与输出、搜索、改动、工具调用），由本机日志还原，须提供 site、room_id、token、execution_id；细节只留在本机，不写入网站。
 models 按 adapter、executable 或 API profile 读取模型目录，不启动讨论或生成回答。
 api-key 将 base_url、api_key 保存于本机私有目录，只返回 api_key_ref。
 api-check 用 API profile 向模型发送一次极短请求，核对地址、密钥、协议与模型是否可用。
@@ -100,7 +102,7 @@ tts 用朗读设置把 text（不超过 300 字）合成为 MP3，返回 base64
 stt 按序接收录音片段（upload_id、index、base64 PCM 16 kHz 单声道、final）；最后一段时识别整段录音并返回 text。
 pick-directory 在本机弹出系统目录选择窗口，返回所选路径；取消时不返回路径。
 browse-directory 列出常用项目及其中的子文件夹（只含文件夹名，分页），供其他设备选择目录；path 为空时列出常用项目。
-device-pairing 在本机生成 12 位设备配对码（2 分钟有效，可选 temporary 临时设备、site 指定已绑定的网站），扫码链接带本机密钥指纹；只能在这台电脑上执行，新设备只能在电脑前添加。
+device-pairing 在本机生成 12 位设备配对码（2 分钟有效，可选 temporary 临时设备、without_passkey 允许这次配对不用通行密钥、site 指定已绑定的网站），扫码链接带本机密钥指纹；只能在这台电脑上执行，新设备只能在电脑前添加。
 devices 列出已配对设备；提供 revoke（设备 id）撤销设备。
 projects 读取本机已配置的项目（名称与绝对路径）；提供 JSON（projects 列表）时整体替换保存。
 presets 读取本机的专家预设（含未删除的内置预设）与各平台默认描述；提供 JSON（presets 列表、description_templates 和/或 hidden_builtins 已删除的内置预设名）时替换对应部分。
@@ -342,11 +344,15 @@ export async function room_models(home, raw, { read_defaults = profile => cached
       ...(actual.model ? { actual_model: actual.model } : {}), ...(actual.effort ? { actual_effort: actual.effort } : {}),
       project_access: !facts?.capabilities.project ? 'read' : profile.project_access || config.project_access || 'read',
       // A member bound to its own conversation may keep that conversation's project, so this tool cannot set its access.
-      own_project: Boolean(facts?.own_project_when_bound && profile.session_id) }];
+      own_project: Boolean(facts?.own_project_when_bound && profile.session_id),
+      // A member working outside every project directory of the room only reads them; the page warns and names its directory.
+      ...(facts?.capabilities.project && outside_directory(config, profile) ? { outside_directory: outside_directory(config, profile),
+        outside_enforced: read_only_enforced({ ...profile, project_access: profile.project_access || config.project_access || 'read' }) } : {}) }];
   })));
   // Smart scheduling is a local choice; only which model decides is shown, never its key.
   const scheduler = config.scheduler ? { provider: config.scheduler.provider, model: config.scheduler.model, mode: config.scheduler.mode || DEFAULT_SCHEDULER_MODE } : null;
   return { room_id: input.room_id, registered: paths.length > 0, participants, scheduler, project_directory: config.cwd || '',
+    extra_directories: config.extra_directories || [],
     workflow: room_workflow_status(config, home), host_workflows: Boolean(config.host_workflows),
     api_max_requests: config.api_max_requests ?? DEFAULT_API_MAX_REQUESTS };
 }
@@ -359,10 +365,17 @@ function room_workflow_status(config, home) {
     available: !loaded.error, members: config.workflow.members || {} };
 }
 
-/** Read the owner's saved room project, never a directory supplied by the request. */
+/**
+ * Read the owner's saved room projects, never a directory supplied by the request: `root` picks one of the room's
+ * directories by index (0, the main one, by default), and a search covers all of them.
+ */
 export async function room_files(home, raw, { trust = false } = {}) {
   const { input, config } = await member_room_context(home, raw, { trust });
-  return { room_id: input.room_id, ...read_project_files(config.cwd, input.path, input.offset, input.query) };
+  const directories = room_directories(config);
+  if (input.query) return { room_id: input.room_id, ...search_project_roots(directories, input.query) };
+  const root = input.root ?? 0;
+  if (!Number.isSafeInteger(root) || root < 0 || (directories.length && root >= directories.length)) throw new Error('项目目录编号无效，请刷新后重试');
+  return { room_id: input.room_id, root, ...read_project_files(directories[root], input.path, input.offset) };
 }
 
 /**
@@ -375,6 +388,33 @@ export async function remote_room_files(home, input) {
   return room_files(home, input, { trust: true });
 }
 
+// The newest part of a long-running execution's log is what its detail view needs; older lines are dropped.
+const DETAIL_LOG_TAIL_BYTES = 4 * 1024 * 1024;
+
+/**
+ * What a member did in one execution, rebuilt from the raw event log its process wrote in the room's runtime directory
+ * (`<adapter>-free-<execution>.log`). The log stays on this computer: the page reads it here or through the relay.
+ * `available: false` when the execution kept no such log (an App or manual member, or an API member).
+ */
+export async function execution_details_command(home, raw, { trust = false } = {}) {
+  const { input, config } = await member_room_context(home, raw, { trust });
+  const execution_id = Number(input.execution_id);
+  if (!Number.isSafeInteger(execution_id) || execution_id <= 0) throw new Error('执行编号无效');
+  const suffix = `-free-${execution_id}.log`;
+  const name = existsSync(config.directory) ? readdirSync(config.directory).find(file => file.endsWith(suffix)) : undefined;
+  const parsed = name ? execution_details(name.slice(0, -suffix.length), read_log_tail(join(config.directory, name))) : null;
+  return { room_id: input.room_id, execution_id, available: Boolean(parsed), ...parsed };
+}
+
+/** The last bytes of a log as text, starting at a whole line. */
+function read_log_tail(path) {
+  const size = statSync(path).size, length = Math.min(size, DETAIL_LOG_TAIL_BYTES);
+  const buffer = Buffer.alloc(length), descriptor = openSync(path, 'r');
+  try { readSync(descriptor, buffer, 0, length, size - length); } finally { closeSync(descriptor); }
+  const text = buffer.toString('utf8');
+  return length < size ? text.slice(text.indexOf('\n') + 1) : text;
+}
+
 const CREATE_PREFERENCE_RANGES = { max_rounds: [0, 100], max_minutes: [0, 1440], goal_max_continues: [0, 100], goal_max_minutes: [0, 1440], chain_rounds: [0, 100],
   api_max_requests: [0, MAX_API_MAX_REQUESTS] };
 const CREATE_PREFERENCE_FLAGS = ['named_followup', 'host_workflows', 'advanced_open'];
@@ -578,6 +618,9 @@ function launch_input(input) {
   if (!['conversation', 'web'].includes(value.entry)) throw new Error('entry 必须为 conversation 或 web');
   if (value.entry === 'conversation' && (typeof value.current_session_id !== 'string' || !value.current_session_id.trim())) throw new Error('对话入口须提供当前实际会话的 current_session_id');
   if (value.cwd && (typeof value.cwd !== 'string' || !isAbsolute(value.cwd))) throw new Error('cwd 必须为完整绝对路径');
+  // A new room's extra project directories; an existing room changes them through room-settings.
+  if (!value.room_id && value.extra_directories?.length) check_extra_directories(value.cwd, value.extra_directories);
+  else if (!value.room_id) delete value.extra_directories;
   if (value.project_access && !PROJECT_ACCESS.includes(value.project_access)) throw new Error('project_access 只能为 read、write、auto 或 full');
   if (value.room_id && !/^[A-Za-z0-9_-]+$/.test(value.room_id)) throw new Error('房间编号无效');
   if (!value.room_id && !value.room?.submission_id) throw new Error('新房间须提供 room.submission_id；重试沿用原编号');
@@ -622,7 +665,7 @@ function launch_config(home, input, room, directory, options) {
   const members = launch_members(input, Object.keys(participants), options);
   return validate_config({ site: input.site, room: room.id || 'preview', token: options.token, mode: 'free', participants, members, api_home: home,
     scheduler: input.scheduler || undefined,
-    cwd: input.cwd, discussion_project: input.discussion_project, project_access: input.project_access || undefined,
+    cwd: input.cwd, extra_directories: input.extra_directories, discussion_project: input.discussion_project, project_access: input.project_access || undefined,
     data_directory: join(directory, 'runtime'), draft_directory: service_drafts(home, join(directory, 'runtime')) }, directory);
 }
 
@@ -640,7 +683,7 @@ function free_launch_config(home, input, room, directory, options) {
   if (workflow) get_workflow(home, workflow.id);
   if (workflow && Object.values(workflow.members).some(name => !names.includes(name))) throw new Error('工作流成员须在本次邀请的成员中');
   return validate_config({ site: input.site, room: room.id || 'preview', token: options.token, mode: 'free', participants, members, api_home: home,
-    scheduler: input.scheduler || undefined, cwd: input.cwd, project_access: input.project_access || undefined, workflow,
+    scheduler: input.scheduler || undefined, cwd: input.cwd, extra_directories: input.extra_directories, project_access: input.project_access || undefined, workflow,
     host_workflows: input.host_workflows === true || undefined, api_max_requests: input.api_max_requests,
     data_directory: join(directory, 'runtime'), draft_directory: service_drafts(home, join(directory, 'runtime')) }, directory);
 }
@@ -704,7 +747,9 @@ function same_directory(left, right) {
 /**
  * Prove an invited existing conversation is on this machine before it can hold a turn, so a mistyped ID
  * fails here instead of pausing the discussion later. Claude stores sessions per directory and resumes only
- * from the original one, so its cwd follows the session; a different room project is refused.
+ * from the original one, so its cwd follows the session: a session kept elsewhere than the room's project joins as a
+ * member working in its own directory (it only reads the room's directories); only a directory the member's own
+ * settings name explicitly must match.
  */
 export function borrowed_session(name, profile, room_cwd, env = process.env) {
   const id = profile.session_id;
@@ -718,9 +763,8 @@ export function borrowed_session(name, profile, room_cwd, env = process.env) {
   if (adapter.adopt !== 'own_cwd') return profile;
   const cwd = adapter.session.cwd(id, { env });
   if (!cwd) throw new Error(`${name}：${adapter.label} 会话 ${id} 没有记录原工作目录，无法续接`);
-  const wanted = profile.cwd || room_cwd;
-  if (wanted && !same_directory(wanted, cwd)) throw new Error(`${name}：这个 Claude 会话属于 ${cwd}，只能在原目录续接；请让项目目录与它一致，或留空会话 ID 新建会话`);
-  return { ...profile, cwd: wanted || cwd };
+  if (profile.cwd && !same_directory(profile.cwd, cwd)) throw new Error(`${name}：这个 ${adapter.label} 会话属于 ${cwd}，只能在原目录续接；请让此 AI 的工作目录与它一致，或留空会话 ID 新建会话`);
+  return { ...profile, cwd: profile.cwd || (room_cwd && same_directory(room_cwd, cwd) ? room_cwd : cwd) };
 }
 
 // An owner credential the website accepted is trusted this long for read-only file browsing in a long-running process
@@ -824,19 +868,36 @@ export async function room_member(home, raw, locked = false) {
 
 
 /**
- * Change this room's runner settings: `api_max_requests`, how many model requests one execution of an API member may
- * make (0 = no limit). Read at each delivery, so it applies from the next execution.
+ * Change this room's runner settings, any of: `api_max_requests`, how many model requests one execution of an API member
+ * may make (0 = no limit); `cwd`, the main project directory, accepted only while the room has none (once set it never
+ * changes: sessions and file-change tracking are bound to it); `extra_directories`, the project directories shared
+ * besides the main one, replaced as a whole. Members already in a room that gets its main directory keep working where
+ * their sessions are (their `cwd` is pinned to '') and reach the room's directories as extra ones; members invited later
+ * work in it. Everything is read at each delivery, so it applies from the next execution and keeps every session.
  */
 export async function room_settings(home, raw) {
   const { input, path } = await member_room_context(home, raw);
-  const value = input.api_max_requests;
-  if (!Number.isInteger(value)) throw new Error('api_max_requests 须为整数');
+  const { api_max_requests: requests, extra_directories: directories, cwd } = input;
+  if (requests === undefined && directories === undefined && cwd === undefined) throw new Error('须提供 api_max_requests、cwd 或 extra_directories');
+  if (requests !== undefined && !Number.isInteger(requests)) throw new Error('api_max_requests 须为整数');
   const release = acquire_lock(join(dirname(path), 'configuration-edit'));
   try {
-    const next = { ...configuration_snapshot(path).config, api_max_requests: value };
+    const config = configuration_snapshot(path).config;
+    const next = { ...config, ...(requests !== undefined ? { api_max_requests: requests } : {}) };
+    if (cwd !== undefined) {
+      if (config.cwd) throw new Error('本房间已有项目目录，建房后不能更改；可添加其他项目目录');
+      if (typeof cwd !== 'string' || !isAbsolute(cwd) || !existsSync(cwd) || !statSync(cwd).isDirectory()) throw new Error('项目目录须为本机已有文件夹的完整路径');
+      next.cwd = cwd;
+      next.participants = Object.fromEntries(Object.entries(config.participants || {}).map(([name, profile]) => [name, { ...profile, cwd: profile.cwd ?? '' }]));
+    }
+    if (directories !== undefined) {
+      check_extra_directories(next.cwd, directories);
+      next.extra_directories = directories.length ? directories : undefined;
+    }
     validate_config(next, dirname(path));
     atomic_json(path, next);
-    return { room_id: input.room_id, api_max_requests: value };
+    return { room_id: input.room_id, ...(requests !== undefined ? { api_max_requests: requests } : {}),
+      ...(cwd !== undefined ? { project_directory: cwd } : {}), ...(directories !== undefined ? { extra_directories: directories } : {}) };
   } finally { release(); }
 }
 
@@ -1774,6 +1835,7 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
   else if (positionals[0] === 'stt' && input) result = await stt_part(home, input);
   else if (positionals[0] === 'room-models' && input) result = await room_models(home, input);
   else if (positionals[0] === 'room-files' && input) result = await room_files(home, input);
+  else if (positionals[0] === 'execution-details' && input) result = await execution_details_command(home, input);
   else if (positionals[0] === 'models' && adapter_profile(input?.adapter)?.kind === 'api') result = await api_models(home, input);
   else if (positionals[0] === 'models' && input) {
     const saved = Object.values(launch_settings(home).participants).find(profile => profile.adapter === input.adapter);
@@ -1796,7 +1858,7 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
     const { keyed_links } = await import('./remote_launch.mjs');
     const [site, link] = Object.entries(keyed_links(home).sites).find(([origin]) => !input?.site || origin === input.site) || [];
     if (!link) throw new Error('这台电脑还没有绑定线上网站，请先运行 codiscuss local connect 网站地址');
-    result = start_pairing(home, { site, fingerprint: machine_fingerprint(link), temporary: input?.temporary === true });
+    result = start_pairing(home, { site, fingerprint: machine_fingerprint(link), temporary: input?.temporary === true, without_passkey: input?.without_passkey === true });
   }
   else if (positionals[0] === 'devices' && !values.remote) {
     result = input?.revoke ? revoke_device(home, String(input.revoke)) : list_devices(home);

package/runner/discussion_local.mjs

@@ -91,6 +91,8 @@ async function bind_machine(home, origin, setup_key) {
     headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ...link, setup_key: key }) });
   const result = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(result.error || `绑定失败：HTTP ${response.status}`);
+  // From now on this website reaches the local one only as the relay's bridge, never with a browser connection credential.
+  (await import('./relay_channel.mjs')).bridge_token(home, origin);
   await sync_remote_launches(home);
 }
 

package/runner/discussion_runner.mjs

@@ -2,7 +2,7 @@
 import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
@@ -15,6 +15,8 @@ import { validate_scheduler } from './scheduler.mjs';
 import { bind_room_workflow } from './workflows.mjs';
 
 const POLL_MS = 2000;
+// A room's members work in its main project directory and at most this many extra ones.
+export const MAX_EXTRA_DIRECTORIES = 8;
 let rg_available;
 /**
  * Windows PowerShell mis-decodes UTF-8 files, so point the AI at rg when its commands can run it; free rooms and
@@ -76,6 +78,7 @@ export function validate_config(input, base_directory) {
   if (Object.keys(config.participants).some(name => typeof config.members?.[name]?.token !== 'string' || config.members[name].token.length < 32)) {
     throw new Error('房间配置须为每位成员保存成员凭证；旧版配置请重新接入房间');
   }
+  if (config.extra_directories !== undefined) check_extra_directories(config.cwd, config.extra_directories, { exists: false });
   // A bound workflow only names a folder and which member plays which card; its content is read at each execution.
   if (config.workflow) config.workflow = bind_room_workflow({}, config.workflow).workflow;
   // How many model requests an API member's execution may make; absent means the adapter's default.
@@ -86,6 +89,36 @@ export function validate_config(input, base_directory) {
   return { ...config, mode: 'free', site: url.origin, project: resolve(config.project), directory: resolve(config.data_directory || join(base_directory, `discussion-${config.room}`)) };
 }
 
+/** Whether one directory is the other or lies inside it; Windows paths compare without case. */
+export function overlapping_directories(left, right) {
+  const [a, b] = [left, right].map(path => process.platform === 'win32' ? resolve(path).toLowerCase() : resolve(path));
+  const inside = (outer, inner) => { const rest = relative(outer, inner); return !rest.startsWith('..') && !isAbsolute(rest); };
+  return inside(a, b) || inside(b, a);
+}
+
+/**
+ * Check a room's extra project directories: existing folders given as absolute paths, added to a main directory, and
+ * none inside another (a folder inside one already shared adds nothing and would be watched twice).
+ * @param {string} cwd - the room's main project directory.
+ * @param {unknown} directories - the extra directories as given.
+ * @param {{exists?: boolean}} options - `exists: false` skips the existence check, so a saved room whose folder was
+ *   later moved still loads (its members then work without it).
+ * @returns {string[]} the directories, unchanged.
+ */
+export function check_extra_directories(cwd, directories, { exists = true } = {}) {
+  if (!Array.isArray(directories) || directories.length > MAX_EXTRA_DIRECTORIES) throw new Error(`extra_directories 须为最多 ${MAX_EXTRA_DIRECTORIES} 个目录的列表`);
+  if (directories.length && !cwd) throw new Error('添加其他项目目录前须先指定房间的项目目录');
+  const seen = cwd ? [cwd] : [];
+  for (const directory of directories) {
+    if (typeof directory !== 'string' || !isAbsolute(directory)) throw new Error('项目目录须为完整绝对路径');
+    if (exists && (!existsSync(directory) || !statSync(directory).isDirectory())) throw new Error(`项目目录 ${directory} 在本机不存在或不是文件夹`);
+    const overlap = seen.find(other => overlapping_directories(other, directory));
+    if (overlap) throw new Error(`项目目录 ${directory} 与 ${overlap} 重复或互相包含`);
+    seen.push(directory);
+  }
+  return directories;
+}
+
 /** Send exactly one bounded website request; never follow redirects with a capability. */
 export async function api(config, tail, body, token = config.token) {
   const response = await fetch(`${config.site}/api/rooms/${config.room}${tail}`, {

package/runner/expert_prompts.mjs

@@ -79,26 +79,33 @@ export function access_label(level) { return level === 'own' ? '自行决定' :
 export const TASK_SUBCOMMANDS = ['room', 'message', 'turn', 'state', 'goal', 'mode', 'review', 'sequence', 'execution', 'health', 'schema', 'launch workflow-adopt', 'launch workflow-join'];
 
 /**
- * Whether a member may run commands beyond the codiscuss subcommands: every level but 只读, and 可写 only with a project.
- * A taken-over manual member (`own`) keeps its own session's permissions, so the room's limits do not apply.
+ * Whether a member may run commands beyond the codiscuss subcommands: every level but 只读, and 可写 only with a project
+ * (its own, or one of the room's directories it may write, `extra_directories`). A taken-over manual member (`own`)
+ * keeps its own session's permissions, so the room's limits do not apply.
  */
-export function runs_commands(config) {
+export function runs_commands(config, extra_directories = []) {
   const access = config.project_access;
-  return ['own', 'auto', 'full'].includes(access) || (access === 'write' && Boolean(config.cwd || config.workdir));
+  return ['own', 'auto', 'full'].includes(access) || (access === 'write'
+    && Boolean(config.cwd || config.workdir || extra_directories.some(item => item.access === 'write')));
 }
 
-/** The task text's rule for project files and commands; `purpose` says what the member works for (按请求 / 按议题需要). */
-export function project_rule(profile, purpose) {
+/**
+ * The task text's rule for project files and commands; `purpose` says what the member works for (按请求 / 按议题需要).
+ * A member without its own project may still have the room's directories in `extra_directories`.
+ */
+export function project_rule(profile, purpose, extra_directories = []) {
   if (profile.project_access === 'own') return '项目文件与命令权限沿用你自己会话的软件设置。';
   if (profile.project_access === 'auto') return `由软件自动审批：可${purpose}修改项目文件并运行所需命令；被沙箱或审批拦下时按软件方式申请放行（Codex 申请提权），仍被拒绝就在回答中说明。`;
   if (profile.project_access === 'full') return `已跳过软件审批与沙箱，可${purpose}修改文件并运行所需命令。`;
+  if (!profile.cwd && extra_directories.length) return runs_commands(profile, extra_directories)
+    ? `用户允许${purpose}修改项目文件并运行所需命令。` : '项目文件只读，不修改。';
   if (!profile.cwd) return '未指定项目目录。';
   return profile.project_access === 'write' ? `用户允许${purpose}修改 cwd 中的项目文件并运行所需命令。` : 'cwd 中的项目文件只读，不修改。';
 }
 
 /** The fixed rules one software needs in every task, from its adapter profile; no member prompt can drop them. */
-export function software_rules(config, cli) {
-  return adapter_profile(config.adapter)?.task_rules?.(cli, { runs_commands: runs_commands(config) }) || '';
+export function software_rules(config, cli, extra_directories = []) {
+  return adapter_profile(config.adapter)?.task_rules?.(cli, { runs_commands: runs_commands(config, extra_directories) }) || '';
 }
 
 /** Windows PowerShell mis-decodes UTF-8 files; the runner adds this where the member's commands can run rg. */
@@ -112,11 +119,14 @@ export const READ_RULE = '读含中文的文件用 rg --encoding utf-8 . 文件
  * otherwise where the task file is, plus how to read files at all; the task file's fields carry this execution's values
  * (messages, read point, execution, role, credentials), the skills it lists say how to use them, and `instructions`
  * holds only the limits no skill can know. `access_file` is set where the credential is not bound to the process.
+ * `extra_directories` are the room's other project directories this member works with, each read-only or writable.
  */
-export function free_task_text({ name, discussion, discussion_request, profile, cli, messages, read_after, task_path, access_file = '', read_rule = '' }) {
+export function free_task_text({ name, discussion, discussion_request, profile, cli, messages, read_after, task_path, access_file = '', read_rule = '',
+  extra_directories = [] }) {
   const scope = discussion ? `讨论进行中，用户直接向你提问（${messages}）：只回答这个提问，不改变讨论安排和进度。` : '';
-  const commands = runs_commands(profile) ? '' : `命令只用 subcommands 列出的 ${cli} 子命令。`;
-  const instructions = `${software_rules(profile, cli)}${scope}${project_rule(profile, '按请求')}${commands}草稿写在 draft_directory。`;
+  const commands = runs_commands(profile, extra_directories) ? '' : `命令只用 subcommands 列出的 ${cli} 子命令。`;
+  const extras = extra_directories.length ? 'extra_directories 是本房间的其他项目目录，access 为 read 的只读、不修改。' : '';
+  const instructions = `${software_rules(profile, cli, extra_directories)}${scope}${project_rule(profile, '按请求', extra_directories)}${extras}${commands}草稿写在 draft_directory。`;
   if (discussion_request) {
     const role = discussion_request.purpose === 'discuss_host' ? '主持任务' : '发言请求';
     const prompt = `你（${name}）收到了讨论中的${role}。先读任务文件 ${task_path}，按其中列出的技能处理本次请求并保存结果。${read_rule}`;