@ornexus/neocortex 4.60.73 → 4.60.75

package/packages/client/dist/runner/epic-background-dispatcher.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Contract-first admission for root-owned native background execution.
+ *
+ * This module deliberately does not spawn, persist tracked state, select graph
+ * work, or perform Git effects. It only converts an exact server-owned task
+ * directive into closed per-story entries for the host root.
+ */
+import { type NativeBackgroundDispatchContractV1, type NativeDispatchBindingV1, type NativeHostAttestationV1 } from '../continuity/native-agent-types.js';
+export declare const NATIVE_BACKGROUND_REASON_CODES: Readonly<{
+    readonly CONTRACT_INVALID: "directive-background-contract-invalid";
+    readonly BINDING_MISSING: "directive-background-binding-missing";
+    readonly WAVE_MISMATCH: "directive-background-wave-mismatch";
+    readonly GRAPH_STALE: "directive-background-graph-stale";
+    readonly CAPABILITY_UNVALIDATED: "native-background-capability-unvalidated";
+    readonly DEPTH_DENIED: "native-background-depth-denied";
+    readonly SETTLEMENT_INVALID: "native-background-settlement-invalid";
+}>;
+export type NativeBackgroundReasonCode = (typeof NATIVE_BACKGROUND_REASON_CODES)[keyof typeof NATIVE_BACKGROUND_REASON_CODES];
+export interface NativeBackgroundTaskDirectiveV1 {
+    readonly kind: 'task';
+    readonly subagentType: 'neocortex';
+    readonly promptTemplate: string;
+    readonly storyIds: readonly string[];
+    readonly promptTemplates: readonly string[];
+    readonly dispatchBinding: NativeDispatchBindingV1;
+    readonly dispatchBindings: readonly NativeDispatchBindingV1[];
+    readonly backgroundDispatch: NativeBackgroundDispatchContractV1;
+    readonly rationale?: string;
+}
+export interface NativeBackgroundAdmissionInput {
+    readonly directive: unknown;
+    readonly supportsTaskDelegation: boolean;
+    readonly taskDelegationCapability: 'native_safe' | 'unsupported' | 'unvalidated' | 'disabled_by_override';
+    readonly hostAttestation: unknown;
+    readonly currentGraphRevision: string;
+}
+export interface AuthorizedNativeBackgroundEntryV1 {
+    readonly storyId: string;
+    readonly prompt: string;
+    readonly binding: NativeDispatchBindingV1;
+}
+export type EpicBackgroundDispatchDecisionV1 = Readonly<{
+    kind: 'launch';
+    entries: readonly AuthorizedNativeBackgroundEntryV1[];
+    hostAttestation: NativeHostAttestationV1;
+}> | Readonly<{
+    kind: 'reconcile-existing';
+    dispatchKeys: readonly string[];
+    reasonCode: 'native-background-reconcile-existing';
+}> | Readonly<{
+    kind: 'inline';
+    reasonCode: NativeBackgroundReasonCode;
+}> | Readonly<{
+    kind: 'denied';
+    reasonCode: NativeBackgroundReasonCode;
+}>;
+/**
+ * Admit only the exact P224-CON-DISPATCH chain. Missing native authority is an
+ * explicit inline fallback; malformed or stale authority is denied.
+ */
+export declare function planEpicBackgroundDispatch(input: NativeBackgroundAdmissionInput): EpicBackgroundDispatchDecisionV1;

package/packages/client/dist/runner/epic-background-dispatcher.js

@@ -0,0 +1 @@
+import{isNativeBackgroundDispatchContractV1 as b,isNativeDispatchBindingV1 as h,isNativeHostAttestationV1 as I}from"../continuity/native-agent-types.js";const i=Object.freeze({CONTRACT_INVALID:"directive-background-contract-invalid",BINDING_MISSING:"directive-background-binding-missing",WAVE_MISMATCH:"directive-background-wave-mismatch",GRAPH_STALE:"directive-background-graph-stale",CAPABILITY_UNVALIDATED:"native-background-capability-unvalidated",DEPTH_DENIED:"native-background-depth-denied",SETTLEMENT_INVALID:"native-background-settlement-invalid"}),v=/^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)+$/,f=/^\*yolo @docs\/stories\/([A-Za-z0-9._-]+)\.story\.md(?: branchless-preparation)?$/,y=/^(?:sha256:)?[a-f0-9]{64}$/i;function D(e){return!!e&&typeof e=="object"&&!Array.isArray(e)}function C(e,t){return e.schemaVersion===t.schemaVersion&&e.storyId===t.storyId&&e.graphRevision.toLowerCase()===t.graphRevision.toLowerCase()&&e.dispatchKey.toLowerCase()===t.dispatchKey.toLowerCase()&&e.requiredCapability===t.requiredCapability&&e.maxDepth===t.maxDepth&&e.publicSafe===t.publicSafe}function p(e){return e.toLowerCase().replace(/^sha256:/,"")}function T(e,t,n){return Object.freeze({storyId:e,prompt:t,binding:Object.freeze({...n})})}function _(e){if(!e.supportsTaskDelegation||e.taskDelegationCapability!=="native_safe"||!I(e.hostAttestation))return Object.freeze({kind:"inline",reasonCode:i.CAPABILITY_UNVALIDATED});if(!D(e.directive)||e.directive.kind!=="task"||e.directive.subagentType!=="neocortex"||!b(e.directive.backgroundDispatch))return Object.freeze({kind:"denied",reasonCode:i.CONTRACT_INVALID});if(!h(e.directive.dispatchBinding)||!Array.isArray(e.directive.dispatchBindings)||e.directive.dispatchBindings.length===0||!e.directive.dispatchBindings.every(h))return Object.freeze({kind:"denied",reasonCode:i.BINDING_MISSING});if(!y.test(e.currentGraphRevision))return Object.freeze({kind:"denied",reasonCode:i.GRAPH_STALE});const t=e.directive.storyIds,n=e.directive.promptTemplates,a=e.directive.dispatchBindings;if(!Array.isArray(t)||!Array.isArray(n)||t.length===0||t.length!==n.length||t.length!==a.length||new Set(t).size!==t.length||new Set(a.map(r=>r.dispatchKey)).size!==a.length||!C(e.directive.dispatchBinding,a[0]))return Object.freeze({kind:"denied",reasonCode:i.WAVE_MISMATCH});const g=p(e.currentGraphRevision),c=[];for(let r=0;r<t.length;r+=1){const s=t[r],d=n[r],o=a[r],A=typeof d=="string"?d.match(f):null;if(typeof s!="string"||!v.test(s)||!A||A[1]!==s||o.storyId!==s)return Object.freeze({kind:"denied",reasonCode:i.WAVE_MISMATCH});if(p(o.graphRevision)!==g)return Object.freeze({kind:"denied",reasonCode:i.GRAPH_STALE});if(o.maxDepth!==1||e.directive.backgroundDispatch.maxDepth!==1)return Object.freeze({kind:"denied",reasonCode:i.DEPTH_DENIED});c.push(T(s,d,o))}return Object.freeze({kind:"launch",entries:Object.freeze(c),hostAttestation:Object.freeze({...e.hostAttestation})})}export{i as NATIVE_BACKGROUND_REASON_CODES,_ as planEpicBackgroundDispatch};

package/packages/client/dist/runner/headless/adapters.js

@@ -1,49 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * P190.04 -- allowlisted headless adapter registry.
- */
-import { HEADLESS_ADAPTER_IDS, HEADLESS_REASON_CODES, isHeadlessAdapterId, redaction, } from './types.js';
-import { createClaudeCodeHeadlessAdapter } from './claude-code-adapter.js';
-import { createFakeHeadlessAdapter } from './fake-adapter.js';
-import { createOpenCodeHeadlessAdapter } from './opencode-adapter.js';
-export class HeadlessAdapterRegistry {
-    adapters;
-    constructor(adapters) {
-        const map = new Map();
-        for (const adapter of adapters) {
-            if (!isHeadlessAdapterId(adapter.id))
-                continue;
-            map.set(adapter.id, adapter);
-        }
-        this.adapters = map;
-    }
-    listAdapterIds() {
-        return HEADLESS_ADAPTER_IDS.filter((id) => this.adapters.has(id));
-    }
-    hasAdapter(id) {
-        return isHeadlessAdapterId(id) && this.adapters.has(id);
-    }
-    getAdapter(id) {
-        if (!isHeadlessAdapterId(id) || !this.adapters.has(id)) {
-            return {
-                ok: false,
-                reasonCode: HEADLESS_REASON_CODES.RUNTIME_UNTRUSTED,
-                reasonCodes: [HEADLESS_REASON_CODES.RUNTIME_UNTRUSTED],
-                publicSummary: 'Headless adapter id is not allowlisted.',
-                redactionSummary: [redaction('runtimeId', 'unsafe_key', 'value-denied')],
-                publicSafe: true,
-            };
-        }
-        return { ok: true, adapter: this.adapters.get(id), publicSafe: true };
-    }
-}
-export function createDefaultHeadlessAdapterRegistry() {
-    return new HeadlessAdapterRegistry([
-        createFakeHeadlessAdapter('fake'),
-        createFakeHeadlessAdapter('test'),
-        createOpenCodeHeadlessAdapter(),
-        createClaudeCodeHeadlessAdapter(),
-    ]);
-}
+import{HEADLESS_ADAPTER_IDS as o,HEADLESS_REASON_CODES as s,isHeadlessAdapterId as a,redaction as p}from"./types.js";import{createClaudeCodeHeadlessAdapter as i}from"./claude-code-adapter.js";import{createFakeHeadlessAdapter as d}from"./fake-adapter.js";import{createOpenCodeHeadlessAdapter as n}from"./opencode-adapter.js";class u{adapters;constructor(e){const r=new Map;for(const t of e)a(t.id)&&r.set(t.id,t);this.adapters=r}listAdapterIds(){return o.filter(e=>this.adapters.has(e))}hasAdapter(e){return a(e)&&this.adapters.has(e)}getAdapter(e){return!a(e)||!this.adapters.has(e)?{ok:!1,reasonCode:s.RUNTIME_UNTRUSTED,reasonCodes:[s.RUNTIME_UNTRUSTED],publicSummary:"Headless adapter id is not allowlisted.",redactionSummary:[p("runtimeId","unsafe_key","value-denied")],publicSafe:!0}:{ok:!0,adapter:this.adapters.get(e),publicSafe:!0}}}function S(){return new u([d("fake"),d("test"),n(),i()])}export{u as HeadlessAdapterRegistry,S as createDefaultHeadlessAdapterRegistry};

package/packages/client/dist/runner/headless/background-root.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Root-owned execution of an already admitted native background frontier.
+ * Host-specific APIs are injected; raw handles never leave the launch/observe
+ * bridge and are absent from this module's public result.
+ */
+import { type NativeAgentDispatchReceiptV1, type NativeHostAttestationV1 } from '../../continuity/native-agent-types.js';
+import { type AuthorizedNativeBackgroundEntryV1 } from '../epic-background-dispatcher.js';
+export declare const NATIVE_BACKGROUND_MAX_POLLS = 30;
+export interface NativeBackgroundReservationV1 {
+    readonly action: 'spawn-once' | 'reconcile-existing';
+    readonly receipt: NativeAgentDispatchReceiptV1;
+}
+interface PrivateNativeHostLaunchV1 {
+    readonly rawHandle: string;
+    readonly rawParentHandle?: string | null;
+}
+export interface NativeBackgroundRootPorts {
+    /**
+     * Root-owned continuation/session/auth preflight. Implementations may use the
+     * supported P224.02/P224.03 interfaces, but must return only a public reason.
+     */
+    readonly preflight: (entries: readonly AuthorizedNativeBackgroundEntryV1[], hostAttestation: NativeHostAttestationV1) => Promise<Readonly<{
+        ok: true;
+    } | {
+        ok: false;
+        reasonCode: string;
+    }>>;
+    readonly reserve: (entry: AuthorizedNativeBackgroundEntryV1, hostAttestation: NativeHostAttestationV1) => Promise<NativeBackgroundReservationV1>;
+    readonly launch: (entry: AuthorizedNativeBackgroundEntryV1) => Promise<PrivateNativeHostLaunchV1>;
+    readonly recordSpawned: (entry: AuthorizedNativeBackgroundEntryV1, reservation: NativeBackgroundReservationV1, launch: PrivateNativeHostLaunchV1) => Promise<NativeAgentDispatchReceiptV1>;
+    readonly reconcileExisting: (entry: AuthorizedNativeBackgroundEntryV1, reservation: NativeBackgroundReservationV1) => Promise<NativeAgentDispatchReceiptV1>;
+    readonly awaitSettlement: (entry: AuthorizedNativeBackgroundEntryV1, receipt: NativeAgentDispatchReceiptV1, options: Readonly<{
+        maxPolls: 30;
+        signal?: AbortSignal;
+    }>) => Promise<NativeAgentDispatchReceiptV1>;
+}
+export interface NativeBackgroundRootResultV1 {
+    readonly kind: 'settled';
+    readonly settlement: NativeAgentDispatchReceiptV1;
+    readonly started: readonly NativeAgentDispatchReceiptV1[];
+    readonly publicSafe: true;
+}
+export declare class NativeBackgroundRootError extends Error {
+    readonly reasonCode: string;
+    constructor(reasonCode: string);
+}
+/**
+ * Reserve the whole frontier, launch only `spawn-once` entries, reconcile
+ * existing dispatches, then begin settlement. No settlement is awaited before
+ * every entry has produced a launch/reconciliation receipt.
+ */
+export declare function runNativeBackgroundRoot(entries: readonly AuthorizedNativeBackgroundEntryV1[], hostAttestation: NativeHostAttestationV1, ports: NativeBackgroundRootPorts, options?: Readonly<{
+    signal?: AbortSignal;
+}>): Promise<NativeBackgroundRootResultV1>;
+export interface BoundedNativeBackgroundPollResultV1 {
+    readonly receipt: NativeAgentDispatchReceiptV1 | null;
+    readonly polls: number;
+    readonly exhausted: boolean;
+}
+/** Sequential by construction: at most one poll is in flight for one dispatch. */
+export declare function boundedNativeBackgroundPoll(poll: (attempt: number) => Promise<NativeAgentDispatchReceiptV1 | null>, options?: Readonly<{
+    maxPolls?: number;
+    signal?: AbortSignal;
+}>): Promise<BoundedNativeBackgroundPollResultV1>;
+export {};

package/packages/client/dist/runner/headless/background-root.js

@@ -0,0 +1 @@
+import{isNativeAgentDispatchReceiptV1 as m,NATIVE_AGENT_TERMINAL_STATES as g}from"../../continuity/native-agent-types.js";import{NATIVE_BACKGROUND_REASON_CODES as d}from"../epic-background-dispatcher.js";const w=30;class c extends Error{reasonCode;constructor(a){super(a),this.reasonCode=a,this.name="NativeBackgroundRootError"}}function u(e,a){if(!m(e)||e.storyId!==a.storyId||e.dispatchKey!==a.binding.dispatchKey||e.graphRevision.replace(/^sha256:/,"").toLowerCase()!==a.binding.graphRevision.replace(/^sha256:/,"").toLowerCase()||e.topology!=="native-agent")throw new c(d.SETTLEMENT_INVALID);return e}async function T(e,a,r,o={}){if(e.length===0)throw new c(d.WAVE_MISMATCH);const n=await r.preflight(e,a);if(!n.ok)throw new c(n.reasonCode);const i=await Promise.all(e.map(t=>r.reserve(t,a))),E=await Promise.all(e.map(async(t,l)=>{const s=i[l];if(u(s.receipt,t),s.action==="reconcile-existing")return u(await r.reconcileExisting(t,s),t);const h=await r.launch(t);return u(await r.recordSpawned(t,s,h),t)}));let f;try{f=await Promise.any(E.map((t,l)=>r.awaitSettlement(e[l],t,{maxPolls:w,...o.signal?{signal:o.signal}:{}}).then(s=>{const h=u(s,e[l]);if(!g.has(h.state))throw new c(d.SETTLEMENT_INVALID);return h})))}catch{throw new c(d.SETTLEMENT_INVALID)}return Object.freeze({kind:"settled",settlement:f,started:Object.freeze([...E]),publicSafe:!0})}async function A(e,a={}){const r=Math.max(1,Math.min(w,a.maxPolls??w));let o=null,n=0;for(let i=1;i<=r&&!a.signal?.aborted;i+=1)if(o=await e(i),n=i,o&&g.has(o.state))return Object.freeze({receipt:o,polls:n,exhausted:!1});return Object.freeze({receipt:o,polls:n,exhausted:n>=r})}export{w as NATIVE_BACKGROUND_MAX_POLLS,c as NativeBackgroundRootError,A as boundedNativeBackgroundPoll,T as runNativeBackgroundRoot};

package/packages/client/dist/runner/headless/claude-code-adapter.js

@@ -1,79 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * P190.04 -- trusted Claude Code headless adapter interface.
- */
-import { createRejectedExecutionResult, createUnavailableExecutionResult, normalizeHeadlessCommandResult, runHeadlessCommand, validateHeadlessAdapterExecutionInput, } from './types.js';
-import { checkRuntimeAvailability } from './opencode-adapter.js';
-import { governedPreflightFailureResult, preflightManagedHeadlessProfile, withGovernedHeadlessEvidence, } from './managed-profile.js';
-const CLAUDE_CODE_ADAPTER_ID = 'claude-code';
-const CLAUDE_CODE_COMMAND = 'claude';
-const CLAUDE_CODE_AGENT_PROFILE = 'neocortex';
-export function createClaudeCodeHeadlessAdapter() {
-    return {
-        id: CLAUDE_CODE_ADAPTER_ID,
-        displayName: 'Claude Code Headless Adapter',
-        async checkAvailability(options = {}) {
-            return checkRuntimeAvailability(CLAUDE_CODE_ADAPTER_ID, CLAUDE_CODE_COMMAND, options, {
-                realpathBasenamePolicy: 'claude-code-versioned',
-                versionEvidence: 'claude-code',
-            });
-        },
-        buildInvocation(input) {
-            const validation = validateHeadlessAdapterExecutionInput(input, CLAUDE_CODE_ADAPTER_ID);
-            if (!validation.ok)
-                return validation;
-            return {
-                ok: true,
-                invocation: {
-                    adapterId: CLAUDE_CODE_ADAPTER_ID,
-                    commandName: CLAUDE_CODE_COMMAND,
-                    args: buildClaudeCodeArgs(validation.prompt, validation.input.modelId),
-                    promptHash: validation.promptHash,
-                    ...(validation.input.modelId ? { modelId: validation.input.modelId } : {}),
-                    timeoutMs: validation.input.timeoutMs ?? 10 * 60 * 1000,
-                    publicSafe: true,
-                },
-                publicSafe: true,
-            };
-        },
-        async execute(input, options = {}) {
-            const validation = validateHeadlessAdapterExecutionInput(input, CLAUDE_CODE_ADAPTER_ID);
-            if (!validation.ok)
-                return createRejectedExecutionResult(CLAUDE_CODE_ADAPTER_ID, CLAUDE_CODE_ADAPTER_ID, validation);
-            const preflight = preflightManagedHeadlessProfile(CLAUDE_CODE_ADAPTER_ID, options);
-            if (!preflight.ok)
-                return governedPreflightFailureResult(CLAUDE_CODE_ADAPTER_ID, validation.input, preflight);
-            if (options.signal?.aborted) {
-                return withGovernedHeadlessEvidence(normalizeHeadlessCommandResult(CLAUDE_CODE_ADAPTER_ID, validation.input, {
-                    exitCode: null, signal: 'SIGTERM', timedOut: false, cancelled: true, durationMs: 0,
-                    stdout: '', stderr: '', stdoutBytes: 0, stderrBytes: 0,
-                }));
-            }
-            const availability = await this.checkAvailability(options);
-            if (!availability.ok)
-                return withGovernedHeadlessEvidence(createUnavailableExecutionResult(CLAUDE_CODE_ADAPTER_ID, validation.input, availability));
-            const invocation = this.buildInvocation(validation.input);
-            if (!invocation.ok)
-                return createRejectedExecutionResult(CLAUDE_CODE_ADAPTER_ID, CLAUDE_CODE_ADAPTER_ID, invocation);
-            const runner = options.commandRunner ?? runHeadlessCommand;
-            const result = await runner(availability.executablePath ?? CLAUDE_CODE_COMMAND, invocation.invocation.args, {
-                cwd: options.cwd,
-                env: options.env,
-                timeoutMs: invocation.invocation.timeoutMs,
-                maxOutputBytes: options.maxOutputBytes,
-                signal: options.signal,
-                ...(validation.input.receipt?.jobId ? { localConsole: { projectRoot: options.cwd, jobId: validation.input.receipt.jobId, attemptId: validation.input.receipt.attemptId, executionId: validation.input.receipt.executionId, publicSafe: true } } : {}),
-            });
-            return withGovernedHeadlessEvidence(normalizeHeadlessCommandResult(CLAUDE_CODE_ADAPTER_ID, validation.input, result));
-        },
-    };
-}
-function buildClaudeCodeArgs(prompt, modelId) {
-    const args = ['--agent', CLAUDE_CODE_AGENT_PROFILE];
-    if (modelId)
-        args.push('--model', modelId);
-    args.push('-p', prompt);
-    return args;
-}
+import{createRejectedExecutionResult as c,createUnavailableExecutionResult as m,normalizeHeadlessCommandResult as l,runHeadlessCommand as v,validateHeadlessAdapterExecutionInput as s}from"./types.js";import{checkRuntimeAvailability as f}from"./opencode-adapter.js";import{governedPreflightFailureResult as C,preflightManagedHeadlessProfile as I,withGovernedHeadlessEvidence as u}from"./managed-profile.js";const a="claude-code",o="claude",b="neocortex";function y(){return{id:a,displayName:"Claude Code Headless Adapter",async checkAvailability(i={}){return f(a,o,i,{realpathBasenamePolicy:"claude-code-versioned",versionEvidence:"claude-code"})},buildInvocation(i){const e=s(i,a);return e.ok?{ok:!0,invocation:{adapterId:a,commandName:o,args:h(e.prompt,e.input.modelId),promptHash:e.promptHash,...e.input.modelId?{modelId:e.input.modelId}:{},timeoutMs:e.input.timeoutMs??600*1e3,publicSafe:!0},publicSafe:!0}:e},async execute(i,e={}){const t=s(i,a);if(!t.ok)return c(a,a,t);const d=I(a,e);if(!d.ok)return C(a,t.input,d);if(e.signal?.aborted)return u(l(a,t.input,{exitCode:null,signal:"SIGTERM",timedOut:!1,cancelled:!0,durationMs:0,stdout:"",stderr:"",stdoutBytes:0,stderrBytes:0}));const r=await this.checkAvailability(e);if(!r.ok)return u(m(a,t.input,r));const n=this.buildInvocation(t.input);if(!n.ok)return c(a,a,n);const p=await(e.commandRunner??v)(r.executablePath??o,n.invocation.args,{cwd:e.cwd,env:e.env,timeoutMs:n.invocation.timeoutMs,maxOutputBytes:e.maxOutputBytes,signal:e.signal,...t.input.receipt?.jobId?{localConsole:{projectRoot:e.cwd,jobId:t.input.receipt.jobId,attemptId:t.input.receipt.attemptId,executionId:t.input.receipt.executionId,publicSafe:!0}}:{}});return u(l(a,t.input,p))}}}function h(i,e){const t=["--agent",b];return e&&t.push("--model",e),t.push("-p",i),t}export{y as createClaudeCodeHeadlessAdapter};