@zq-silk/yui 2.3.0 → 2.4.0

package/dist/repository/project.js

@@ -63,13 +63,17 @@ export function assertProjectActive(project, action) {
         throw new Error(`Project is retired and cannot ${action}: ${project.id}.`);
     }
 }
-export function addProjectKnowledge(project, id, title, body, now, provenance) {
+export function addProjectKnowledge(project, id, title, body, now, provenance, applicability = {}) {
     const timestamp = now.toISOString();
     const knowledge = {
-        schemaVersion: 1,
+        schemaVersion: 2,
+        version: 1,
+        history: [],
         id: requireIdentity(id, "Project knowledge id"),
         title: requireText(title, "Project knowledge title"),
         body: requireText(body, "Project knowledge body"),
+        ...(applicability.scope === undefined ? {} : { scope: requireText(applicability.scope, "Knowledge scope") }),
+        ...(applicability.expiresWhen === undefined ? {} : { expiresWhen: requireText(applicability.expiresWhen, "Knowledge expiry condition") }),
         status: "active",
         ...(provenance === undefined ? {} : { provenance: validateKnowledgeProvenance(provenance) }),
         createdAt: timestamp,
@@ -114,19 +118,34 @@ export function updateProjectKnowledge(project, id, patch, now) {
         if (entry.status === "retired") {
             throw new Error(`Project knowledge is retired: ${knowledgeId}.`);
         }
-        return {
-            ...entry,
+        const { scope: _scope, expiresWhen: _expiresWhen, ...base } = entry;
+        const scope = patch.scope === undefined ? entry.scope
+            : patch.scope === null ? undefined : requireText(patch.scope, "Knowledge scope");
+        const expiresWhen = patch.expiresWhen === undefined ? entry.expiresWhen
+            : patch.expiresWhen === null ? undefined : requireText(patch.expiresWhen, "Knowledge expiry condition");
+        const next = {
+            ...base,
+            ...(scope === undefined ? {} : { scope }),
+            ...(expiresWhen === undefined ? {} : { expiresWhen }),
             title: patch.title === undefined
                 ? entry.title
                 : requireText(patch.title, "Project knowledge title"),
             body: patch.body === undefined
                 ? entry.body
                 : requireText(patch.body, "Project knowledge body"),
+            ...(patch.provenance === undefined ? {} : { provenance: validateKnowledgeProvenance(patch.provenance) }),
             updatedAt: now.toISOString()
         };
+        if (next.title === entry.title && next.body === entry.body
+            && next.scope === entry.scope && next.expiresWhen === entry.expiresWhen
+            && JSON.stringify(next.provenance) === JSON.stringify(entry.provenance))
+            return entry;
+        return { ...next, version: entry.version + 1, history: [...entry.history, knowledgeRevision(entry)] };
     });
     if (!found)
         throw new Error(`Project knowledge not found: ${knowledgeId}.`);
+    if (knowledge.every((entry, index) => entry === project.knowledge[index]))
+        return project;
     return validateProject({ ...project, knowledge, updatedAt: now.toISOString() });
 }
 export function retireProjectKnowledge(project, id, now) {
@@ -136,31 +155,42 @@ export function retireProjectKnowledge(project, id, now) {
         if (entry.id !== knowledgeId)
             return entry;
         found = true;
+        if (entry.status === "retired")
+            return entry;
         return {
             ...entry,
+            version: entry.version + 1,
+            history: [...entry.history, knowledgeRevision(entry)],
             status: "retired",
             updatedAt: now.toISOString()
         };
     });
     if (!found)
         throw new Error(`Project knowledge not found: ${knowledgeId}.`);
+    if (knowledge.every((entry, index) => entry === project.knowledge[index]))
+        return project;
     return validateProject({ ...project, knowledge, updatedAt: now.toISOString() });
 }
+function knowledgeRevision(entry) {
+    const { schemaVersion: _schema, id: _id, history: _history, createdAt: _created, ...revision } = entry;
+    return revision;
+}
 /**
  * Stable dedup fingerprint for a promotion candidate. Two proposals with the
- * same source identity, title, and body are the same conclusion regardless of
- * who proposed them or when.
+ * same source, content, applicability and replacement intent are identical.
+ * Trim outer whitespace only; preserve case, internal whitespace and Unicode.
+ * A JSON tuple avoids collisions between user-supplied identity delimiters.
  */
 export function knowledgeProposalFingerprint(input) {
-    const sourceKey = [
-        input.projectId,
-        input.source.taskId,
-        input.source.decisionId ?? "",
-        input.source.milestoneId ?? "",
-        input.source.commitSha ?? ""
-    ].join("|");
+    const optional = (value) => value === undefined ? null : requireText(value, "Knowledge fingerprint field");
     return createHash("sha256")
-        .update(`${sourceKey}\u0000${input.title}\u0000${input.body}`)
+        .update(JSON.stringify([
+        "knowledge-proposal-v2", requireText(input.projectId, "Project id"),
+        requireText(input.source.taskId, "Source Task"), optional(input.source.decisionId),
+        optional(input.source.milestoneId), optional(input.source.commitSha),
+        requireText(input.title, "Knowledge title"), requireText(input.body, "Knowledge body"),
+        optional(input.scope), optional(input.expiresWhen), optional(input.supersedesKnowledgeId)
+    ]))
         .digest("hex");
 }
 /** Digest of the cited source evidence, so a later Agent can verify it. */
@@ -334,17 +364,18 @@ export function validateProject(project) {
     requireGitRef(project.developmentBranch, "Project development branch");
     const knowledgeIds = new Set();
     for (const entry of project.knowledge) {
-        if (entry.schemaVersion !== 1)
-            throw new Error("Project knowledge must use schemaVersion 1.");
+        if (entry.schemaVersion !== 2)
+            throw new Error("Project knowledge must use schemaVersion 2.");
         requireIdentity(entry.id, "Project knowledge id");
-        requireText(entry.title, "Project knowledge title");
-        requireText(entry.body, "Project knowledge body");
-        if (!["active", "retired"].includes(entry.status)) {
-            throw new Error("Project knowledge status is invalid.");
-        }
-        if (entry.provenance !== undefined) {
-            validateKnowledgeProvenance(entry.provenance);
+        validateKnowledgeRevision(entry);
+        if (!Array.isArray(entry.history) || entry.history.length !== entry.version - 1) {
+            throw new Error("Project knowledge history must contain every prior version.");
         }
+        entry.history.forEach((revision, index) => {
+            validateKnowledgeRevision(revision);
+            if (revision.version !== index + 1)
+                throw new Error("Project knowledge history is out of order.");
+        });
         requireTimestamp(entry.createdAt, "Project knowledge createdAt");
         requireTimestamp(entry.updatedAt, "Project knowledge updatedAt");
         if (knowledgeIds.has(entry.id))
@@ -363,6 +394,21 @@ export function validateProject(project) {
     requireTimestamp(project.updatedAt, "Project updatedAt");
     return project;
 }
+function validateKnowledgeRevision(entry) {
+    if (!Number.isSafeInteger(entry.version) || entry.version < 1)
+        throw new Error("Invalid knowledge version.");
+    requireText(entry.title, "Project knowledge title");
+    requireText(entry.body, "Project knowledge body");
+    if (entry.scope !== undefined)
+        requireText(entry.scope, "Knowledge scope");
+    if (entry.expiresWhen !== undefined)
+        requireText(entry.expiresWhen, "Knowledge expiry condition");
+    if (!["active", "retired"].includes(entry.status))
+        throw new Error("Project knowledge status is invalid.");
+    if (entry.provenance !== undefined)
+        validateKnowledgeProvenance(entry.provenance);
+    requireTimestamp(entry.updatedAt, "Project knowledge updatedAt");
+}
 function validateKnowledgeProvenance(provenance) {
     requireIdentity(provenance.taskId, "Knowledge provenance task id");
     if (provenance.decisionId !== undefined) {
@@ -394,8 +440,8 @@ function validateKnowledgeProvenance(provenance) {
     return provenance;
 }
 function validateKnowledgeProposal(proposal, projectId) {
-    if (proposal.schemaVersion !== 1) {
-        throw new Error("Knowledge proposal must use schemaVersion 1.");
+    if (proposal.schemaVersion !== 2) {
+        throw new Error("Knowledge proposal must use schemaVersion 2.");
     }
     requireIdentity(proposal.id, "Knowledge proposal id");
     if (proposal.projectId !== projectId) {
@@ -403,6 +449,9 @@ function validateKnowledgeProposal(proposal, projectId) {
     }
     requireText(proposal.title, "Knowledge proposal title");
     requireText(proposal.body, "Knowledge proposal body");
+    if (proposal.fingerprint !== knowledgeProposalFingerprint(proposal)) {
+        throw new Error("Knowledge proposal fingerprint does not match its content.");
+    }
     if (!["pending", "accepted", "rejected"].includes(proposal.status)) {
         throw new Error("Knowledge proposal status is invalid.");
     }

package/dist/resources/resourceDiscovery.js

@@ -10,6 +10,7 @@ import { execFile } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { promisify } from "node:util";
+import { readGitWorktrees } from "../repository/gitWorktreeInventory.js";
 import { managedProjectPath } from "../repository/project.js";
 import { managedRuntimeRoot } from "../storage/homeLayout.js";
 import { isResourceQuarantinePath } from "./resourceRegistry.js";
@@ -54,8 +55,7 @@ export function parseGitWorktreePorcelain(output) {
 }
 async function listGitWorktrees(repositoryPath) {
     try {
-        const { stdout } = await executeFile("git", ["-C", repositoryPath, "worktree", "list", "--porcelain"], { timeout: 10_000 });
-        return parseGitWorktreePorcelain(stdout);
+        return await readGitWorktrees(repositoryPath);
     }
     catch (error) {
         throw new Error(`Failed to list Git worktrees for ${repositoryPath}: `

package/dist/resources/resourceGc.js

@@ -16,6 +16,7 @@
  * - `restoreAllResourceGc` is the explicit rollback entry point.
  */
 import { execFileSync } from "node:child_process";
+import { supportedGit } from "../repository/gitCompatibility.js";
 import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, relative, isAbsolute } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -384,13 +385,14 @@ function quarantineResource(home, record, now) {
     const receiptPath = `${quarantinePath}.receipt.json`;
     try {
         if (isGitWorktreePath(record.path)) {
+            const program = supportedGit();
             // Move the linked worktree, including its exact checkout and Git
             // metadata, into the Home-local quarantine. Restore is the inverse
             // move, so the recorded HEAD cannot drift with a branch.
             mkdirSync(quarantineRoot, { recursive: true, mode: 0o700 });
             // Keep the existing SQLite writer fence through this bounded move, so a
             // Task reopen or new durable owner cannot commit between check and move.
-            execFileSync("git", ["-C", record.path, "worktree", "move", "--", record.path, quarantinePath], { timeout: 30_000 });
+            execFileSync(program.path, ["-C", record.path, "worktree", "move", "--", record.path, quarantinePath], { timeout: 30_000 });
             writeQuarantineReceipt(home, record, now, "move", receiptPath);
             return {
                 ok: true,
@@ -496,9 +498,10 @@ function restoreQuarantinedRecord(record, liveRefs, now) {
                 updatedAt: now.toISOString()
             };
         }
+        const program = isGitWorktreePath(quarantine.path) ? supportedGit() : undefined;
         mkdirSync(dirname(quarantine.originalPath), { recursive: true });
-        if (isGitWorktreePath(quarantine.path)) {
-            execFileSync("git", ["-C", quarantine.path, "worktree", "move", "--", quarantine.path, quarantine.originalPath], { timeout: 30_000 });
+        if (program !== undefined) {
+            execFileSync(program.path, ["-C", quarantine.path, "worktree", "move", "--", quarantine.path, quarantine.originalPath], { timeout: 30_000 });
         }
         else {
             renameSync(quarantine.path, quarantine.originalPath);
@@ -604,7 +607,7 @@ export async function purgeResourceQuarantine(home, options, store) {
             try {
                 if (existsSync(quarantine.path)) {
                     if (isGitWorktreePath(quarantine.path)) {
-                        execFileSync("git", ["-C", quarantine.path, "worktree", "remove", "--force", "--", quarantine.path], { timeout: 30_000 });
+                        execFileSync(supportedGit().path, ["-C", quarantine.path, "worktree", "remove", "--force", "--", quarantine.path], { timeout: 30_000 });
                     }
                     rmSync(quarantine.path, { recursive: true, force: true });
                 }

package/dist/resources/resourceRegistrar.js

@@ -9,6 +9,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
+import { gitOutputLine, supportedGit } from "../repository/gitCompatibility.js";
 import { upsertResourceRecord } from "./resourceRegistry.js";
 import { createResourceRegistryStore } from "./resourceRegistryStore.js";
 import { createResourceRecord, isReleaseNamespacePath, resourceId } from "./resourceTypes.js";
@@ -212,7 +213,7 @@ function ownerFromManagedWorkspace(home, owner, projectId) {
     };
 }
 function readGitWorktreeMetadata(path) {
-    const commonDir = execFileSync("git", ["-C", path, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const commonDir = resolve(path, gitOutputLine(execFileSync(supportedGit().path, ["-C", path, "rev-parse", "--git-common-dir"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] })));
     const repositoryPath = basename(commonDir) === ".git" ? dirname(commonDir) : commonDir;
     let branch;
     try {

package/dist/runtime/agentEndpoint.js

@@ -41,6 +41,12 @@ export function createAgentEndpointFactory(start = startStructuredProviderSessio
                 endpoint.observe(event);
         };
         const opened = await start(payload, {
+            // The native TUI owns rendering while attached. Raw JSON mirroring into
+            // its inherited PTY would corrupt its screen on every Provider event.
+            mirrorOutput: (stream, text) => {
+                if (!endpoint?.nativeAccess?.attached)
+                    (stream === "stdout" ? process.stdout : process.stderr).write(text);
+            },
             onAccepted: (value) => emit({ type: "accepted", value }),
             onActivity: (value) => emit({ type: "activity", value }),
             onStarted: (value) => emit({ type: "started", value }),
@@ -74,6 +80,7 @@ function freezeConfiguration(value) {
 class BuiltinAgentEndpoint {
     driver;
     configuration;
+    get nativeAccess() { return this.driver.nativeAccess; }
     get ownedProcessId() { return this.driver.ownedProcessId; }
     get nativeAccountHome() { return this.driver.nativeAccountHome; }
     capabilities;
@@ -118,6 +125,7 @@ class BuiltinAgentEndpoint {
     get nativeSessionId() { return this.driver.nativeSessionId; }
     get conversationId() { return this.driver.conversationId; }
     get processInstanceId() { return this.driver.processInstanceId; }
+    get publicReply() { return this.driver.publicReply; }
     /**
      * Delegated rather than copied at construction: the Session reads its own
      * current state, and a value captured here would freeze the configuration as

package/dist/runtime/agentHost.js

@@ -18,6 +18,7 @@ import { closeAgentHostEndpoints } from "./agentHostCleanup.js";
 import { readAgentRunConfigurationObservation, unknownAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { CodexPreSubmissionError } from "./codexAppServerRuntime.js";
 import { runCodexInteractiveHost } from "./codexInteractiveHost.js";
+import { openControlledCodexTui } from "./controlledCodexTui.js";
 import { validateAgentHostLaunchPayload } from "./launchBroker.js";
 import { validateRuntimeProcessExitObservation } from "./processExitObservation.js";
 import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox } from "./processExitOutbox.js";
@@ -108,6 +109,10 @@ export async function runAgentHost(input) {
     let snapshot = hostSnapshot("idle");
     let dispatchTail = Promise.resolve();
     let promptHuman = () => { };
+    let humanConsole;
+    let nativeTui;
+    let nativeOpening;
+    let modelChanging = false;
     const recentSteerAttempts = new Map();
     await replayExitOutbox(input.home);
     const updateSnapshot = (next) => {
@@ -444,6 +449,8 @@ export async function runAgentHost(input) {
                 && providerSession.adapterId === "codex"
                 && !hostStopRequested;
             if (reconnectableCodexClient) {
+                nativeTui?.close();
+                nativeTui = undefined;
                 session = undefined;
                 if (codexClientAttachedAt !== undefined
                     && Date.now() - codexClientAttachedAt >= CODEX_CLIENT_STABLE_MS) {
@@ -1028,7 +1035,128 @@ export async function runAgentHost(input) {
         promptHuman();
         return snapshot;
     };
-    const control = await openAgentHostControl(input.home, payload, () => snapshot, async (request) => {
+    const nativeMutation = async (expected, method, params) => {
+        if (session !== expected || params.threadId !== expected.nativeSessionId || !authority
+            || (sessionPayload?.environment.YUI_SESSION_SCOPE === "task" && sessionPayload.environment.YUI_ROLE !== "leader")) {
+            throw new Error("Native input targets a replaced or unsupported Session.");
+        }
+        if (method === "turn/interrupt") {
+            if (!activeRunAttemptId || params.turnId !== activeNativeTurnId)
+                throw new Error("Native stop targets a different Turn.");
+            const cancelled = await expected.cancel(activeRunAttemptId);
+            if (cancelled.status !== "requested")
+                throw new Error(`Native stop is ${cancelled.status}; do not replay.`);
+            return {};
+        }
+        if (!Array.isArray(params.input) || params.input.length === 0
+            || params.input.some(part => !part || typeof part !== "object"
+                || part.type !== "text" || typeof part.text !== "string")) {
+            throw new Error("Managed native access currently supports text input only.");
+        }
+        const boundedText = params.input.map(part => part.text).join("\n");
+        if (!boundedText.trim() || boundedText.includes("\0") || Buffer.byteLength(boundedText) > 12000)
+            throw new Error("Native input exceeds its text bound.");
+        const run = { attemptId: `human:${authority.holderId}:${randomUUID()}`, boundedText };
+        if (method === "turn/steer") {
+            const turnId = activeNativeTurnId;
+            if (params.expectedTurnId !== turnId || !turnId)
+                throw new Error("Native steer targets a different Turn.");
+            if (!sessionPayload)
+                throw new Error("Native Session launch context is unavailable.");
+            // Persist human intent and the existing steer receipt before Provider
+            // write. A fresh human turn id is not an additional-input binding.
+            const prepared = await callControllerIdempotently(input.home, "runtime.native-steer-prepare", {
+                ...hostRunControlParams(sessionPayload, expected.nativeSessionId, authority, run.attemptId),
+                nativeTurnId: turnId, boundedText
+            });
+            const result = await handleControl({ protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "steer-turn",
+                nativeSessionId: expected.nativeSessionId, nativeTurnId: turnId, authority, run: prepared });
+            if (result.outcome !== "accepted")
+                throw new Error("Native steer acceptance is unconfirmed; do not resubmit.");
+            return { turnId };
+        }
+        const result = await handleControl({ protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "submit-turn",
+            nativeSessionId: expected.nativeSessionId, authority, run });
+        const accepted = result.snapshot;
+        if (result.outcome !== "accepted" || accepted.inputAcceptance !== "provider" || !accepted.nativeTurnId) {
+            throw new Error("Native acceptance is unconfirmed; do not resubmit.");
+        }
+        return { turn: { id: accepted.nativeTurnId, items: [], status: "inProgress", error: null } };
+    };
+    const handleControl = async (request) => {
+        if (request.type === "native-model") {
+            return enqueueSerialized(async () => {
+                const current = session;
+                if (!current?.nativeAccess || current.nativeSessionId !== request.nativeSessionId
+                    || !sessionPayload || activeNativeTurnId || authority?.owner !== "controller"
+                    || (sessionPayload.environment.YUI_SESSION_SCOPE === "task" && sessionPayload.environment.YUI_ROLE !== "leader")
+                    || (sessionPayload.environment.YUI_SESSION_SCOPE === "global" && sessionPayload.environment.YUI_ROLE !== "operator")) {
+                    throw new Error("Model switching requires the idle current controlled Codex Session, without a native terminal writer.");
+                }
+                if (nativeTui || nativeOpening) {
+                    throw new Error("Exit the native TUI before changing the Session model. Closing a browser terminal viewer only detaches it; the Host-owned TUI remains open.");
+                }
+                modelChanging = true;
+                try {
+                    await assertHostExecutionEnvironment(input.home, sessionPayload, current.nativeSessionId);
+                    try {
+                        await current.nativeAccess.setModel(request.model);
+                    }
+                    catch (error) {
+                        if (error instanceof CodexPreSubmissionError)
+                            throw error;
+                        throw new ProviderDeliveryUnknownError(`Native model adoption is unconfirmed: ${errorText(error)}`, `model:${current.nativeSessionId}`, { cause: error });
+                    }
+                    return controlResult("accepted", { ...snapshot, runConfiguration: current.runConfiguration });
+                }
+                finally {
+                    modelChanging = false;
+                }
+            });
+        }
+        if (request.type === "native-open" || request.type === "native-respond") {
+            const current = session;
+            if (!current?.nativeAccess || current.nativeSessionId !== request.nativeSessionId
+                || !sessionPayload || (sessionPayload.environment.YUI_SESSION_SCOPE === "task"
+                && sessionPayload.environment.YUI_ROLE !== "leader"))
+                throw new Error("Native access requires the current controlled Codex Operator/Leader.");
+            if (request.type === "native-respond") {
+                await assertHostExecutionEnvironment(input.home, sessionPayload, current.nativeSessionId);
+                await current.nativeAccess.respond(request.requestId, request.nativeSessionId, request.nativeTurnId ?? null, request.result);
+            }
+            else if (!nativeTui) {
+                if (modelChanging)
+                    throw new Error("Wait for model adoption before attaching native input.");
+                if (!process.stdin.isTTY)
+                    throw new Error("Native TUI requires the Host's owned terminal.");
+                humanConsole?.close();
+                humanConsole = undefined;
+                nativeOpening ??= openControlledCodexTui(sessionPayload, current.nativeSessionId, current.nativeAccess, {
+                    mutate: (method, params) => nativeMutation(current, method, params),
+                    respond: async (requestId, nativeTurnId, result) => {
+                        await handleControl({ protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "native-respond",
+                            nativeSessionId: current.nativeSessionId, requestId, nativeTurnId, result });
+                    },
+                    onExit: () => {
+                        nativeTui = undefined;
+                        process.stdout.write("\r\nNative TUI detached. Reattach the terminal to reopen this same Thread; the Agent Host remains running.\r\n");
+                    },
+                    onError: error => process.stderr.write(`Native TUI: ${errorText(error)}\n`)
+                });
+                try {
+                    nativeTui = await nativeOpening;
+                }
+                finally {
+                    nativeOpening = undefined;
+                }
+                if (session !== current) {
+                    nativeTui.close();
+                    nativeTui = undefined;
+                    throw new Error("Session changed while opening native access.");
+                }
+            }
+            return controlResult("accepted", { ...snapshot, nativeTui: !!nativeTui });
+        }
         if (request.type === "status") {
             // Read the Agent's configuration at answer time, not from the stored
             // snapshot. The Agent may have changed it since the last state
@@ -1036,10 +1164,20 @@ export async function runAgentHost(input) {
             // current reading rather than the one that was true at launch. Nothing is
             // sent to the Agent to obtain it: this reads what the Session has already
             // been told.
+            let requestBytes = 0;
+            const nativeRequests = session?.nativeAccess?.requests.filter(request => {
+                requestBytes += Buffer.byteLength(JSON.stringify(request));
+                return requestBytes <= 8000;
+            }).slice(0, 8);
             return controlResult("status", session === undefined
                 ? snapshot
                 : validateSnapshot({
                     ...snapshot,
+                    nativeTui: !!nativeTui,
+                    ...(nativeRequests === undefined ? {} : { nativeRequests,
+                        nativeRequestsOmitted: nativeRequests.length !== session.nativeAccess.requests.length }),
+                    ...(session.publicReply === undefined ? {} : { publicReply: session.publicReply }),
+                    ...(session.adapterId === "codex" ? { publicReplyObservation: "supported" } : {}),
                     runConfiguration: session.runConfiguration
                 }));
         }
@@ -1138,6 +1276,8 @@ export async function runAgentHost(input) {
             const accepted = await enqueueSerialized(async () => setAuthority(request));
             return controlResult("accepted", accepted);
         }
+        if (request.type !== "launch")
+            throw new Error("Unsupported Host request.");
         const redeemed = await redeem(input.home, request.ticket);
         if (activeRunPayload !== undefined
             || ["starting", "ready", "settling", "delivery-unknown"].includes(snapshot.state)) {
@@ -1149,8 +1289,9 @@ export async function runAgentHost(input) {
         }
         const accepted = await enqueueDispatch(redeemed);
         return controlResult("accepted", accepted);
-    });
-    const humanConsole = process.stdin.isTTY
+    };
+    const control = await openAgentHostControl(input.home, payload, () => snapshot, handleControl);
+    humanConsole = process.stdin.isTTY
         ? createInterface({ input: process.stdin, output: process.stdout, terminal: true })
         : undefined;
     promptHuman = () => {
@@ -1231,6 +1372,7 @@ export async function runAgentHost(input) {
         if (forceKillTimer !== undefined)
             clearTimeout(forceKillTimer);
         humanConsole?.close();
+        nativeTui?.close();
         await closeAgentHostEndpoints({
             owner: endpointOwner, session, lease: endpointLease, adapterId: endpointAdapterId,
             attemptId: activeRunAttemptId ?? lastTerminal?.attemptId,
@@ -1309,6 +1451,9 @@ export async function sendAgentHostAuthorityControl(input) {
 export async function sendAgentHostCancelControl(input) {
     return await sendAgentHostControl(input);
 }
+export async function sendAgentHostNativeControl(input) {
+    return sendAgentHostControl(input);
+}
 export async function inspectAgentHost(input) {
     const result = await sendAgentHostControl({
         ...input,
@@ -1550,6 +1695,12 @@ function boundControlResponse(result) {
     };
     if (withinControlBound(result))
         return result;
+    if (result.snapshot.publicReply !== undefined) {
+        const { publicReply: _omitted, ...snapshot } = result.snapshot;
+        result = { ...result, snapshot };
+        if (withinControlBound(result))
+            return result;
+    }
     const clip = (text, chars) => {
         if (text.length <= chars)
             return text;
@@ -1613,6 +1764,22 @@ function validateControl(control) {
     }
     if (control.type === "status")
         return Object.freeze({ ...control });
+    if (control.type === "native-open" || control.type === "native-respond" || control.type === "native-model") {
+        validateIdentity(control.nativeSessionId, "native Session id");
+        if (control.type === "native-model" && (typeof control.model !== "string"
+            || !control.model.trim() || control.model.length > 200 || control.model.includes("\0"))) {
+            throw new Error("Invalid native model.");
+        }
+        if (control.type === "native-respond") {
+            if (control.nativeTurnId !== null)
+                validateIdentity(control.nativeTurnId, "native Turn id");
+            if ((typeof control.requestId !== "string" && typeof control.requestId !== "number")
+                || control.result === null || typeof control.result !== "object" || Array.isArray(control.result)) {
+                throw new Error("Invalid native request response.");
+            }
+        }
+        return Object.freeze({ ...control });
+    }
     if (control.type === "cancel") {
         if (control.nativeOnly !== undefined && typeof control.nativeOnly !== "boolean") {
             throw new Error("Native-only cancellation flag is invalid.");

package/dist/runtime/codexAppServerRuntime.js

@@ -42,7 +42,7 @@ export class CodexAppServerRuntime {
             cwd: text(input.cwd, "Codex thread cwd"),
             ...threadOptions(input)
         });
-        return { conversationId: threadId(result) };
+        return { conversationId: threadId(result), raw: result };
     }
     async resumeConversation(conversationId, options = {}) {
         const id = text(conversationId, "Codex thread id");