@zq-silk/yui 2.22.0 → 2.25.0

package/dist/runtime/codexInteractiveHost.js

@@ -4,7 +4,11 @@ import { once } from "node:events";
 import WebSocket, { WebSocketServer } from "ws";
 import { AGENT_HOST_CONTROL_PROTOCOL } from "./agentHostProtocol.js";
 import { openCodexInteractiveConnection } from "./structuredProviderHost.js";
-import { createSessionSkillNotice } from "../context/sessionSkillNotice.js";
+import { createSessionSkillNotice, createSessionSkillLifecycleCheck } from "../context/sessionSkillNotice.js";
+import { isNativeContextRecovery } from "./contextRecovery.js";
+import { createHostSessionLifecycle } from "./hostSessionLifecycle.js";
+import { createNonBlockingChecks } from "./lifecycleChecks.js";
+import { createNativeTitleSync } from "./nativeTitleSync.js";
 /**
  * Keep the native TUI and its transparent App Server attachment in one pane.
  * The existing Host acknowledgement carries the ID from that TUI's exact
@@ -31,8 +35,19 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         throw new Error("Codex proxy base arguments are invalid.");
     }
     const expectedId = environment.YUI_NATIVE_SESSION_ID;
+    const lifecycleChecks = createNonBlockingChecks([createSessionSkillLifecycleCheck(home, () => environment)], error => process.stderr.write(`Session lifecycle check failed: ${String(error)}\n`));
+    const lifecycle = createHostSessionLifecycle({ after: lifecycleChecks });
+    lifecycle.send({ type: "launch" });
     let snapshot = {
-        schemaVersion: 1, state: "starting", adapterId: "codex", updatedAt: new Date().toISOString()
+        schemaVersion: 1, state: lifecycle.state, adapterId: "codex", updatedAt: new Date().toISOString()
+    };
+    const transition = (event, fields = {}) => {
+        const result = lifecycle.send(event);
+        if (result.status === "ignored")
+            return;
+        if (result.status === "invalid")
+            throw new Error(result.reason);
+        snapshot = { ...snapshot, ...fields, state: result.state, updatedAt: new Date().toISOString() };
     };
     const control = await openAgentHostControl(home, payload, () => snapshot, async (request) => {
         if (request.type !== "status") {
@@ -44,6 +59,9 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
     let client;
     let closing = false;
     let startupRequestId;
+    let initializeRequestId;
+    let nativeAccountHome;
+    let titleSync;
     let connection;
     let relay;
     const signals = ["SIGTERM", "SIGHUP", "SIGINT"];
@@ -51,11 +69,9 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
     const fail = (error) => {
         if (closing || snapshot.state === "failed")
             return;
-        snapshot = {
-            ...snapshot, state: "failed",
-            detail: error instanceof Error ? error.message : String(error),
-            updatedAt: new Date().toISOString()
-        };
+        transition({ type: "failure", outcome: "failed" }, {
+            detail: error instanceof Error ? error.message : String(error)
+        });
         process.stderr.write(`Yui Codex attachment failed: ${snapshot.detail}\n`);
         client?.terminate();
         stop();
@@ -94,6 +110,11 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
                     if (binary)
                         throw new Error("Codex TUI sent a binary App Server request.");
                     const message = jsonObject(JSON.parse(data.toString()));
+                    if (message.method === "thread/name/set")
+                        titleSync?.close();
+                    if (message.method === "initialize"
+                        && (typeof message.id === "string" || typeof message.id === "number"))
+                        initializeRequestId = message.id;
                     if (snapshot.nativeSessionId === undefined
                         && (message.method === "thread/start" || message.method === "thread/resume")) {
                         if (startupRequestId !== undefined)
@@ -135,6 +156,17 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         });
         connection.onMessage((message) => {
             try {
+                if (snapshot.nativeSessionId !== undefined
+                    && isNativeContextRecovery("codex", snapshot.nativeSessionId, message))
+                    skillNotice.invalidate();
+                if (message.method === "thread/name/updated"
+                    && message.params?.threadId === snapshot.nativeSessionId)
+                    titleSync?.close();
+                if (message.method === undefined && message.id === initializeRequestId) {
+                    const initialized = message.result;
+                    nativeAccountHome = typeof initialized?.codexHome === "string" ? initialized.codexHome : undefined;
+                    initializeRequestId = undefined;
+                }
                 if (message.method === undefined && (typeof message.id === "string" || typeof message.id === "number")) {
                     const pending = pendingNotices.get(message.id);
                     if (pending !== undefined) {
@@ -142,8 +174,10 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
                         const result = message.result;
                         const turnId = result?.turn?.id ?? result?.turnId;
                         if (message.error === undefined && typeof turnId === "string" && turnId.length > 0
-                            && (pending.expectedTurnId === undefined || pending.expectedTurnId === turnId))
+                            && (pending.expectedTurnId === undefined || pending.expectedTurnId === turnId)) {
                             pending.commit();
+                            titleSync?.notify();
+                        }
                     }
                 }
                 let nativeSessionId;
@@ -166,13 +200,17 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
                         fail(error);
                         return;
                     }
-                    if (nativeSessionId === undefined || snapshot.state === "failed")
+                    if (nativeSessionId === undefined || closing || snapshot.state === "failed")
                         return;
                     startupRequestId = undefined;
-                    snapshot = {
-                        ...snapshot, state: "ready", nativeSessionId, conversationId: nativeSessionId,
-                        updatedAt: new Date().toISOString()
-                    };
+                    // Ready here means the native TUI attachment is ready, not a managed
+                    // AgentRun acceptance or proof that the native Thread is idle.
+                    transition({ type: "interactive-connected", nativeSessionId }, {
+                        nativeSessionId, conversationId: nativeSessionId
+                    });
+                    titleSync = createNativeTitleSync(payload, nativeSessionId, nativeAccountHome, result => process.stderr.write(`Native title: ${JSON.stringify(result)}\n`));
+                    if (expectedId !== undefined)
+                        titleSync.notify();
                 });
             }
             catch (error) {
@@ -196,6 +234,7 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         for (const signal of signals)
             process.on(signal, stop);
         const [code] = await once(child, "exit");
+        transition({ type: "exit" });
         return typeof code === "number" ? code : 1;
     }
     catch (error) {
@@ -203,7 +242,9 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         throw error;
     }
     finally {
+        lifecycleChecks.close();
         closing = true;
+        titleSync?.close();
         for (const signal of signals)
             process.removeListener(signal, stop);
         stop();
@@ -214,7 +255,8 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         await control.close();
     }
 }
-/** Preserve all native content parts (including images), adding only Host metadata. */
+/** Keep application metadata out of native user input, including on steer.
+ * Formal titles are synchronized separately; no automatic-title heuristic is assumed. */
 export function codexInteractiveSkillInput(notice, environment, nativeSessionId, params) {
     if (!Array.isArray(params.input))
         throw new Error("Turn input must be an array.");
@@ -222,9 +264,12 @@ export function codexInteractiveSkillInput(notice, environment, nativeSessionId,
     return {
         params: {
             ...params,
-            input: prepared.text.length === 0 ? params.input : [
-                { type: "text", text: prepared.text.trimEnd(), text_elements: [] }, ...params.input
-            ]
+            ...(prepared.context === undefined ? {} : {
+                additionalContext: {
+                    ...(params.additionalContext == null ? {} : jsonObject(params.additionalContext)),
+                    "yui.session-skills": { kind: "application", value: prepared.context }
+                }
+            })
         },
         commit: prepared.commit
     };

package/dist/runtime/codexNativeAccess.js

@@ -5,7 +5,7 @@ const READS = new Set([
     "config/read", "configRequirements/read", "model/list", "collaborationMode/list",
     "experimentalFeature/list", "skills/list", "hooks/list", "mcpServerStatus/list", "account/read",
     "account/rateLimits/read", "modelProvider/capabilities/read", "permissionProfile/list",
-    "thread/read", "thread/turns/list", "thread/items/list", "thread/goal/get"
+    "thread/read", "thread/turns/list", "thread/items/list", "thread/goal/get", "thread/backgroundTerminals/list"
 ]);
 const REQUESTS = new Set([
     "item/commandExecution/requestApproval", "item/fileChange/requestApproval",

package/dist/runtime/contextRecovery.js

@@ -0,0 +1,15 @@
+/** Only explicit, identity-bound native lifecycle events invalidate context.
+ * Absence of an event never proves that instructions are still in memory. */
+export function isNativeContextRecovery(adapter, nativeSessionId, message) {
+    if (adapter === "claude") {
+        return message.type === "system" && message.subtype === "compact_boundary"
+            && message.session_id === nativeSessionId;
+    }
+    const params = message.params;
+    if (!params || params.threadId !== nativeSessionId)
+        return false;
+    if (message.method === "thread/compacted")
+        return true;
+    const item = params.item;
+    return message.method === "item/completed" && item?.type === "contextCompaction";
+}

package/dist/runtime/hostSessionLifecycle.js

@@ -0,0 +1,83 @@
+const live = [
+    "idle", "starting", "ready", "busy", "settling", "delivery-unknown", "rejected", "failed"
+];
+const available = ["idle", "busy", "rejected", "failed"];
+const occupancy = (value) => (event) => "occupancy" in event && event.occupancy === value;
+/** Lifecycle only: no version checks, upgrade phases, I/O or business policy.
+ * Each event selects one guarded edge; callers cannot assign a target state.
+ * Existing authority/admission checks must succeed before sending commands. */
+export const HOST_SESSION_LIFECYCLE_TRANSITIONS = {
+    launch: [{ from: [...available, "exited"], to: "starting" }],
+    submit: [{ from: available, to: "starting" }],
+    connected: [
+        { from: live, guard: occupancy("owned"), to: "ready" },
+        { from: live, guard: occupancy("unknown"), to: "delivery-unknown" },
+        { from: live, guard: occupancy("busy"), to: "busy" },
+        { from: live, guard: occupancy("idle"), to: "idle" }
+    ],
+    accepted: [{ from: ["starting", "ready", "delivery-unknown"], to: "ready" }],
+    "interactive-connected": [{ from: ["starting", "ready"], to: "ready" }],
+    "native-started": [{ from: live, to: "busy" }],
+    terminal: [{ from: ["starting", "ready", "busy", "delivery-unknown", "settling", "failed"], to: "settling" }],
+    settled: [
+        { from: live, guard: occupancy("idle"), to: "idle" },
+        { from: live, guard: occupancy("busy"), to: "busy" }
+    ],
+    disconnected: [{ from: live, to: "starting" }],
+    "authority-changed": [{ from: available, to: "idle" }],
+    failure: ["busy", "delivery-unknown", "rejected", "failed"].map(outcome => ({
+        from: live, guard: event => event.type === "failure" && event.outcome === outcome, to: outcome
+    })),
+    exit: [{ from: live, to: "exited" }]
+};
+export function createHostSessionLifecycle(hooks = {}) {
+    let state = "idle";
+    let revision = 0;
+    let identity = {};
+    const edgeFor = (event) => HOST_SESSION_LIFECYCLE_TRANSITIONS[event.type].find(rule => rule.from.includes(state) && (!rule.guard || rule.guard(event)));
+    return {
+        get state() { return state; },
+        get revision() { return revision; },
+        /** State eligibility only; caller still owns exact writer/resource guards. */
+        can(event) { return edgeFor(event) !== undefined; },
+        send(input) {
+            const event = Object.freeze({ ...input });
+            if (state === "exited" && event.type !== "launch")
+                return { status: "ignored", state, reason: "exited" };
+            if (!["launch", "connected"].includes(event.type)) {
+                for (const key of ["processInstanceId", "nativeSessionId"]) {
+                    if (identity[key] && event[key] && identity[key] !== event[key]) {
+                        return { status: "ignored", state, reason: `stale-${key}` };
+                    }
+                }
+                if (["accepted", "terminal"].includes(event.type)
+                    && identity.attemptId && event.attemptId && identity.attemptId !== event.attemptId) {
+                    return { status: "ignored", state, reason: "stale-attempt" };
+                }
+                if (event.type === "terminal" && identity.nativeTurnId && event.nativeTurnId
+                    && identity.nativeTurnId !== event.nativeTurnId) {
+                    return { status: "ignored", state, reason: "stale-turn" };
+                }
+            }
+            const edge = edgeFor(event);
+            if (!edge)
+                return { status: "invalid", state, reason: `No ${event.type} edge from ${state}` };
+            const transition = Object.freeze({ from: state, to: edge.to, revision: revision + 1, event });
+            hooks.before?.notify(transition);
+            state = edge.to;
+            revision += 1;
+            // A new authorized attachment must not inherit the departed proxy's
+            // identity fence. A launch reusing a live connection supplies its IDs.
+            if (event.type === "launch")
+                identity = {};
+            identity = {
+                processInstanceId: event.processInstanceId ?? identity.processInstanceId,
+                nativeSessionId: event.nativeSessionId ?? identity.nativeSessionId,
+                attemptId: event.attemptId,
+                nativeTurnId: event.nativeTurnId
+            };
+            hooks.after?.notify(transition);
+            return { status: "applied", state };
+        }
+    };
+}

package/dist/runtime/hostUpgradeGate.js

@@ -0,0 +1,43 @@
+/** Host-local input admission fence. The existing lifecycle mailbox owns the
+ * durable request; this gate owns only the actual loaded process's drain. */
+export function createHostUpgradeGate() {
+    let current;
+    let draining;
+    return {
+        get observation() { return current; },
+        get fenced() { return current !== undefined; },
+        request(fence, identity) {
+            if (fence.nativeSessionId !== identity.nativeSessionId
+                || fence.processInstanceId !== identity.processInstanceId
+                || fence.hostGeneration !== identity.hostGeneration)
+                throw new Error("Host upgrade identity changed.");
+            if (current && (fence.requestId !== current.requestId || fence.nativeSessionId !== current.nativeSessionId
+                || fence.processInstanceId !== current.processInstanceId || fence.hostGeneration !== current.hostGeneration)) {
+                throw new Error("Host already holds a different upgrade request.");
+            }
+            current ??= { requestId: fence.requestId, nativeSessionId: fence.nativeSessionId,
+                processInstanceId: fence.processInstanceId, hostGeneration: fence.hostGeneration, state: "waiting" };
+        },
+        async drain(input) {
+            if (!current || current.state !== "waiting")
+                return;
+            if (input.busy || input.events.pending !== 0 || input.events.pendingTerminals !== 0
+                || input.events.unpersisted !== 0 || input.events.failure !== undefined)
+                return;
+            draining ??= (async () => {
+                try {
+                    if (!await input.checkQuiescent())
+                        return;
+                    await input.release();
+                    current = { ...current, state: "drained" };
+                }
+                catch (error) {
+                    current = { ...current, state: "failed",
+                        detail: error instanceof Error ? error.message : String(error) };
+                }
+            })();
+            await draining;
+            draining = undefined;
+        }
+    };
+}

package/dist/runtime/lifecycleChecks.js

@@ -0,0 +1,47 @@
+export function createNonBlockingChecks(checks, onError = () => { }) {
+    if (new Set(checks.map(check => check.id)).size !== checks.length)
+        throw new Error("Duplicate lifecycle check id.");
+    const abort = new AbortController();
+    const lanes = checks.map(check => ({ check, running: false, pending: undefined }));
+    const launch = (lane) => {
+        if (lane.running || abort.signal.aborted)
+            return;
+        lane.running = true;
+        // Defer even synchronous callbacks until the caller has committed its state.
+        void Promise.resolve().then(async () => {
+            while (lane.pending && !abort.signal.aborted) {
+                const { value } = lane.pending;
+                lane.pending = undefined;
+                try {
+                    await lane.check.run(value, abort.signal);
+                }
+                catch (error) {
+                    try {
+                        onError(error);
+                    }
+                    catch { /* Diagnostics cannot gate lifecycle. */ }
+                }
+            }
+        }).finally(() => {
+            lane.running = false;
+            if (lane.pending)
+                launch(lane);
+        });
+    };
+    return {
+        notify(observation) {
+            if (abort.signal.aborted)
+                return;
+            for (const lane of lanes) {
+                lane.pending = { value: observation };
+                launch(lane);
+            }
+        },
+        get pendingCount() { return lanes.filter(lane => lane.pending !== undefined).length; },
+        close() {
+            abort.abort();
+            for (const lane of lanes)
+                lane.pending = undefined;
+        }
+    };
+}

package/dist/runtime/lifecycleReservation.js

@@ -3,6 +3,9 @@ export const RUNTIME_LIFECYCLE_OWNER = "runtime-lifecycle";
 export const RUNTIME_CLEANUP_REQUIRED_REASON = "runtime-cleanup-required";
 export const RUNTIME_HOST_DETACH_REQUIRED_REASON = "runtime-host-detach-required";
 export const RUNTIME_SESSION_REPLACE_REQUIRED_REASON = "runtime-session-replace-required";
+export const RUNTIME_HOST_UPGRADE_REASON = "runtime-host-upgrade-required";
+export const RUNTIME_HOST_UPGRADE_DRAINED = "runtime-host-upgrade-drained";
+export const RUNTIME_HOST_UPGRADE_FAILED = "runtime-host-upgrade-failed";
 /**
  * A Role runtime lifecycle lane already holds an explicit cleanup obligation.
  * This is scheduler
@@ -48,12 +51,17 @@ export function runtimeCleanupDisposition(mailbox) {
         return "end-session";
     if (reasons.includes(RUNTIME_HOST_DETACH_REQUIRED_REASON))
         return "detach-host";
+    if (reasons.includes(RUNTIME_HOST_UPGRADE_REASON))
+        return "upgrade-host";
     return null;
 }
 export function isRuntimeCleanupReason(reason) {
     return reason === RUNTIME_CLEANUP_REQUIRED_REASON
         || reason === RUNTIME_SESSION_REPLACE_REQUIRED_REASON
-        || reason === RUNTIME_HOST_DETACH_REQUIRED_REASON;
+        || reason === RUNTIME_HOST_DETACH_REQUIRED_REASON
+        || reason === RUNTIME_HOST_UPGRADE_REASON
+        || reason === RUNTIME_HOST_UPGRADE_DRAINED
+        || reason === RUNTIME_HOST_UPGRADE_FAILED;
 }
 export function hasRuntimeLifecycleWork(mailbox) {
     return mailbox !== null && mailboxHasWork(mailbox);

package/dist/runtime/nativeExecutable.js

@@ -1,9 +1,12 @@
 import { fileURLToPath } from "node:url";
+import { unsupportedPlatformMessage } from "./platform.js";
 /** Native binaries are shipped together; never execute another platform's helper. */
 export function nativeExecutable(name, platform = process.platform, architecture = process.arch) {
     const target = `${platform}-${architecture}`;
-    if (!["linux-x64", "darwin-x64", "darwin-arm64"].includes(target)
-        || (name === "process-identity" && platform !== "darwin")) {
+    const failure = unsupportedPlatformMessage(platform, architecture);
+    if (failure !== undefined)
+        throw new Error(failure);
+    if (name === "process-identity" && platform !== "darwin") {
         throw new Error(`Unsupported native runtime: ${target}/${name}.`);
     }
     return fileURLToPath(new URL(`./native/${target}/${name}`, import.meta.url));

package/dist/runtime/nativeTitleReceipt.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+export function nativeTitleDirectory(home, identity) {
+    const key = createHash("sha256").update(JSON.stringify([
+        identity.scope, identity.taskId ?? null, identity.roleName, identity.agentId, identity.threadId
+    ])).digest("hex");
+    return join(home, "runtime", "native-titles", key);
+}
+export function parseNativeTitleReceipt(text, identity) {
+    const value = JSON.parse(text);
+    if (value.schemaVersion !== 1 || JSON.stringify(value.identity) !== JSON.stringify(identity)
+        || !value.accountHome || !value.attemptId || !value.requestedTitle
+        || !(value.expectedTitle === null || typeof value.expectedTitle === "string")
+        || !["submitted", "confirmed", "unknown", "preserved"].includes(value.status)
+        || !Array.isArray(value.generatedTitles) || value.generatedTitles.some(title => typeof title !== "string")) {
+        throw new Error("Invalid native title receipt; preserve it for diagnosis.");
+    }
+    return value;
+}
+/** Read-only diagnostics can reuse confirmation, never a submitted naming intent.
+ * Unavailable/uncertain evidence supplies no ownership of an existing title. */
+export function confirmedNativeTitles(home, identity) {
+    try {
+        const receipt = parseNativeTitleReceipt(readFileSync(join(nativeTitleDirectory(home, identity), "receipt.json"), "utf8"), identity);
+        return receipt.status === "confirmed" ? receipt.generatedTitles : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/runtime/nativeTitleSync.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rmdir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { createNonBlockingChecks } from "./lifecycleChecks.js";
+import { CodexNamingClient } from "../execution/codexThreadNaming.js";
+import { nativeTitleDirectory, parseNativeTitleReceipt } from "./nativeTitleReceipt.js";
+/** A standalone metadata process, NOT a second connection to the shared
+ * business daemon. It never starts/resumes a Thread or runs a Turn. Its hard
+ * process deadline releases even native locks after an unanswered request.
+ * Caller launches this in an independent lane; Goal/Turn never await it. */
+export async function synchronizeNativeTitle(request) {
+    const result = (status, detail, extra = {}) => ({ threadId: request.identity.threadId, status, detail, ...extra });
+    let client;
+    let locked = false;
+    let submitted = false;
+    let receipt;
+    const cancel = () => client?.close("SIGKILL");
+    const directory = nativeTitleDirectory(request.home, request.identity);
+    try {
+        if (!isAbsolute(request.home) || !isAbsolute(request.accountHome)
+            || [request.title, request.generatedTitle].some(title => title !== undefined
+                && (!title || title.trim() !== title || title.length > 1024 || /[\r\n\0]/u.test(title)))) {
+            return result("not-submitted", "Native title request has an invalid local identity or title.");
+        }
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed.");
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        // Never remove another attempt's lock, including after a Host crash.
+        await mkdir(join(directory, "writing"), { mode: 0o700 });
+        locked = true;
+        try {
+            receipt = parseNativeTitleReceipt(await readFile(join(directory, "receipt.json"), "utf8"), request.identity);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (receipt !== undefined && (receipt.accountHome !== request.accountHome || receipt.status !== "confirmed")) {
+            return result("not-submitted", "Prior title identity/effect is unresolved; no rename replayed.", { attemptId: receipt.attemptId, receiptPath: join(directory, "receipt.json") });
+        }
+        if (request.localTitle !== undefined && request.localTitle !== request.previousTitle
+            && !receipt?.generatedTitles.includes(request.localTitle)) {
+            return result("preserved", "Yui Session has a custom or unowned local title; native name left unchanged.");
+        }
+        client = await CodexNamingClient.start(request.command, { ...request.environment, CODEX_HOME: request.accountHome }, request.baseArgs, request.timeoutMs ?? 2_000);
+        request.signal?.addEventListener("abort", cancel, { once: true });
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed.");
+        if (client.accountHome !== request.accountHome) {
+            return result("not-submitted", "Metadata process account identity did not match the business connection.");
+        }
+        const read = await client.request("thread/read", { threadId: request.identity.threadId, includeTurns: false });
+        const thread = read.thread;
+        if (thread?.id !== request.identity.threadId
+            || !(thread.name == null || typeof thread.name === "string")) {
+            return result("not-submitted", "Native title observation has no exact Thread/name identity.");
+        }
+        const current = typeof thread.name === "string" && thread.name.length > 0 ? thread.name : null;
+        const previous = receipt?.requestedTitle ?? request.previousTitle;
+        const title = request.generatedTitle !== undefined
+            && (request.title === previous || receipt?.generatedTitles.includes(request.title))
+            ? request.generatedTitle : request.title;
+        // A prefix (including the historic Skill notice) is not ownership proof.
+        if (current !== previous && !(request.newThread && current === null && receipt === undefined)) {
+            const pollution = [current, thread.preview].some(value => typeof value === "string"
+                && (value.startsWith("Yui Host checked current Skills;")
+                    || value.startsWith("Yui Session Manifest:")
+                    || value.startsWith("<!-- yui:skills-checked -->")));
+            return result("preserved", pollution
+                ? "Historical Skill-prefix title/preview candidate; no native ownership proof, so no repair submitted."
+                : "Native name has no matching generated-title provenance; left unchanged.");
+        }
+        if (current === title)
+            return result("confirmed", "Existing generated title observed.", { title, ...(receipt === undefined ? {} : { attemptId: receipt.attemptId }) });
+        receipt = {
+            schemaVersion: 1, identity: request.identity, accountHome: request.accountHome,
+            attemptId: randomUUID(), requestedTitle: title, expectedTitle: current,
+            status: "submitted", generatedTitles: receipt?.generatedTitles ?? (previous === undefined ? [] : [previous])
+        };
+        // Durable intent precedes the only mutation. A crash anywhere after this
+        // write is an unknown effect, never permission to resubmit.
+        await saveReceipt(directory, receipt);
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed before mutation.");
+        // Persistence may yield to a user's edit. Recheck immediately before
+        // sending; the native API has no expected-name compare-and-swap.
+        const prewrite = await client.request("thread/read", { threadId: request.identity.threadId, includeTurns: false });
+        const fresh = prewrite.thread;
+        if (fresh?.id !== request.identity.threadId || (fresh.name ?? null) !== current) {
+            await saveReceipt(directory, { ...receipt, status: "preserved" });
+            return result("preserved", "Native name changed before submission; no rename sent.", { attemptId: receipt.attemptId });
+        }
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed before mutation.");
+        submitted = true;
+        await client.request("thread/name/set", { threadId: request.identity.threadId, name: title });
+        const confirmation = await client.request("thread/read", { threadId: request.identity.threadId, includeTurns: false });
+        const observed = confirmation.thread;
+        if (observed?.id !== request.identity.threadId || observed.name !== title) {
+            throw new Error("Title mutation has no matching readback; preserve unknown effect.");
+        }
+        receipt = { ...receipt, status: "confirmed",
+            generatedTitles: [...new Set([...receipt.generatedTitles, title])] };
+        await saveReceipt(directory, receipt);
+        return result("confirmed", "Native title acknowledged and read back.", {
+            attemptId: receipt.attemptId, title, receiptPath: join(directory, "receipt.json")
+        });
+    }
+    catch (error) {
+        if (submitted && receipt !== undefined) {
+            await saveReceipt(directory, { ...receipt, status: "unknown" }).catch(() => { });
+        }
+        return result(submitted ? "unknown" : "not-submitted", error instanceof Error ? error.message : String(error), receipt === undefined ? {} : { attemptId: receipt.attemptId, receiptPath: join(directory, "receipt.json") });
+    }
+    finally {
+        request.signal?.removeEventListener("abort", cancel);
+        client?.close();
+        await client?.exited;
+        if (locked)
+            await rmdir(join(directory, "writing")).catch(() => { });
+    }
+}
+/** Use task-161's independent lifecycle-check lane without changing its FSM.
+ * One trigger per attachment; receipt fencing handles reconnects/other Hosts. */
+export function createNativeTitleSync(payload, threadId, accountHome, report) {
+    let triggered = false;
+    const checks = createNonBlockingChecks([{
+            id: "native-title",
+            async run(_observation, signal) {
+                const env = payload.environment;
+                const title = payload.providerControl?.sessionTitle ?? env.YUI_SESSION_TITLE ?? env.YUI_NATIVE_TITLE_PROPOSAL;
+                if (title === undefined)
+                    return;
+                const scope = env.YUI_SESSION_SCOPE;
+                if (!accountHome || !env.YUI_HOME || !env.YUI_ROLE || !env.YUI_AGENT_ID
+                    || !["task", "global"].includes(scope ?? "") || scope === "task" && !env.YUI_TASK_ID
+                    || !env.YUI_AGENT_BASE_ARGS) {
+                    report({ threadId, status: "not-submitted", detail: "Native title synchronization lacks an exact local account/launch identity." });
+                    return;
+                }
+                const baseArgs = JSON.parse(env.YUI_AGENT_BASE_ARGS);
+                if (!Array.isArray(baseArgs) || baseArgs.some(value => typeof value !== "string")) {
+                    throw new Error("Invalid native naming executable arguments.");
+                }
+                const observed = await synchronizeNativeTitle({
+                    home: env.YUI_HOME, identity: {
+                        scope: scope,
+                        ...(scope === "task" ? { taskId: env.YUI_TASK_ID } : {}),
+                        roleName: env.YUI_ROLE, agentId: env.YUI_AGENT_ID, threadId
+                    },
+                    accountHome, command: payload.command, baseArgs,
+                    environment: env, title,
+                    ...(env.YUI_NATIVE_TITLE_PROPOSAL === undefined ? {} : { generatedTitle: env.YUI_NATIVE_TITLE_PROPOSAL }),
+                    ...(env.YUI_NATIVE_TITLE_LOCAL === undefined ? {} : { localTitle: env.YUI_NATIVE_TITLE_LOCAL }),
+                    newThread: payload.providerControl?.mode === "new"
+                        || payload.providerControl === undefined && env.YUI_NATIVE_SESSION_ID === undefined,
+                    ...(payload.providerControl?.previousSessionTitle === undefined ? {} : {
+                        previousTitle: payload.providerControl.previousSessionTitle
+                    }),
+                    signal
+                });
+                if (!signal.aborted)
+                    report(observed);
+            }
+        }], error => report({ threadId, status: "not-submitted", detail: String(error) }));
+    return {
+        notify() { if (!triggered) {
+            triggered = true;
+            checks.notify(true);
+        } },
+        close() { checks.close(); }
+    };
+}
+async function saveReceipt(directory, receipt) {
+    const temporary = join(directory, `${receipt.attemptId}-${receipt.status}.tmp`);
+    const file = await open(temporary, "wx", 0o600);
+    try {
+        await file.writeFile(JSON.stringify(receipt) + "\n");
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    await rename(temporary, join(directory, "receipt.json"));
+    const parent = await open(directory, "r");
+    try {
+        await parent.sync();
+    }
+    finally {
+        await parent.close();
+    }
+}

package/dist/runtime/platform.js

@@ -0,0 +1,11 @@
+/** Check the Node runtime's exact OS/architecture before loading the control plane. */
+export function unsupportedPlatformMessage(platform = process.platform, architecture = process.arch) {
+    const target = `${platform}-${architecture}`;
+    if (target === "linux-x64" || target === "darwin-arm64")
+        return undefined;
+    return `Unsupported Yui runtime: ${target}. `
+        + "Yui supports Linux x64 (glibc) and macOS Apple Silicon with native arm64 Node.js."
+        + (target === "darwin-x64"
+            ? " macOS Intel is no longer supported; Intel Macs must remain on Yui 2.23.0."
+            : "");
+}