@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/subagent-claude-code/lib/types/index.js

@@ -1,30 +1,35 @@
 /**
- * Fixed Claude Code one-shot subagent provider. Every accepted run invokes
- * the official Agent SDK in the delegating Session's workspace and places
- * the SDK-spawned real CLI under the shared subprocess owner.
+ * Profile-named Claude Code one-shot subagent provider. Every accepted run
+ * invokes the official Agent SDK in the delegating Session's workspace and
+ * places the SDK-spawned real CLI under the shared subprocess owner.
  *
  * @module @nomix-ai/nomix-subagent-claude-code
  */
 import z from '../../../schemastery/lib/index.mjs';
 import { MAX_TIMER_DELAY_MS } from '../../../timeout/lib/index.js';
 import { assertPositiveFinite, NO_START_CAPABILITIES, resolveChildCwd, } from '../../../subagent/lib/index.js';
-import { DEFAULT_DISPOSE_GRACE_MS, startClaudeCodeRun, } from "./run.js";
+import { CLAUDE_CODE_PERMISSION_MODES, DEFAULT_CLAUDE_CODE_PERMISSION_MODE, DEFAULT_DISPOSE_GRACE_MS, claudeCodeStartupFailure, startClaudeCodeRun, } from "./run.js";
 export const name = 'subagent-claude-code';
 export const inject = ['subagents', 'subprocess'];
+const DEFAULT_PROVIDER_NAME = 'claude-code';
 export const Config = z.object({
+    providerName: z.string().min(1).default(DEFAULT_PROVIDER_NAME),
     env: z.dict(z.string()).default({}),
+    permissionMode: z.union([...CLAUDE_CODE_PERMISSION_MODES])
+        .default(DEFAULT_CLAUDE_CODE_PERMISSION_MODE),
     disposeGraceMs: z.number().default(DEFAULT_DISPOSE_GRACE_MS),
 });
 /* jscpd:ignore-end */
 /* jscpd:ignore-start -- Cordis registration and shared-seam plumbing mirror
  * the Codex sibling; each product's lifecycle remains package-private. */
 class ClaudeCodeProvider {
+    name;
     ctx;
     config;
-    name = 'claude-code';
     capabilities = NO_START_CAPABILITIES;
     inheritsParentContext = false;
-    constructor(ctx, config) {
+    constructor(name, ctx, config) {
+        this.name = name;
         this.ctx = ctx;
         this.config = config;
     }
@@ -33,32 +38,48 @@ class ClaudeCodeProvider {
         if (parentCwd === undefined) {
             throw new Error('subagent-claude-code: no working directory for the child — delegate from a parent session that has one');
         }
-        const executable = await this.ctx.subprocess.resolveExecutable('claude', this.config.env, request.signal);
+        let cwd;
+        try {
+            cwd = resolveChildCwd('subagent-claude-code', undefined, parentCwd);
+        }
+        catch (error) {
+            if (request.signal.aborted) {
+                throw new Error('subagent-claude-code: request was aborted before SDK startup');
+            }
+            const failure = claudeCodeStartupFailure(error);
+            this.ctx.logger.warn(`subagent-claude-code "${this.name}": child start failed: %o`, failure);
+            throw failure;
+        }
         const spec = {
-            cwd: resolveChildCwd('subagent-claude-code', undefined, parentCwd),
-            executable,
+            cwd,
+            permissionMode: this.config.permissionMode,
             env: this.config.env,
             disposeGraceMs: this.config.disposeGraceMs,
             spawn: spawnSpec => this.ctx.subprocess.spawn(spawnSpec),
             onError: (error, stopReason) => {
-                this.ctx.logger.warn(`subagent-claude-code: child run failed (${stopReason}): ${error.message}`);
+                this.ctx.logger.warn(`subagent-claude-code "${this.name}": child run failed (${stopReason}): %o`, error);
             },
         };
         return startClaudeCodeRun(request, spec);
     }
 }
 /**
- * Register the fixed `claude-code` provider.
+ * Register one Profile-named Claude Code provider.
  * @param ctx - context carrying shared subagent and subprocess services.
- * @param config - explicit child environment and disposal grace.
+ * @param config - registry name, permission mode, child environment, and disposal grace.
  */
 export function apply(ctx, config) {
-    const resolved = config;
+    const resolved = {
+        providerName: config.providerName ?? DEFAULT_PROVIDER_NAME,
+        env: config.env,
+        permissionMode: config.permissionMode ?? DEFAULT_CLAUDE_CODE_PERMISSION_MODE,
+        disposeGraceMs: config.disposeGraceMs,
+    };
     assertPositiveFinite('subagent-claude-code', 'disposeGraceMs', resolved.disposeGraceMs);
     if (resolved.disposeGraceMs > MAX_TIMER_DELAY_MS) {
         throw new Error(`subagent-claude-code: disposeGraceMs must be no greater than ${MAX_TIMER_DELAY_MS}`);
     }
-    ctx.subagents.registerProvider(new ClaudeCodeProvider(ctx, resolved));
+    ctx.subagents.registerProvider(new ClaudeCodeProvider(resolved.providerName, ctx, resolved));
 }
 /* jscpd:ignore-end */
 //# sourceMappingURL=index.js.map

package/dist/kernel/subagent-claude-code/lib/types/process.d.ts

@@ -5,7 +5,7 @@
  * @module @nomix-ai/nomix-subagent-claude-code/process
  */
 import type { SpawnedProcess, SpawnOptions } from '@anthropic-ai/claude-agent-sdk';
-import { type SubprocessHandle, type SubprocessSpawnSpec } from '../../../subprocess/lib/index.js';
+import { type SubprocessHandle, type SubprocessOutcome, type SubprocessSpawnSpec } from '../../../subprocess/lib/index.js';
 /**
  * Encode the SDK's complete child environment as a subprocess overlay.
  * @param env - SDK-composed child environment after its removals and replacements.
@@ -16,12 +16,9 @@ export declare function sdkEnvironmentOverlay(env: SpawnOptions['env']): NodeJS.
  * Translate one official SDK spawn request to the shared process owner.
  * @param options - command, arguments, workspace, environment, and forwarded signal from the SDK.
  * @param graceMs - process-tree termination grace.
- * @param platform - host platform selecting the Windows batch-shim boundary.
  * @returns the fully explicit shared subprocess request.
- * @remarks The batch-shim path quotes only the resolved executable. The pinned SDK
- * supplies fixed flag arguments without cmd metacharacters; cmd reparses that tail.
  */
-export declare function claudeSpawnSpec(options: SpawnOptions, graceMs: number, platform?: NodeJS.Platform): SubprocessSpawnSpec;
+export declare function claudeSpawnSpec(options: SpawnOptions, graceMs: number): SubprocessSpawnSpec;
 /**
  * SDK-facing view of one shared managed process. Protocol transport remains
  * in the official SDK; this adapter only projects streams and exit events.
@@ -31,8 +28,7 @@ export declare class ManagedClaudeCodeProcess implements SpawnedProcess {
     readonly stdin: import("stream").Writable;
     readonly stdout: import("stream").Readable;
     private readonly events;
-    private exitCodeValue;
-    private signalCodeValue;
+    private outcomeValue;
     private killRequested;
     /**
      * Project a managed process with piped stdin and stdout.
@@ -45,6 +41,8 @@ export declare class ManagedClaudeCodeProcess implements SpawnedProcess {
     get exitCode(): number | null;
     /** Direct-child terminating signal, if any. */
     get signalCode(): NodeJS.Signals | null;
+    /** Exact managed-process outcome after exit, or undefined while running. */
+    get outcome(): SubprocessOutcome | undefined;
     /**
      * Route the SDK's termination request to the tree-scoped process owner.
      * @param _signal - SDK-selected signal; the shared seam owns its escalation ladder.

package/dist/kernel/subagent-claude-code/lib/types/process.js

@@ -5,9 +5,7 @@
  * @module @nomix-ai/nomix-subagent-claude-code/process
  */
 import { EventEmitter } from 'node:events';
-import { extname } from 'node:path';
 import { scrubbedParentEnv, } from '../../../subprocess/lib/index.js';
-const WINDOWS_BATCH_EXECUTABLE_ENV = 'NOMIX_CLAUDE_CODE_EXECUTABLE';
 function thrown(value) {
     /* v8 ignore next -- the subprocess seam rejects with Error. */
     return value instanceof Error ? value : new Error(String(value));
@@ -29,30 +27,19 @@ export function sdkEnvironmentOverlay(env) {
  * Translate one official SDK spawn request to the shared process owner.
  * @param options - command, arguments, workspace, environment, and forwarded signal from the SDK.
  * @param graceMs - process-tree termination grace.
- * @param platform - host platform selecting the Windows batch-shim boundary.
  * @returns the fully explicit shared subprocess request.
- * @remarks The batch-shim path quotes only the resolved executable. The pinned SDK
- * supplies fixed flag arguments without cmd metacharacters; cmd reparses that tail.
  */
-export function claudeSpawnSpec(options, graceMs, platform = process.platform) {
+export function claudeSpawnSpec(options, graceMs) {
     if (options.cwd === undefined || options.cwd.length === 0) {
         throw new Error('subagent-claude-code: SDK spawn request omitted its workspace');
     }
-    const extension = extname(options.command).toLowerCase();
-    const batchShim = platform === 'win32' && (extension === '.cmd' || extension === '.bat');
-    const env = sdkEnvironmentOverlay(options.env);
-    const argv = batchShim
-        ? ['cmd.exe', '/d', '/v:off', '/s', '/c', `%${WINDOWS_BATCH_EXECUTABLE_ENV}%`, ...options.args]
-        : [options.command, ...options.args];
-    if (batchShim)
-        env[WINDOWS_BATCH_EXECUTABLE_ENV] = `"${options.command}"`;
     return {
-        argv,
+        argv: [options.command, ...options.args],
         cwd: options.cwd,
         stdio: { stdin: 'pipe', stdout: 'pipe', stderr: 'inherit' },
         graceMs,
         signal: options.signal,
-        env,
+        env: sdkEnvironmentOverlay(options.env),
     };
 }
 /**
@@ -64,8 +51,7 @@ export class ManagedClaudeCodeProcess {
     stdin;
     stdout;
     events = new EventEmitter();
-    exitCodeValue = null;
-    signalCodeValue = null;
+    outcomeValue;
     killRequested = false;
     /**
      * Project a managed process with piped stdin and stdout.
@@ -80,8 +66,7 @@ export class ManagedClaudeCodeProcess {
         // while this no-op also contains an already-rejected spawn handle.
         this.events.on('error', () => { });
         void child.done.then((outcome) => {
-            this.exitCodeValue = outcome.exitCode;
-            this.signalCodeValue = outcome.signal;
+            this.outcomeValue = outcome;
             this.events.emit('exit', outcome.exitCode, outcome.signal);
         }, (error) => {
             this.events.emit('error', thrown(error));
@@ -93,11 +78,15 @@ export class ManagedClaudeCodeProcess {
     }
     /** Direct-child exit code, or null while running or after signal exit. */
     get exitCode() {
-        return this.exitCodeValue;
+        return this.outcomeValue?.exitCode ?? null;
     }
     /** Direct-child terminating signal, if any. */
     get signalCode() {
-        return this.signalCodeValue;
+        return this.outcomeValue?.signal ?? null;
+    }
+    /** Exact managed-process outcome after exit, or undefined while running. */
+    get outcome() {
+        return this.outcomeValue;
     }
     /**
      * Route the SDK's termination request to the tree-scoped process owner.
@@ -106,8 +95,7 @@ export class ManagedClaudeCodeProcess {
      */
     kill(_signal) {
         if (this.killRequested
-            || this.exitCodeValue !== null
-            || this.signalCodeValue !== null) {
+            || this.outcomeValue !== undefined) {
             return false;
         }
         this.killRequested = true;

package/dist/kernel/subagent-claude-code/lib/types/run.d.ts

@@ -9,21 +9,34 @@ import { type Options, type Query, type SDKMessage, type SDKResultMessage } from
 import type { ContentBlock } from '../../../llm/lib/index.js';
 import { type SubagentResult, type SubagentRun, type SubagentStartRequest, type SubagentStopReason } from '../../../subagent/lib/index.js';
 import { type SubprocessHandle, type SubprocessSpawnSpec } from '../../../subprocess/lib/index.js';
+import { ManagedClaudeCodeProcess } from './process.ts';
 /** Default POSIX grace between subprocess termination tiers. */
 export declare const DEFAULT_DISPOSE_GRACE_MS = 3000;
+/** Claude Code permission modes that cannot wait for a human response. */
+export declare const CLAUDE_CODE_PERMISSION_MODES: readonly ["dontAsk", "acceptEdits", "auto", "plan", "bypassPermissions"];
+/** Profile-selectable non-interactive Claude Code permission mode. */
+export type ClaudeCodePermissionMode = typeof CLAUDE_CODE_PERMISSION_MODES[number];
+/** Safe default for unattended Claude Code runs. */
+export declare const DEFAULT_CLAUDE_CODE_PERMISSION_MODE: ClaudeCodePermissionMode;
+/**
+ * Hide an unpublished product startup failure behind fixed safe facts.
+ * @param cause - original host-side failure retained only on the Error cause chain.
+ * @returns a rejection safe to expose through the subagent start boundary.
+ */
+export declare function claudeCodeStartupFailure(cause: unknown): Error;
 /** Fully resolved inputs for one official Claude Agent SDK query. */
 export interface ClaudeCodeRunSpec {
     /** Parent Session workspace supplied to the SDK and real CLI. */
     readonly cwd: string;
-    /** Exact native Claude Code executable resolved from the host PATH. */
-    readonly executable: string;
+    /** Profile-selected native non-interactive permission mode. */
+    readonly permissionMode: ClaudeCodePermissionMode;
     /** Explicit deployment/test environment layered after shared scrubbing. */
     readonly env: Record<string, string>;
     /** Subprocess termination grace passed to the shared process-tree owner. */
     readonly disposeGraceMs: number;
     /** Shared subprocess service spawn operation. */
     readonly spawn: (spec: SubprocessSpawnSpec) => SubprocessHandle;
-    /** Diagnostic sink for a post-publication error flattened into a result. */
+    /** Host diagnostic sink for a product failure kept outside model-visible text. */
     readonly onError?: (error: Error, stopReason: SubagentStopReason) => void;
 }
 /**
@@ -42,24 +55,28 @@ export declare function successfulResult(message: SDKResultMessage): string;
  * Consume the complete SDK stream and require one strict success plus normal
  * iterator completion.
  * @param query - published official SDK query.
+ * @param onPermissionDenied - records a safe fact when the SDK reports native denial.
+ * @param onResult - records that the SDK supplied a terminal result message.
  * @returns the completed shared result.
  */
-export declare function consumeClaudeQuery(query: AsyncIterable<SDKMessage>): Promise<SubagentResult>;
+export declare function consumeClaudeQuery(query: AsyncIterable<SDKMessage>, onPermissionDenied?: () => void, onResult?: () => void): Promise<SubagentResult>;
 /**
  * Close the official query, terminate the managed process tree, and wait for
  * the subprocess owner to prove it is gone.
  * @param query - official SDK query, when creation reached that point.
- * @param child - shared-service handle that owns the CLI process tree.
+ * @param child - live shared-service handle that owns the CLI process tree;
+ * spawn-failed handles settle at the startup boundary instead.
  */
 export declare function disposeClaudeCodeChild(query: Pick<Query, 'close'> | undefined, child: SubprocessHandle): Promise<void>;
 /**
  * Build the fixed official SDK options for one one-shot provider run.
  * @param spec - Workspace, environment, process service, and disposal policy.
  * @param controller - per-run cancellation owner.
- * @param capture - receives the real managed child synchronously from the SDK hook.
+ * @param capture - receives the shared child and SDK-facing process synchronously.
+ * @param captureDiagnostic - receives safe facts from unattended interaction callbacks.
  * @returns options that inherit native settings while disabling persistence and user questions.
  */
-export declare function claudeQueryOptions(spec: ClaudeCodeRunSpec, controller: AbortController, capture: (child: SubprocessHandle) => void): Options;
+export declare function claudeQueryOptions(spec: ClaudeCodeRunSpec, controller: AbortController, capture: (child: SubprocessHandle, process: ManagedClaudeCodeProcess) => void, captureDiagnostic: (diagnostic: string) => void): Options;
 /**
  * Start one official Claude Agent SDK query and publish its one-shot run.
  * @param request - resolved shared subagent request.