@ours.network/fleet 1.2.0-nightly.8 → 1.2.0-nightly.81

package/dist/harness/codex-app-server-proxy.js

@@ -300,9 +300,9 @@ function sandboxMode(policy) {
  * Fleet keeps the preset's sandbox policy, but restores the independently
  * configured approval policy on the request Codex actually executes.
  */
-function rewriteMessage(value, approval, expectedSandbox, disableInheritedMcp) {
+function rewriteMessage(value, approval, expectedSandbox, disableInheritedMcp, managedOursTools) {
     if (Array.isArray(value))
-        return value.map(candidate => rewriteMessage(candidate, approval, expectedSandbox, disableInheritedMcp));
+        return value.map(candidate => rewriteMessage(candidate, approval, expectedSandbox, disableInheritedMcp, managedOursTools));
     if (!isObject(value) || !isObject(value.params))
         return value;
     if (value.method === 'turn/start') {
@@ -318,17 +318,52 @@ function rewriteMessage(value, approval, expectedSandbox, disableInheritedMcp) {
             params: { ...value.params, config: { ...config, mcp_servers: {} } },
         };
     }
+    if (managedOursTools
+        && (value.method === 'thread/start' || value.method === 'thread/resume')) {
+        const config = isObject(value.params.config) ? value.params.config : {};
+        const servers = isObject(config.mcp_servers) ? config.mcp_servers : {};
+        const ours = servers.ours;
+        // Policy cannot create or re-enable a connector that ACP did not inject.
+        if (!isObject(ours) || ours.enabled === false)
+            return value;
+        const tools = isObject(ours.tools) ? { ...ours.tools } : {};
+        for (const [name, policy] of Object.entries(managedOursTools)) {
+            if (isObject(policy))
+                tools[name] = {
+                    ...(isObject(tools[name]) ? tools[name] : {}), ...policy,
+                };
+        }
+        return { ...value, params: { ...value.params, config: { ...config,
+                    mcp_servers: { ...servers, ours: { ...ours, tools } },
+                } } };
+    }
     return value;
 }
 /** Transform one app-server NDJSON request; malformed input passes through. */
-export function rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp = false) {
+export function rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp = false, managedOursTools) {
     try {
-        return JSON.stringify(rewriteMessage(JSON.parse(line), approval, expectedSandbox, disableInheritedMcp));
+        return JSON.stringify(rewriteMessage(JSON.parse(line), approval, expectedSandbox, disableInheritedMcp, managedOursTools));
     }
     catch {
         return line;
     }
 }
+/** ACP only carries transport fields; read policy from Fleet's complete config. */
+export function managedCodexToolPolicy(env) {
+    if (env.FLEET_OURS_MANAGED !== '1')
+        return undefined;
+    try {
+        const config = JSON.parse(env.CODEX_CONFIG ?? '{}');
+        const servers = isObject(config) ? config.mcp_servers : undefined;
+        const ours = isObject(servers) ? servers.ours : undefined;
+        return isObject(ours) && ours.enabled !== false && isObject(ours.tools)
+            ? ours.tools : undefined;
+    }
+    catch {
+        // Invalid config never grants tool approval. ACP owns config diagnostics.
+        return undefined;
+    }
+}
 function requiredChoice(name, allowed) {
     const value = process.env[name];
     if (value && allowed.has(value))
@@ -355,6 +390,7 @@ export function runCodexAppServerProxy() {
     const approval = requiredChoice(APPROVAL_ENV, APPROVAL_POLICIES);
     const expectedSandbox = requiredChoice(SANDBOX_ENV, SANDBOX_MODES);
     const disableInheritedMcp = process.env[DISABLE_INHERITED_MCP_ENV] === '1';
+    const managedOursTools = managedCodexToolPolicy(process.env);
     const launch = realCodexLaunch();
     const env = { ...process.env };
     delete env.CODEX_PATH;
@@ -450,7 +486,7 @@ export function runCodexAppServerProxy() {
     input.on('line', line => {
         if (finished)
             return;
-        const rewritten = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp);
+        const rewritten = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp, managedOursTools);
         recovery.observeClientLine(rewritten);
         writeToChild(rewritten);
     });

package/dist/harness/codex-reasoning.d.ts

@@ -0,0 +1,5 @@
+/** Efforts supported by Fleet's Codex Brain contract. Keep native eligibility in sync. */
+export declare const CODEX_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh", "max", "ultra"];
+export declare function isCodexReasoningEffort(value: unknown): value is string;
+/** Only inspected model tuning may bypass the managed CLI native-config guard. */
+export declare function isManagedCliCodexConfig(config: unknown): boolean;

package/dist/harness/codex-reasoning.js

@@ -0,0 +1,12 @@
+/** Efforts supported by Fleet's Codex Brain contract. Keep native eligibility in sync. */
+export const CODEX_REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+export function isCodexReasoningEffort(value) {
+    return typeof value === 'string' && CODEX_REASONING_EFFORTS.includes(value);
+}
+/** Only inspected model tuning may bypass the managed CLI native-config guard. */
+export function isManagedCliCodexConfig(config) {
+    if (config == null)
+        return true;
+    return typeof config === 'object' && !Array.isArray(config)
+        && Object.entries(config).every(([key, value]) => key === 'model_reasoning_effort' && isCodexReasoningEffort(value));
+}

package/dist/harness/codex-runtime.d.ts

@@ -4,8 +4,18 @@ export declare const VERIFIED_CODEX_ACP_VERSIONS: Set<string>;
 export declare function executableOnPath(command: string, env: NodeJS.ProcessEnv, cwd?: string): string;
 /** Match the npm Codex wrapper's platform-package/vendor selection. */
 export declare function codexExecutable(entry: string): string;
+/**
+ * The host's own Codex, when ACP sessions should run it instead of the copy bundled with the adapter.
+ * The person signs in to, updates and checks the host Codex, and a newer Codex knows models the bundled
+ * one does not. It is used only when it is at least as new as the bundled copy; an explicit CODEX_PATH
+ * (including an empty one, which selects the bundled copy) always decides instead.
+ */
+export declare function hostCodex(adapterManifest: string | undefined, env: NodeJS.ProcessEnv, cwd?: string, version?: (path: string, env: NodeJS.ProcessEnv) => string | undefined): {
+    path: string;
+    version: string;
+} | undefined;
 export interface CodexRuntime {
-    source: 'CODEX_PATH' | 'bundled';
+    source: 'CODEX_PATH' | 'host' | 'bundled';
     entry: string;
     executable: string;
     version: string;

package/dist/harness/codex-runtime.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module';
-import { accessSync, constants, existsSync, realpathSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { accessSync, constants, existsSync, readFileSync, realpathSync } from 'node:fs';
 import { dirname, join, isAbsolute, resolve, delimiter } from 'node:path';
 import { realExec } from '../exec.js';
 export const VERIFIED_CODEX_ACP_VERSIONS = new Set(['1.1.7', '1.10.0']);
@@ -46,18 +47,44 @@ export function codexExecutable(entry) {
     }
     throw new Error(`Codex platform binary missing under ${vendor}; reinstall Fleet with optional dependencies`);
 }
+const versionOf = (text) => text.match(/\b(\d+\.\d+\.\d+)\b/)?.[1];
+function installedCodexVersion(path, env) {
+    const result = spawnSync(path, ['--version'], { env, encoding: 'utf8', timeout: 5_000, stdio: ['ignore', 'pipe', 'ignore'] });
+    return result.status === 0 ? versionOf(result.stdout ?? '') : undefined;
+}
+/**
+ * The host's own Codex, when ACP sessions should run it instead of the copy bundled with the adapter.
+ * The person signs in to, updates and checks the host Codex, and a newer Codex knows models the bundled
+ * one does not. It is used only when it is at least as new as the bundled copy; an explicit CODEX_PATH
+ * (including an empty one, which selects the bundled copy) always decides instead.
+ */
+export function hostCodex(adapterManifest, env, cwd = process.cwd(), version = installedCodexVersion) {
+    if (env.CODEX_PATH !== undefined || !adapterManifest)
+        return undefined;
+    let path, bundled;
+    try {
+        path = executableOnPath('codex', env, cwd);
+        bundled = JSON.parse(readFileSync(createRequire(adapterManifest).resolve('@openai/codex/package.json'), 'utf8')).version;
+    }
+    catch {
+        return undefined;
+    }
+    const found = version(path, env);
+    return found && typeof bundled === 'string' && codexVersionAtLeast(found, bundled) ? { path, version: found } : undefined;
+}
 export async function probeCodexRuntime(adapter, env, exec = realExec, cwd = process.cwd()) {
-    const configured = env.CODEX_PATH;
+    const host = hostCodex(adapter.manifestPath, env, cwd);
+    const configured = env.CODEX_PATH || host?.path;
     if (!configured && !adapter.manifestPath)
         throw new Error('ACP runtime is unknown for a PATH/custom adapter; set CODEX_PATH to an absolute executable or use the bundled adapter');
     const entry = configured ? executableOnPath(configured, env, cwd)
         : createRequire(adapter.manifestPath).resolve('@openai/codex/bin/codex.js');
     const executable = codexExecutable(entry);
     const result = await exec(!configured ? process.execPath : entry, !configured ? [entry, '--version'] : ['--version'], { env, timeout: 5_000 });
-    const version = result.stdout.match(/\b(\d+\.\d+\.\d+)\b/)?.[1];
+    const version = versionOf(result.stdout);
     if (result.code !== 0 || !version)
         throw new Error(`Cannot read Codex version from ${entry}; check CODEX_PATH and executable permissions`);
-    return { source: configured ? 'CODEX_PATH' : 'bundled', entry, executable, version };
+    return { source: host ? 'host' : configured ? 'CODEX_PATH' : 'bundled', entry, executable, version };
 }
 export function codexVersionAtLeast(version, minimum) {
     const actual = version.split('.').map(Number);

package/dist/harness/codex-session.js

@@ -32,7 +32,7 @@ export class CodexAgentSessionAdapter {
         if (role.session === 'codex-app-server')
             return this.nativeTransport({
                 name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
-                stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+                stateDir: options.stateDir, mode: options.mode, requireResume: options.requireResume, deferRecoveredPrompts: options.deferRecoveredPrompts, permissions: options.permissions,
                 permissionMode: options.permissionMode,
                 model: role.model, effort: role.effort,
                 approvalPolicy: this.strategy.approvalPolicy(role),
@@ -44,7 +44,7 @@ export class CodexAgentSessionAdapter {
         return this.transport({
             name: role.name, harness: role.harness,
             argv: launch.argv, cwd: options.cwd, env: launch.env,
-            stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+            stateDir: options.stateDir, mode: options.mode, requireResume: options.requireResume, deferRecoveredPrompts: options.deferRecoveredPrompts, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
             mcpServers: options.managedOurs ? [...(this.strategy.mcpServers(role) ?? []).filter(s => s.name !== 'ours'), options.managedOurs.server] : this.strategy.mcpServers(role),
             inheritEnvironment: options.managedOurs ? false : undefined,

package/dist/harness/codex.js

@@ -6,8 +6,9 @@ import { realExec } from '../exec.js';
 import { registerAdapter } from './registry.js';
 import { harnessRuntimeDir } from '../isolation/policy.js';
 import { resolveBundledAcpAgent, } from './acp-agent.js';
-import { VERIFIED_CODEX_ACP_VERSIONS, probeCodexRuntime, codexVersionAtLeast } from './codex-runtime.js';
+import { VERIFIED_CODEX_ACP_VERSIONS, probeCodexRuntime, codexVersionAtLeast, hostCodex } from './codex-runtime.js';
 import { CodexAgentSessionAdapter } from './codex-session.js';
+import { CODEX_REASONING_EFFORTS, isCodexReasoningEffort } from './codex-reasoning.js';
 const OPTION_KEYS = [
     'launcher', 'sandbox', 'approval', 'permission_mode', 'search', 'profile', 'config', 'add_dirs',
     'monitor',
@@ -141,6 +142,13 @@ function neutralSandboxMode(role) {
 function isNativeConfigKeyAllowed(key) {
     return NATIVE_CONFIG_ALLOWLIST.has(key);
 }
+/** Brain wins; a validated native effort also needs delivery through ACP's selection API. */
+function reasoningEffort(role) {
+    if (typeof role.effort === 'string')
+        return role.effort;
+    const value = role.harness_options?.config?.model_reasoning_effort;
+    return isCodexReasoningEffort(value) ? value : undefined;
+}
 /** Defense in depth for callers which launch a role after validation was bypassed. */
 export function nativeCodexConfig(role) {
     const options = role.harness_options;
@@ -266,7 +274,9 @@ function codexAcpEnvironment(role, dirs) {
         [CODEX_PROXY_APPROVAL_ENV]: approvalPolicy(role) ?? 'on-request',
         [CODEX_PROXY_SANDBOX_ENV]: acpRuntimeSandbox(role),
         [CODEX_PROXY_MANIFEST_ENV]: resolution.manifestPath,
-        [CODEX_PROXY_REAL_PATH_ENV]: role.env?.CODEX_PATH ?? process.env.CODEX_PATH ?? '',
+        // Same choice as probeCodexRuntime: an explicit CODEX_PATH, else a host Codex at least as new as the bundled one.
+        [CODEX_PROXY_REAL_PATH_ENV]: role.env?.CODEX_PATH ?? process.env.CODEX_PATH
+            ?? hostCodex(resolution.manifestPath, { ...process.env, ...role.env }, dirs.runCwd)?.path ?? '',
     };
 }
 function encodeTomlValue(value) {
@@ -316,10 +326,8 @@ export function makeCodexAdapter(exec = realExec, transport, nativeTransport) {
         id: 'codex',
         agentSession: new CodexAgentSessionAdapter({
             resolveBrain(brain) {
-                const levels = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
-                if (brain.effort != null
-                    && (typeof brain.effort !== 'string' || !levels.includes(brain.effort)))
-                    throw new Error(`Codex Brain effort must be one of: ${levels.join(', ')}`);
+                if (brain.effort != null && !isCodexReasoningEffort(brain.effort))
+                    throw new Error(`Codex Brain effort must be one of: ${CODEX_REASONING_EFFORTS.join(', ')}`);
                 const harnessOptions = { ...(brain.harnessOptions ?? {}) };
                 if (brain.effort)
                     harnessOptions.config = {
@@ -341,8 +349,8 @@ export function makeCodexAdapter(exec = realExec, transport, nativeTransport) {
             sessionConfigSelections: role => [
                 ...(typeof role.model === 'string'
                     ? [{ configId: 'model', value: role.model }] : []),
-                ...(typeof role.effort === 'string'
-                    ? [{ configId: 'reasoning_effort', value: role.effort }] : []),
+                ...(reasoningEffort(role)
+                    ? [{ configId: 'reasoning_effort', value: reasoningEffort(role) }] : []),
             ],
             permissionModeId: role => acpAgentMode(role),
             mcpServers: () => undefined,
@@ -613,12 +621,16 @@ export function makeCodexAdapter(exec = realExec, transport, nativeTransport) {
             supervisedWakeNote: () => 'Your mail wake-ups are delivered by the fleet supervisor directly into this console as ' +
                 '`[fleet-monitor]` lines — do NOT arm arm_monitor or foreground_monitor. When such a line ' +
                 'appears, call **get_messages**, handle the mail, and reply with send_message.',
-            launchNote: name => `You were launched as the fleet role \`${name}\` under a Codex session. Confirm you are running.`,
+            launchNote: name => `You were launched as the fleet role \`${name}\` under a Codex session. Announce console readiness before task details.`,
             restartPrompt: (id, worklog, configuredRole) => {
                 if (configuredRole?.monitor?.mode === 'fleet')
-                    return `Session restarted. Re-bind your ours identity now (choose_identity name "${id}" force=true); ` +
-                        'your mail wakes are delivered by the fleet supervisor as `[fleet-monitor]` console lines, so do ' +
-                        `NOT arm arm_monitor/foreground_monitor. Continue from ${worklog}. Do not re-run whatever crashed you.`;
+                    return `Session restarted. The supervisor has verified assigned identity "${id}"; ` +
+                        'accept that readiness and continue without rebinding or profile reconciliation. ' +
+                        'Mail wakes arrive as `[fleet-monitor]` lines; do NOT arm arm_monitor/foreground_monitor. ' +
+                        'Announce console readiness first without tools, then end that readiness turn. ' +
+                        `For a separate continuation task, read ${worklog} once for continuity if it records previous work; ` +
+                        'do not read it again later in this session. ' +
+                        'Do not re-run whatever crashed you.';
                 const consented = configuredRole?.harness_options?.monitor === true;
                 return `Session restarted. Re-bind your ours identity now (choose_identity name "${id}" force=true), ` +
                     (consented

package/dist/init-wizard.d.ts

@@ -53,6 +53,8 @@ export declare function validateCatalog(value: BrainCatalog, path?: string): Bra
 export declare function readInitSettings(path: string): InitAnswers;
 export declare function askInitQuestions(prompter: InitPrompter, configuration: string): Promise<InitAnswers | undefined>;
 export declare function formatSetupSummary(answers: InitAnswers, configuration: string): string;
+/** The packaged Brain preset for a catalog model at one effort; the same naming the presets are generated with. */
+export declare function brainPresetId(model: Pick<CatalogModel, 'harness' | 'model'>, effort: string): string;
 /** Build the exact, deterministic default experience without writing to disk. */
 export declare function generateSetup(answers: InitAnswers): GeneratedSetup;
 /** Run the mutation boundary only after the complete questionnaire is accepted. */

package/dist/init-wizard.js

@@ -7,13 +7,19 @@ import { packagedPresetRoot } from './preset-bootstrap.js';
 import { listTemplates } from './rooms-tasks/templates.js';
 const WORK_KINDS = ['development', 'review', 'coordination'];
 const ROLE_WORK = {
-    Developer: 'development', Critic: 'review',
+    Developer: 'development', Engineer: 'development', Critic: 'review',
     LocalCoordinator: 'coordination', Coordinator: 'coordination', FleetCoordinator: 'coordination',
 };
 const REASONING_EFFORT = {
     quick: 'low', balanced: 'medium', thorough: 'high',
 };
 const MODEL_LABELS = {
+    'gpt-6.1-sol': 'GPT-6.1 Sol',
+    'gpt-6-sol': 'GPT-6 Sol',
+    'gpt-6-luna': 'GPT-6 Luna',
+    'claude-fable-5-1': 'Claude Fable 5.1',
+    'claude-opus-5-5': 'Claude Opus 5.5',
+    'claude-haiku-4-5-20251001': 'Claude Haiku 4.5',
     'gpt-6-astra': 'GPT-6 Astra',
     'gpt-5.6-sol': 'GPT-5.6 Sol',
     'gpt-5.6-terra': 'GPT-5.6 Terra',
@@ -33,10 +39,10 @@ export function validateCatalog(value, path = 'supported model catalog') {
     for (const model of value.models) {
         if (!['codex', 'claude-code'].includes(model.harness) || model.session !== 'acp'
             || typeof model.model !== 'string' || !MODEL_LABELS[model.model]
-            || !Array.isArray(model.efforts) || model.efforts.length === 0
+            || !Array.isArray(model.efforts)
             || new Set(model.efforts).size !== model.efforts.length
             || model.efforts.some(effort => !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(effort))
-            || !['low', 'medium', 'high'].every(effort => model.efforts.includes(effort)))
+            || (model.efforts.length > 0 && !['low', 'medium', 'high'].every(effort => model.efforts.includes(effort))))
             throw new Error(`unsupported model state in ${path}`);
         const tuple = `${model.harness}\0${model.session}\0${model.model}`;
         if (tuples.has(tuple))
@@ -90,7 +96,9 @@ export async function askInitQuestions(prompter, configuration) {
         return undefined;
     if (subscriptions.length === 0)
         throw new Error('Select at least one subscription.');
-    const available = catalog().models.filter(model => subscriptions.includes(subscriptionFor(model)));
+    // The wizard assigns low/medium/high; no-effort models remain available as named presets.
+    const available = catalog().models.filter(model => subscriptions.includes(subscriptionFor(model))
+        && model.efforts.length > 0);
     if (!available.length)
         throw new Error('None of the selected subscriptions has a supported model.');
     prompter.note([
@@ -163,7 +171,9 @@ export function formatSetupSummary(answers, configuration) {
         '  One-agent work: one Developer',
         '  Reviewed pair: Developer + independent Critic',
         '  Team: LocalCoordinator + Developer + Critic',
+        '  Gated engineering: Engineer (gate pipeline) + independent Critic',
         '  FleetCoordinator: coordination model',
+        '  Brains: the packaged presets; each prepared agent references the preset of its chosen model',
         '',
         'After the final Yes, Fleet performs host service setup before publishing the complete configuration.',
         'A hard termination after that Yes can leave host integration or private stage/recovery evidence to inspect.',
@@ -172,6 +182,11 @@ export function formatSetupSummary(answers, configuration) {
 function preset(relative) {
     return readFileSync(join(packagedPresetRoot(), 'fleet', relative), 'utf8');
 }
+/** The packaged Brain preset for a catalog model at one effort; the same naming the presets are generated with. */
+export function brainPresetId(model, effort) {
+    return `${model.harness === 'claude-code' ? 'claude' : 'codex'}-${model.model
+        .replace(/^claude-/, '').replace(/\./g, '-').toLowerCase()}-${effort}`;
+}
 /** Build the exact, deterministic default experience without writing to disk. */
 export function generateSetup(answers) {
     const effort = REASONING_EFFORT[answers.reasoning];
@@ -192,6 +207,7 @@ export function generateSetup(answers) {
         '  permissions: { approval: ask, filesystem: workspace, unattended: deny }',
         '',
     ].join('\n'));
+    const assigned = {};
     for (const work of WORK_KINDS) {
         const proposed = answers.models[work];
         if (!proposed || !answers.subscriptions.includes(subscriptionFor(proposed)))
@@ -205,14 +221,14 @@ export function generateSetup(answers) {
             throw new Error(`${work} contains tampered model capabilities`);
         if (!model.efforts.includes(effort))
             throw new Error(`${MODEL_LABELS[model.model]} does not support ${answers.reasoning} reasoning`);
-        files.set(`brains/${work}.yaml`, [
-            `harness: ${model.harness}`,
-            `session: ${model.session}`,
-            `model: ${model.model}`,
-            `effort: ${effort}`,
-            '',
-        ].join('\n'));
+        // The chosen model is assigned by reference to its packaged Brain preset; setup defines no Brain of its own.
+        const id = brainPresetId(model, effort);
+        if (!existsSync(join(packagedPresetRoot(), 'fleet', 'brains', `${id}.yaml`)))
+            throw new Error(`no packaged Brain preset for ${MODEL_LABELS[model.model]} at ${effort} reasoning`);
+        assigned[work] = id;
     }
+    for (const name of readdirSync(join(packagedPresetRoot(), 'fleet', 'brains')).filter(name => name.endsWith('.yaml')).sort())
+        files.set(`brains/${name}`, preset(`brains/${name}`));
     if (answers.assignmentStrategy === 'one-model') {
         const tuples = new Set(WORK_KINDS.map(work => {
             const model = answers.models[work];
@@ -221,23 +237,26 @@ export function generateSetup(answers) {
         if (tuples.size !== 1)
             throw new Error('one-model assignment requires the same exact model for development, review, and coordination');
     }
-    for (const role of ['Coordinator', 'LocalCoordinator', 'Developer', 'Critic']) {
+    for (const role of ['Coordinator', 'LocalCoordinator', 'Developer', 'Engineer', 'Critic']) {
         files.set(`roles/${role}.yaml`, preset(`roles/${role}.yaml`));
         if (role === 'Coordinator')
             continue;
         files.set(`agent_templates/${role}.yaml`, [
             `role: { ref: ${role} }`,
-            `brain: { ref: ${ROLE_WORK[role]} }`,
+            `brain: { ref: ${assigned[ROLE_WORK[role]]} }`,
             'coordinator: FleetCoordinator',
-            'permissions: { approval: ask, filesystem: workspace, unattended: deny }',
+            // Temporary default while the product is being tested: prepared agents work without asking.
+            'permissions: { approval: allow, filesystem: unrestricted, unattended: deny }',
             'monitor: { mode: fleet, interrupt: after_tool }',
             '',
         ].join('\n'));
     }
     files.set('agents/FleetCoordinator.yaml', preset('agents/FleetCoordinator.yaml')
-        .replace('brain: { ref: claude-default }', 'brain: { ref: coordination }'));
-    for (const name of ['single', 'pair', 'team'])
+        .replace('brain: { ref: claude-default }', `brain: { ref: ${assigned.coordination} }`));
+    for (const name of ['single', 'pair', 'team', 'engineering']) {
         files.set(`room_templates/${name}.yaml`, preset(`room_templates/${name}.yaml`));
+        files.set(`room_layouts/${name}.yaml`, preset(`room_layouts/${name}.yaml`));
+    }
     return { files, answers };
 }
 /** Run the mutation boundary only after the complete questionnaire is accepted. */
@@ -385,7 +404,7 @@ function writeStaged(stageManifest, setup) {
         replaceFileAtomically(target, contents, 0o600);
         fsyncPath(target);
     }
-    for (const kind of ['agents', 'agent_templates', 'roles', 'brains', 'room_templates'])
+    for (const kind of ['agents', 'agent_templates', 'roles', 'brains', 'room_templates', 'room_layouts'])
         fsyncPath(join(stageRoot, kind));
     fsyncPath(stageRoot);
     fsyncPath(dirname(stageManifest));
@@ -394,8 +413,8 @@ function validateStaged(stageManifest) {
     const config = loadConfig(stageManifest, { yamlMode: 'strict' });
     const templates = listTemplates(config.roomTemplates ?? {});
     const names = new Set(templates.map(template => template.name));
-    if (!['pair', 'single', 'team'].every(name => names.has(name)))
-        throw new Error('generated setup did not resolve the default single, pair, and team experiences');
+    if (!['pair', 'single', 'team', 'engineering'].every(name => names.has(name)))
+        throw new Error('generated setup did not resolve the default single, pair, team, and engineering experiences');
     for (const template of templates)
         for (const member of template.members)
             if (!config.agentTemplates?.[member.agent_template])

package/dist/isolation/policy.js

@@ -1,3 +1,4 @@
+import { stateRoot } from '../paths.js';
 import { realpathSync } from 'node:fs';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { BACKENDS, ON_UNAVAILABLE, NETWORK_MODES, } from './types.js';
@@ -57,7 +58,7 @@ const SYSTEM_RO = ['/usr', '/bin', '/sbin', '/lib', '/lib64', '/etc'];
 /** Ephemeral scratch mounts. */
 const scratchTmpfs = (home) => ['/tmp', join(home, '.cache')];
 /** Home-relative sensitive paths never exposed (the blocklist's teeth). */
-const SENSITIVE_HOME = ['.ssh', '.aws', '.docker', '.gnupg', '.ours', 'fleet.yaml', 'fleet.d'];
+const SENSITIVE_HOME = ['.ssh', '.aws', '.docker', '.gnupg', '.ours', '.ours-fleet/private-ours', '.ours-fleet/private-file-delivery', 'fleet.yaml', 'fleet.d'];
 const ISOLATION_KEYS = ['backend', 'on_unavailable', 'fs', 'network', 'allow_hosts', 'resources', 'secrets'];
 const FS_KEYS = ['read', 'write'];
 const RESOURCE_KEYS = ['cpu', 'mem', 'pids'];
@@ -168,6 +169,8 @@ export function resolveIsolation(cfg, ctx) {
     }
     for (const dir of ctx.additionalWriteDirs ?? [])
         addRw(dir);
+    if (ctx.subscriptionHome)
+        addRw(ctx.subscriptionHome);
     // The selected harness/session command may live outside the system allowlist
     // (for example Node and a bundled ACP adapter under ~/.local). The runner
     // resolves its exact executable/package closure; keep every such bind RO.
@@ -187,6 +190,8 @@ export function resolveIsolation(cfg, ctx) {
     const agentsRoot = dirname(stateDir);
     const blocklist = [
         ...SENSITIVE_HOME.map(p => join(home, p)),
+        join(stateRoot(), 'private-ours'),
+        join(stateRoot(), 'private-file-delivery'),
         agentsRoot, // sibling agents' state dirs (this agent's own is explicitly mounted)
     ];
     // ENFORCE the list, before anything builds a backend argv. Until now it was

package/dist/isolation/types.d.ts

@@ -63,6 +63,11 @@ export interface WrapContext {
      * them for itself or for its peers.
      */
     harnessSharedPaths?: string[];
+    /**
+     * The pinned subscription profile home (CLAUDE_CONFIG_DIR / CODEX_HOME), mounted
+     * read-write so the CLI can refresh that profile's login. Absent for the default.
+     */
+    subscriptionHome?: string;
     /** Exact launcher/interpreter/module closure required by the selected command. */
     runtimeReadPaths?: string[];
     brokerEndpoint?: string;