@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.21

package/dist/harness/codex.js

@@ -16,6 +16,7 @@ const LAUNCHERS = ['auto', 'ours-codex', 'codex'];
 const SANDBOX_MODES = ['read-only', 'workspace-write', 'danger-full-access'];
 /** Codex CLI's accepted `--ask-for-approval` values. */
 const APPROVAL_POLICIES = ['untrusted', 'on-request', 'never'];
+const NATIVE_CONFIG_ALLOWLIST = new Set(['model_reasoning_effort']);
 const BUNDLED_CODEX_ACP_VERSION = '1.1.7';
 const CODEX_ACP_PACKAGE = '@agentclientprotocol/codex-acp';
 const CODEX_PROXY_APPROVAL_ENV = 'OURS_FLEET_CODEX_APPROVAL';
@@ -119,6 +120,34 @@ function approvalPolicy(role) {
         throw new Error(`invalid harness_options.approval "${a}"; allowed: ${APPROVAL_POLICIES.join(', ')}`);
     return a;
 }
+/** Native app-server policy comes only from Fleet's public permission contract. */
+function neutralApprovalPolicy(role) {
+    if (role.permissions?.approval === 'allow')
+        return 'never';
+    if (role.permissions?.approval === 'ask')
+        return 'untrusted';
+    return 'on-request';
+}
+/** Native app-server sandbox comes only from Fleet's public filesystem contract. */
+function neutralSandboxMode(role) {
+    if (role.permissions?.filesystem === 'read-only')
+        return 'read-only';
+    if (role.permissions?.filesystem === 'unrestricted')
+        return 'danger-full-access';
+    return 'workspace-write';
+}
+/** Native config is fail-closed because Codex adds authority-bearing keys over time. */
+function isNativeConfigKeyAllowed(key) {
+    return NATIVE_CONFIG_ALLOWLIST.has(key);
+}
+/** Defense in depth for callers which launch a role after validation was bypassed. */
+export function nativeCodexConfig(role) {
+    const options = role.harness_options;
+    if (!options?.config)
+        return undefined;
+    return Object.fromEntries(Object.entries(options.config)
+        .filter(([key]) => isNativeConfigKeyAllowed(key)));
+}
 function launcherMode(role) {
     return role.harness_options?.launcher ?? 'auto';
 }
@@ -126,6 +155,36 @@ function bundledCodexAcp() {
     return resolveBundledAcpAgent(CODEX_ACP_PACKAGE, 'codex-acp', 'codex-acp');
 }
 function codexAgentLaunch(role, prep) {
+    if (role.session === 'codex-app-server') {
+        const configured = role.session_options?.codex_app_server?.command;
+        if (Array.isArray(configured))
+            return { argv: [...configured], env: prep.env };
+        if (typeof configured === 'string')
+            return { argv: ['sh', '-c', configured], env: prep.env };
+        const launcher = launcherMode(role);
+        const options = role.harness_options;
+        const flags = [
+            ...(options?.search ? ['--search'] : []),
+            'app-server',
+        ];
+        // Preserve the established `auto` launcher contract without resolving PATH
+        // during synchronous launch preparation. The static shell fragment passes
+        // every dynamic value as an argv element and `exec`s the selected process.
+        if (launcher === 'auto')
+            return {
+                argv: [
+                    'sh', '-c',
+                    'if command -v ours-codex >/dev/null 2>&1; then exec ours-codex "$@"; else exec codex "$@"; fi',
+                    'ours-fleet-codex', ...flags,
+                ],
+                env: prep.env,
+            };
+        const command = launcher === 'ours-codex' ? 'ours-codex' : 'codex';
+        return {
+            argv: [command, ...flags],
+            env: prep.env,
+        };
+    }
     const configured = role.session_options?.acp?.command;
     const resolved = configured == null
         ? codexAcpLaunchForResolution(bundledCodexAcp())
@@ -247,7 +306,7 @@ function hasInstalledOursPlugin(output) {
         return false;
     }
 }
-export function makeCodexAdapter(exec = realExec, transport) {
+export function makeCodexAdapter(exec = realExec, transport, nativeTransport) {
     return {
         id: 'codex',
         agentSession: new CodexAgentSessionAdapter({
@@ -274,10 +333,20 @@ export function makeCodexAdapter(exec = realExec, transport) {
                         ? { adapterState: { permissionMetadataSource } } : {}),
                 };
             },
+            sessionConfigSelections: role => [
+                ...(typeof role.model === 'string'
+                    ? [{ configId: 'model', value: role.model }] : []),
+                ...(typeof role.effort === 'string'
+                    ? [{ configId: 'reasoning_effort', value: role.effort }] : []),
+            ],
             permissionModeId: role => acpAgentMode(role),
             mcpServers: () => undefined,
             sessionMeta: () => undefined,
-        }, transport),
+            approvalPolicy: neutralApprovalPolicy,
+            sandbox: neutralSandboxMode,
+            nativeConfig: nativeCodexConfig,
+            addDirs: role => role.harness_options?.add_dirs,
+        }, transport, nativeTransport),
         supportsResume: true,
         async checkPrereqs() {
             const [r, hasOursCodex, plugins] = await Promise.all([
@@ -313,7 +382,7 @@ export function makeCodexAdapter(exec = realExec, transport) {
                 ],
             };
         },
-        validateOptions(opts) {
+        validateOptions(opts, role) {
             if (opts == null)
                 return [];
             if (typeof opts !== 'object' || Array.isArray(opts))
@@ -322,6 +391,28 @@ export function makeCodexAdapter(exec = realExec, transport) {
                 .filter(k => !OPTION_KEYS.includes(k))
                 .map(k => ({ path: `harness_options.${k}`, message: `unknown option; allowed: ${OPTION_KEYS.join(', ')}` }));
             const o = opts;
+            if (role?.session === 'codex-app-server') {
+                if (o.profile != null)
+                    errs.push({
+                        path: 'harness_options.profile',
+                        message: 'is not accepted for codex-app-server; Codex rejects --profile for app-server',
+                    });
+                if (o.approval != null)
+                    errs.push({
+                        path: 'harness_options.approval',
+                        message: 'is not accepted for codex-app-server; use permissions.approval: ask|auto|allow',
+                    });
+                if (o.permission_mode != null)
+                    errs.push({
+                        path: 'harness_options.permission_mode',
+                        message: 'is not accepted for codex-app-server; use permissions.approval: ask|auto|allow',
+                    });
+                if (o.sandbox != null)
+                    errs.push({
+                        path: 'harness_options.sandbox',
+                        message: 'is not accepted for codex-app-server; use permissions.filesystem: read-only|workspace|unrestricted',
+                    });
+            }
             if (o.launcher != null && !LAUNCHERS.includes(o.launcher))
                 errs.push({ path: 'harness_options.launcher', message: `must be one of: ${LAUNCHERS.join(', ')}` });
             if (o.sandbox != null && !SANDBOX_MODES.includes(o.sandbox))
@@ -345,6 +436,13 @@ export function makeCodexAdapter(exec = realExec, transport) {
                     errs.push({ path: 'harness_options.config', message: 'must be a map of Codex config keys to TOML scalar/array values' });
                 else
                     for (const [key, value] of Object.entries(o.config)) {
+                        if (role?.session === 'codex-app-server' && !isNativeConfigKeyAllowed(key)) {
+                            errs.push({
+                                path: `harness_options.config.${key}`,
+                                message: 'is not accepted for codex-app-server; only model_reasoning_effort is allowed',
+                            });
+                            continue;
+                        }
                         try {
                             encodeTomlValue(value);
                         }
@@ -388,7 +486,9 @@ export function makeCodexAdapter(exec = realExec, transport) {
                 ],
             };
         },
-        nativePermissionOverrides(options) {
+        nativePermissionOverrides(options, role) {
+            if (role?.session === 'codex-app-server')
+                return {};
             const o = options;
             const approval = o?.approval ?? o?.permission_mode; // permission_mode is the alias
             return {
@@ -416,6 +516,8 @@ export function makeCodexAdapter(exec = realExec, transport) {
             const translated = this.translatePermissions(role.permissions);
             if (!translated.supported)
                 return translated;
+            if (role.session === 'codex-app-server')
+                return translated;
             const approval = approvalPolicy(role) ?? 'on-request';
             const sandbox = sandboxMode(role) ?? 'workspace-write';
             if (role.session === 'acp') {
@@ -440,11 +542,7 @@ export function makeCodexAdapter(exec = realExec, transport) {
                     capabilities: codexCapabilities(actual.approval, actual.sandbox),
                 };
             }
-            return {
-                ...translated,
-                native: { approval, sandbox },
-                capabilities: codexCapabilities(approval, sandbox),
-            };
+            return translated;
         },
         effectivePermissionMode(role) {
             if (role.session === 'acp') {
@@ -457,10 +555,12 @@ export function makeCodexAdapter(exec = realExec, transport) {
                     fleetMode: fleetModeForApproval(acpModePermissions(nativeMode).approval), nativeMode,
                 };
             }
-            const nativeMode = approvalPolicy(role) ?? 'untrusted';
+            const nativeMode = neutralApprovalPolicy(role);
             return { fleetMode: fleetModeForApproval(nativeMode), nativeMode };
         },
         inheritedPermissionMode(role) {
+            if (role.session === 'codex-app-server')
+                return fleetModeForApproval(neutralApprovalPolicy(role));
             return fleetModeForApproval(approvalPolicy(role) ?? 'untrusted');
         },
         vocabulary: {

package/dist/harness/types.d.ts

@@ -145,7 +145,7 @@ export interface HarnessAdapter {
      * keyed the same way `translatePermissions().native` is, so the two can be
      * compared directly. Only keys the operator actually wrote appear.
      */
-    nativePermissionOverrides(options: unknown): Record<string, unknown>;
+    nativePermissionOverrides(options: unknown, role?: ResolvedRole): Record<string, unknown>;
     /**
      * Host paths this harness needs inside a sandbox, split into a per-role
      * writable home and shared read-only credentials/config. Omit for a

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 export { loadConfig, findRole, resolvePermissions, ConfigError } from './config.js';
 export type { FleetConfig, ResolvedRole, RoleConfig, OverseeEntry, SessionBackendId, CommonPermissions, FleetPermissionMode, ApprovalMode, SessionOptions, OwnerChannelConfig, } from './config.js';
 export type { HarnessAdapter, BriefingVocab, ExitPolicy, PrereqReport, PrereqCheck, SessionPrep, Launch, AcpLaunch, PermissionTranslation, RoleDirs, ValidationError, } from './harness/types.js';
-export type { AgentSession, SessionHandle, SessionSnapshot, SessionEvent, TurnResult, InterruptOutcome, InterruptResult, TurnCancellationSource, QueuedPrompt, ExitRecord, } from './session/types.js';
-export { interruptOutcome } from './session/types.js';
+export type { AgentSession, SessionHandle, SessionSnapshot, SessionEvent, TurnResult, InterruptOutcome, InterruptResult, TurnCancellationSource, QueuedPrompt, ExitRecord, AgentSessionCapabilities, } from './session/types.js';
+export { interruptOutcome, sessionBackendCapabilities } from './session/types.js';
 export { AcpSession } from './session/acp.js';
+export { CodexAppServerSession } from './session/codex-app-server.js';
 export { OwnerChannel } from './owner-channel/channel.js';
 export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
 export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
@@ -13,10 +14,10 @@ export { effectivePermissionMode } from './permissions.js';
 export { pickBackend } from './supervisor/index.js';
 export type { SupervisorBackend } from './supervisor/types.js';
 export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
-export { spawnPermanent, spawnTemp, buildRoleConfig, profileValues, validateSpawnOpts, } from './spawn.js';
+export { spawnPermanent, spawnTemp, agentDefinitionFromSpawn, validateSpawnOpts, } from './spawn.js';
 export { RoleRepository } from './application/role-repository.js';
 export { FleetQueryService } from './application/fleet-query-service.js';
-export { AcpRoleSessionAdapter } from './application/session-control.js';
+export { RoleSessionControlAdapter, AcpRoleSessionAdapter, } from './application/session-control.js';
 export { RoleCreationService } from './application/role-creation-service.js';
 export { RoleCommandService, RoleLifecycleService } from './application/role-command-service.js';
 export { StructuredLogService } from './application/log-service.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export { loadConfig, findRole, resolvePermissions, ConfigError } from './config.js';
-export { interruptOutcome } from './session/types.js';
+export { interruptOutcome, sessionBackendCapabilities } from './session/types.js';
 export { AcpSession } from './session/acp.js';
+export { CodexAppServerSession } from './session/codex-app-server.js';
 export { OwnerChannel } from './owner-channel/channel.js';
 export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
 export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
@@ -9,10 +10,10 @@ export { generateBriefing } from './briefing.js';
 export { effectivePermissionMode } from './permissions.js';
 export { pickBackend } from './supervisor/index.js';
 export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
-export { spawnPermanent, spawnTemp, buildRoleConfig, profileValues, validateSpawnOpts, } from './spawn.js';
+export { spawnPermanent, spawnTemp, agentDefinitionFromSpawn, validateSpawnOpts, } from './spawn.js';
 export { RoleRepository } from './application/role-repository.js';
 export { FleetQueryService } from './application/fleet-query-service.js';
-export { AcpRoleSessionAdapter } from './application/session-control.js';
+export { RoleSessionControlAdapter, AcpRoleSessionAdapter, } from './application/session-control.js';
 export { RoleCreationService } from './application/role-creation-service.js';
 export { RoleCommandService, RoleLifecycleService } from './application/role-command-service.js';
 export { StructuredLogService } from './application/log-service.js';

package/dist/init-guidance.d.ts

@@ -1 +1 @@
-export declare const INIT_COMPLETION_GUIDANCE = "\nNext:\n  cp \"$(npm root -g)/@ours.network/fleet/examples/fleet.yaml\" ~/fleet.yaml\n  cp -R \"$(npm root -g)/@ours.network/fleet/examples/fleet\" ~/fleet\n  edit ~/fleet.yaml and ~/fleet/{agents,roles,brains}/*.yaml, then: ours-fleet up";
+export declare const INIT_COMPLETION_GUIDANCE = "\nNext:\n  ours-fleet config\n  ours-fleet template list\n  review the generated manifest and fleet/{agents,agent_templates,roles,brains,room_templates}/*.yaml\n  configure rooms.owner, then create a task with --template single, pair, or team";

package/dist/init-guidance.js

@@ -1,5 +1,6 @@
 export const INIT_COMPLETION_GUIDANCE = `
 Next:
-  cp "$(npm root -g)/@ours.network/fleet/examples/fleet.yaml" ~/fleet.yaml
-  cp -R "$(npm root -g)/@ours.network/fleet/examples/fleet" ~/fleet
-  edit ~/fleet.yaml and ~/fleet/{agents,roles,brains}/*.yaml, then: ours-fleet up`;
+  ours-fleet config
+  ours-fleet template list
+  review the generated manifest and fleet/{agents,agent_templates,roles,brains,room_templates}/*.yaml
+  configure rooms.owner, then create a task with --template single, pair, or team`;

package/dist/init-wizard.d.ts

@@ -0,0 +1,98 @@
+import type { Stats } from 'node:fs';
+import type { ReadStream, WriteStream } from 'node:tty';
+export type Subscription = 'codex' | 'claude';
+export type WorkKind = 'development' | 'review' | 'coordination';
+export type ReasoningPreference = 'quick' | 'balanced' | 'thorough';
+export type AssignmentStrategy = 'one-model' | 'per-job';
+export interface CatalogModel {
+    harness: 'codex' | 'claude-code';
+    session: 'acp';
+    model: string;
+    efforts: string[];
+}
+export interface InitAnswers {
+    subscriptions: Subscription[];
+    assignmentStrategy: AssignmentStrategy;
+    models: Record<WorkKind, CatalogModel>;
+    reasoning: ReasoningPreference;
+}
+export interface Choice<T> {
+    label: string;
+    value: T;
+}
+export interface InitPrompter {
+    confirm(message: string, detail: string): Promise<boolean | undefined>;
+    multiSelect<T>(message: string, choices: Choice<T>[]): Promise<T[] | undefined>;
+    select<T>(message: string, choices: Choice<T>[], initial?: number): Promise<T | undefined>;
+    note(message: string): void;
+}
+export interface BrainCatalog {
+    schema_version: number;
+    models: CatalogModel[];
+}
+export interface GeneratedSetup {
+    files: Map<string, string>;
+    answers: InitAnswers;
+}
+export interface InitPublishResult {
+    configPath: string;
+    splitRoot: string;
+    recoveryPath: string;
+    replacedExisting: boolean;
+    manifestExisted: boolean;
+    rootExisted: boolean;
+}
+export declare function validateCatalog(value: BrainCatalog, path?: string): BrainCatalog;
+export declare function askInitQuestions(prompter: InitPrompter, configuration: string): Promise<InitAnswers | undefined>;
+export declare function formatSetupSummary(answers: InitAnswers, configuration: 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. */
+export declare function executeInitWizard(prompter: InitPrompter, configuration: string, deps: {
+    hostSetup(): Promise<void>;
+    publish(configuration: string, setup: GeneratedSetup): Promise<InitPublishResult>;
+    generate?(answers: InitAnswers): GeneratedSetup;
+    preflight?(configuration: string): InitPathState;
+}): Promise<InitPublishResult | undefined>;
+export interface InitPathInspectionDeps {
+    exists?(path: string): boolean;
+    lstat?(path: string): Stats;
+    stat?(path: string): Stats;
+    uid?(): number | undefined;
+    entries?(path: string): string[];
+}
+export interface InitPathState {
+    configPath: string;
+    splitRoot: string;
+    parent: string;
+    manifestExisted: boolean;
+    rootExisted: boolean;
+}
+/** Read-only safety gate. Run once before host setup and again under the init lock. */
+export declare function preflightInitPaths(configuration: string, overrides?: InitPathInspectionDeps): InitPathState;
+/** Replace the complete configuration under one lock, retaining a private recovery copy. */
+export declare function publishSetup(configuration: string, setup: GeneratedSetup, hooks?: {
+    beforeArtifact?(entry: 'stage' | 'recovery'): void;
+    beforePublish?(entry: 'root' | 'manifest'): void;
+}): Promise<InitPublishResult>;
+type Key = 'up' | 'down' | 'space' | 'enter' | 'escape' | 'yes' | 'no' | 'other';
+export declare function decodeKey(chunk: Buffer | string): Key;
+export interface MultiSelectState {
+    cursor: number;
+    selected: boolean[];
+}
+export declare function updateMultiSelect(state: MultiSelectState, key: Key): MultiSelectState;
+export declare class TerminalPrompter implements InitPrompter {
+    private readonly input;
+    private readonly output;
+    private readonly notes;
+    constructor(input: ReadStream, output: WriteStream);
+    note(message: string): void;
+    confirm(message: string, detail: string): Promise<boolean | undefined>;
+    multiSelect<T>(message: string, choices: Choice<T>[]): Promise<T[] | undefined>;
+    select<T>(message: string, choices: Choice<T>[], initial?: number): Promise<T | undefined>;
+    private render;
+    private key;
+}
+export declare const isInteractiveTerminal: (input: NodeJS.ReadStream, output: NodeJS.WriteStream) => boolean;
+export {};