@zq-silk/yui 1.0.1 → 1.1.2

package/README.md

@@ -5,7 +5,7 @@
 [![Core CI](https://github.com/zhangqian-silk/yui/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/zhangqian-silk/yui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 ![Node](https://img.shields.io/badge/node-20%20%7C%2022%20%7C%2024-brightgreen.svg)
-![Platform](https://img.shields.io/badge/platform-Linux%20x64%20%28glibc%29-blue.svg)
+![Platform](https://img.shields.io/badge/platform-Linux%20x64%20%28glibc%29%20%7C%20macOS%20x64%2Farm64-blue.svg)
 [![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](#contributing)
 
 Give your Agents work to carry forward, not just another chat to answer.
@@ -34,7 +34,7 @@ not from terminal windows you juggle or details you have to remember.
 - **Isolated by default** — repository work happens in managed Git worktrees;
   the stable checkout stays read-only.
 
-> **Status:** 1.0.0, with a clean storage 1.0 baseline. Default updates
+> **Status:** 1.1.0, with storage 1.1 and a declared upgrade from the 1.0 baseline. Default updates
 > support only declared minor upgrades within one storage major. Homes with
 > any other storage identity are rejected without mutation.
 
@@ -42,10 +42,15 @@ not from terminal windows you juggle or details you have to remember.
 
 ## Quick start
 
-You need Linux x64 with glibc, Git, tmux, and Node.js `^20.17.0`, `^22.9.0` or
-`^24.0.0`. For the simplest setup, have Codex CLI or Claude Code CLI installed
-and ready to use with your own account. Yui coordinates those Agents; it does
-not supply model access.
+You need Linux x64 (glibc) or macOS (x64 or Apple Silicon), Git, tmux, and
+Node.js `^20.17.0`, `^22.9.0`, `^24.0.0` or `^26.0.0`. On macOS install tmux with
+`brew install tmux`. For the simplest setup, have Codex CLI or Claude Code CLI
+installed and ready to use with your own account. Yui coordinates those
+Agents; it does not supply model access.
+
+The npm package includes prebuilt Yui helpers for Linux x64, Mac Intel and
+Apple Silicon. The same package is tested on all three platforms before
+publication; Yui selects only the helper for the running platform.
 
 For Claude, Yui passes through your authentication environment and native
 configuration directory; Claude selects the API key or login method using its
@@ -73,10 +78,18 @@ Or ask the coding Agent you already use:
 > Ask me about any account or setup choices you need.
 
 Setup establishes the Operator—the Agent you talk to—and a default Task Leader,
-then starts the local Controller. You can begin with those two roles and
+then starts the local Controller and any Codex shared daemon those active Roles need. You can begin with those two roles and
 configure Workers or Reviewers later. If your Agent cannot operate an interactive
 terminal, run setup yourself; it only handles the initial configuration.
 
+On later launches, run `yui start`. It starts the Controller if needed and prepares
+the Codex shared daemon only when an active Role uses Codex. On macOS, if Codex
+App is installed, it also configures future App launches to use that daemon.
+Open App after `yui start`; if App was already open, quit and reopen it when Yui
+asks. `yui doctor` checks the live App connection. `yui controller start` starts
+only the Controller. On Linux, the Codex daemon runs without App setup; with no
+active Codex Role, neither platform starts a Codex daemon.
+
 ### 3. Start a conversation
 
 ```sh
@@ -141,6 +154,10 @@ For a visual overview, run `yui web` in another terminal. The local Web view
 shows the same tasks and pending questions and lets you send messages, answer
 questions and explicitly queue, steer or interrupt Task input. These authenticated
 Task controls use the same operations as the CLI; Web is not a separate task system.
+The task list remains at the left, task details occupy the primary reading area,
+and recorded Task messages live in a secondary discussion pane. You can resize,
+swap or hide that pane; on narrow screens it opens over the detail. Native Sessions
+remain separate from recorded Task messages.
 The detail prioritizes user input, native Session activity, Task progress and key
 conclusions; fixed file results and delivery evidence open on demand. See
 [attention and progress](docs/observability/README.md#web-attention-and-progress).
@@ -378,8 +395,9 @@ follow our [Code of Conduct](CODE_OF_CONDUCT.md). In short: in a source
 checkout, run `npm ci` and `npm test`. Read
 `.agents/skills/develop-yui/SKILL.md` and the
 [verification policy](docs/testing/verification-levels.md).
-Source builds also need a Linux C compiler and static libc development libraries
-for the Claude process owner. Published packages include that executable;
+Source builds also need a C compiler. Linux requires static libc development
+libraries for the Claude process owner; macOS builds the owner and a libproc
+process identity helper with the system SDK. Published packages include these executables;
 npm users do not need to compile it.
 
 To exercise your checkout, run `make install-local`, then use the absolute

package/dist/cli/commandCatalog.js

@@ -302,13 +302,13 @@ const taskChildren = [
         children: [
             {
                 name: "request",
-                summary: "Record an Activation request. empty adds no extra environment (bound Projects still get managed worktrees); scratch creates a Task directory; local requires a registered Resource and grant, not a Project ID.",
+                summary: "Record an Activation request. Every active Task gets a managed main workspace. empty adds no execution environment; scratch adopts a separate scratch environment; local requires a registered Resource and grant, not a Project ID.",
                 usage: "yui task activation request <task> --request-id <id> "
                     + "--environment <empty|scratch|local:<resource>:<read|write>>",
                 options: ["--request-id", "--environment"],
                 examples: [
                     "yui task activation request <task> --request-id start-1 --environment empty",
-                    "yui task activation request <gitless-task> --request-id start-1 --environment scratch"
+                    "yui task activation request <task> --request-id start-1 --environment scratch"
                 ]
             },
             {
@@ -1100,10 +1100,10 @@ export const ROOT_COMMAND = buildNode({
     name: "yui",
     summary: "Coordinate durable, isolated Agent work.",
     usage: "yui [--json] <command>",
-    examples: ["yui setup", "yui operator enter", "yui config show", "yui task list"],
+    examples: ["yui setup", "yui start", "yui operator enter", "yui task list"],
     sections: [
         { id: "general", title: "General", entries: [
-                "help", "version", "update", "upgrade", "setup", "doctor"
+                "help", "version", "update", "upgrade", "setup", "start", "doctor"
             ] },
         { id: "workflow", title: "Workflow", entries: ["operator", "role", "project", "task"] },
         { id: "configuration", title: "Configuration", entries: ["config"] },
@@ -1159,6 +1159,7 @@ export const ROOT_COMMAND = buildNode({
             summary: "Initialize the minimum Operator and Leader configuration required to execute Tasks.",
             examples: "yui setup"
         },
+        { name: "start", summary: "Start the Controller and Codex shared runtime needed by active Roles." },
         { name: "doctor", summary: "Check Yui dependencies and file state." },
         {
             name: "web",
@@ -1172,7 +1173,7 @@ export const ROOT_COMMAND = buildNode({
             sections: [{
                     id: "lifecycle",
                     title: "Commands",
-                    entries: ["status", "cleanup", "identity", "live-identity", "stop", "restart"]
+                    entries: ["status", "cleanup", "identity", "live-identity", "start", "stop", "restart"]
                 }],
             children: [
                 {
@@ -1197,6 +1198,7 @@ export const ROOT_COMMAND = buildNode({
                     summary: "Read the authenticated live Controller runtime identity.",
                     hidden: true
                 },
+                { name: "start", summary: "Start the Controller for this Home without preparing Agent runtimes." },
                 { name: "stop", summary: "Stop the Controller." },
                 { name: "restart", summary: "Restart internal services without stopping tmux sessions." }
             ]

package/dist/cli/invocationAuthority.js

@@ -28,6 +28,10 @@ export function assertConfigurationAuthority(args, store, env) {
 export function assertTaskInvocationScope(args, env) {
     if (env.YUI_SESSION_SCOPE !== "task")
         return;
+    if (["setup", "start"].includes(args[0] ?? "")
+        || (args[0] === "controller" && args[1] === "start")) {
+        throw usageError("Starting Home services requires the user or current Operator, not a Task Assignment.");
+    }
     if (args[0] === "jobs" || (args[0] === "task" && ["create", "overlap"].includes(args[1] ?? ""))) {
         throw usageError("This global operation is outside the caller's Task; use its scoped Context.");
     }

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
@@ -96,6 +96,8 @@ import { createTaskFinalReviewContract, extractTaskFinalReviewRequest } from "./
 import { resolveRecordedTaskFinalReviewContract } from "./review/taskFinalReviewContractResolution.js";
 import { AGENT_HOST_CONTROL_PROTOCOL, foldInterruptLiveReceipt, foldSteerLiveReceipt, inspectAgentHost, runAgentHost, sendAgentHostAuthorityControl, sendAgentHostCancelControl, sendAgentHostSteerControl } from "./runtime/agentHost.js";
 import { unknownAgentRunConfiguration } from "./runtime/agentRunConfiguration.js";
+import { isCodexInspectionPermissionError } from "./runtime/codexSharedDaemon.js";
+import { prepareLocalCodexStartup } from "./runtime/localStartup.js";
 import { requireManagedTaskCaller, resolveManagedTaskReader } from "./runtime/managedCaller.js";
 import { assertRuntimeCoherence } from "./runtime/runtimeCoherence.js";
 import { runSetupCommand, validateSetupInvocation } from "./setup/setupCommand.js";
@@ -141,6 +143,12 @@ void main().catch((error) => {
 });
 function runtimeFailureMessage(error) {
     const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof ControllerClientError
+        && ["CONTROLLER_NOT_RUNNING", "CONTROLLER_UNAVAILABLE", "CONTROLLER_DISCOVERY_INVALID"].includes(error.code)) {
+        return `${message} Run \`yui doctor\` with this Session's YUI_HOME and CLI; `
+            + "if the Controller is stopped, run `yui start`; if its process is present but unreachable, "
+            + "inspect it before `yui controller restart`. The Operator or user can perform recovery.";
+    }
     if (!(error instanceof SqliteSchemaError))
         return message;
     try {
@@ -302,6 +310,13 @@ export async function main() {
         // detached per-Home Controller even when setup began with no Controller;
         // read-only commands and failed setup still remain non-starting paths.
         await ensureFileTaskController(home, { environment: process.env });
+        const setupStore = openCurrentTaskStore(home);
+        try {
+            await prepareCodexForCurrentRoles(setupStore, home);
+        }
+        finally {
+            setupStore.close();
+        }
         const refresh = await refreshRunningFileTaskControllerEnvironment(home, openCurrentTaskStore(home), process.env);
         emit(withControllerRefreshWarning(output, refresh, "Agent environment"));
         return;
@@ -310,10 +325,10 @@ export async function main() {
         const doctorArgs = args.slice(1);
         if (doctorArgs.length !== 0) {
             // Preserve the usage error for stray operands (parity with text mode).
-            runDoctorCommand(doctorArgs, process.env, new NodeCommandExecutor());
+            await runDoctorCommand(doctorArgs, process.env, new NodeCommandExecutor());
             return;
         }
-        const report = buildDoctorReport(process.env, new NodeCommandExecutor());
+        const report = await buildDoctorReport(process.env, new NodeCommandExecutor());
         if (jsonOutput) {
             // Machine-readable result: the full checks array + a storage-health verdict
             // the update post-verify parses (P1-3). Exit non-zero when storage is not
@@ -328,6 +343,47 @@ export async function main() {
         emit(renderDoctor(report.checks, report.review));
         return;
     }
+    if (args[0] === "start") {
+        if (args.length !== 1)
+            throw usageError("Start usage: yui start.");
+        validateCurrentTaskStore(home);
+        const startupStore = openCurrentTaskStore(home);
+        try {
+            assertHomeStartupAuthority(startupStore);
+            const controller = await ensureFileTaskController(home, { environment: process.env });
+            let codex;
+            try {
+                codex = await prepareLocalCodexStartup(startupStore, home, process.env);
+            }
+            catch (error) {
+                throw runtimeError(`Controller is ready, but Codex shared startup failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const lines = ["Yui Controller is ready."];
+            if (codex.daemons.length === 0)
+                lines.push("No active Role needs Codex; no Codex daemon was started.");
+            else
+                for (const daemon of codex.daemons) {
+                    lines.push(`Codex shared daemon ${daemon.started ? "started" : "ready"}: ${daemon.socketPath}`);
+                }
+            if (codex.app === "restart-required") {
+                lines.push("Codex App is running with an older connection. Quit and reopen it to use Yui sessions.");
+            }
+            else if (codex.app === "ready") {
+                lines.push("Codex App launch is configured for the shared daemon. Use yui doctor to verify its live connection.");
+            }
+            else if (codex.app === "multiple-homes") {
+                lines.push("Active Codex Roles use multiple Codex homes; App sharing needs one selected Home.");
+            }
+            else if (codex.app === "not-detected") {
+                lines.push("Codex App was not detected; the shared daemon is ready for Codex CLI sessions.");
+            }
+            emit(lines.join("\n"), false, { controller, codex });
+        }
+        finally {
+            startupStore.close();
+        }
+        return;
+    }
     if (args[0] === "execution") {
         // Issue 11 read-only audit: opens the Home read-only, never writes state,
         // never wakes a Leader.
@@ -406,6 +462,19 @@ export async function main() {
     }
     if (args[0] === "controller") {
         const method = args[1];
+        if (method === "start" && args.length === 2) {
+            validateCurrentTaskStore(home);
+            const startupStore = openCurrentTaskStore(home);
+            try {
+                assertHomeStartupAuthority(startupStore);
+            }
+            finally {
+                startupStore.close();
+            }
+            const result = await ensureFileTaskController(home, { environment: process.env });
+            emit("Controller is ready.", false, result);
+            return;
+        }
         if (method === "live-identity" && args.length === 2) {
             try {
                 const identity = await callController(home, "controller.identity", {});
@@ -534,7 +603,7 @@ export async function main() {
         }
         if ((method !== "stop" && method !== "restart") || args.length !== 2) {
             throw usageError("Controller usage: yui controller status [--all] [--verbose] | "
-                + "cleanup [--all] | stop | restart.");
+                + "cleanup [--all] | start | stop | restart.");
         }
         // Stopping an exactly identified Controller is a recovery operation:
         // malformed domain records must not prevent quiescing its process.
@@ -786,6 +855,7 @@ export async function main() {
             if (result.kind !== "enter") {
                 throw new Error("Session commands cannot perform a live input control.");
             }
+            await prepareInteractiveCodexApp(result.role.activeAgentId, store, home);
             await ensureFileTaskController(home, { environment: process.env });
             await runtime.prepareGlobalRoleEnter(result.role.name);
             tmux.attachRole("operator", result.role.name, "auto");
@@ -924,6 +994,9 @@ export async function main() {
             if (resolved[1] === "enter") {
                 if (resolved.length !== 2)
                     throw usageError("Operator enter usage: yui operator enter.");
+                const role = store.getGlobalRole("operator");
+                if (role !== null)
+                    await prepareInteractiveCodexApp(role.activeAgentId, store, home);
                 await ensureFileTaskController(home, { environment: process.env });
                 await runtime.prepareGlobalRoleEnter("operator");
                 tmux.attachRole("operator", "operator", "auto");
@@ -2010,7 +2083,16 @@ function assertManagedSessionManifest(home, scope) {
         throw new Error("Managed Task invocation does not match its Session Manifest owner.");
     }
     const expectedPath = resolve(home, "runtime", "session-manifests", `${manifest.digest}.json`);
-    if (resolve(manifestPath) !== expectedPath) {
+    // YUI_HOME is canonicalized (its macOS /var -> /private/var prefix is a
+    // system symlink), so compare the manifest in the same canonical space.
+    let canonicalManifestPath;
+    try {
+        canonicalManifestPath = realpathSync(resolve(manifestPath));
+    }
+    catch {
+        canonicalManifestPath = resolve(manifestPath);
+    }
+    if (canonicalManifestPath !== expectedPath) {
         throw new Error("Managed Session Manifest path is outside this YUI_HOME.");
     }
     return manifest;
@@ -2388,6 +2470,7 @@ async function executeOperatorSessionControl(control, home, store, runtime, tmux
         && control.targetAgentId === active?.agentId
         && active !== undefined
         && operatorSessionRef(active) === control.ref) {
+        await prepareInteractiveCodexApp(control.targetAgentId, store, home);
         tmux.attachRole("operator", "operator", "auto");
         return;
     }
@@ -2431,6 +2514,7 @@ async function executeOperatorSessionControl(control, home, store, runtime, tmux
     finally {
         handle.close();
     }
+    await prepareInteractiveCodexApp(control.targetAgentId, store, home);
     await ensureFileTaskController(home, { environment: process.env });
     if (paneRunning
         || (active !== undefined
@@ -2444,6 +2528,47 @@ async function executeOperatorSessionControl(control, home, store, runtime, tmux
     await runtime.prepareGlobalRoleEnter(role.name);
     tmux.attachRole("operator", role.name, "auto");
 }
+async function prepareInteractiveCodexApp(agentId, store, home) {
+    await prepareCodexForCurrentRoles(store, home, agentId);
+}
+async function prepareCodexForCurrentRoles(store, home, targetAgentId) {
+    try {
+        const result = await prepareLocalCodexStartup(store, home, process.env, targetAgentId);
+        if (result.app === "restart-required") {
+            codexAppNotice("Codex App is already running without the current Yui shared app-server. "
+                + "Quit and reopen Codex App to see and continue Yui sessions.", "Reopen Codex App to connect to Yui sessions.");
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const permissionDenied = isCodexInspectionPermissionError(error);
+        codexAppNotice(`${permissionDenied
+            ? "Codex sharing could not be prepared or verified from this process"
+            : "Codex shared runtime could not be prepared"}: ${detail}`, permissionDenied
+            ? "macOS denied access while preparing Codex sharing; its state is unverified. See the Yui terminal."
+            : "Codex shared runtime could not be prepared; see the Yui terminal.");
+    }
+}
+function assertHomeStartupAuthority(store) {
+    if (process.env.YUI_SESSION_SCOPE === undefined && process.env.YUI_ROLE === undefined
+        && process.env.YUI_AGENT_ID === undefined && process.env.YUI_NATIVE_SESSION_ID === undefined)
+        return;
+    if (process.env.YUI_SESSION_SCOPE !== "global" || process.env.YUI_ROLE !== "operator") {
+        throw usageError("Starting Home services requires the user or current Operator.");
+    }
+    requireManagedGlobalCaller(store, process.env);
+}
+function codexAppNotice(message, notification) {
+    process.stderr.write(`\nYui: ${message}\n`);
+    if (process.platform !== "darwin")
+        return;
+    // The native TUI clears terminal output on attach, so keep the actionable
+    // warning visible in Notification Center without interrupting Yui startup.
+    spawnSync("/usr/bin/osascript", [
+        "-e",
+        `display notification "${notification}" with title "Yui"`
+    ], { stdio: "ignore", timeout: 3_000 });
+}
 function renderControllerResult(method, value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return JSON.stringify(value);

package/dist/commands/releaseCommands.js

@@ -6,8 +6,8 @@ import { spawn, spawnSync } from "node:child_process";
 import { chmodSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { callController, ControllerClientError } from "../core/controllerClient.js";
-import { readLinuxProcessStartIdentity } from "../controller/domainIdentity.js";
-import { activateRelease } from "../release/releaseHandover.js";
+import { processGenerationIsLive } from "../core/fileLockOwner.js";
+import { activateRelease, ControllerStartUnconfirmedError } from "../release/releaseHandover.js";
 import { assertReleaseIsNotWorktreeOrLinked, detectRunningRelease, readActiveReleasePointer, readReleaseManifest, readSmokeReceipt, releasesDirectory, releaseDirectoryFor, verifyReleaseIntegrity, writeSmokeReceipt } from "../release/runtimeRelease.js";
 /**
  * Installs a runtime package directory into the Home's immutable release
@@ -312,31 +312,37 @@ export function createReleaseActivatePorts(overrides = {}) {
         }),
         startControllerFromRelease: overrides.startControllerFromRelease
             ?? (async (home, releaseDir) => {
-                spawnDetachedController(home, releaseDir, {});
+                const pid = spawnDetachedController(home, releaseDir, {});
                 const deadline = Date.now() + 30_000;
-                const expectedBuildId = readReleaseManifest(releaseDir).buildId;
-                for (;;) {
-                    try {
-                        const status = await callController(home, "controller.status", {});
-                        if (typeof status === "object" && status !== null && status.running === true) {
-                            // Verify the running Controller is the target release, not a
-                            // stale/previous Controller that happened to answer.
-                            const identity = await callController(home, "controller.identity", {});
-                            if (identity.buildId !== expectedBuildId) {
-                                throw new Error(`Controller is running build ${String(identity.buildId)}, `
-                                    + `not the target release build ${expectedBuildId}.`);
+                try {
+                    const expectedBuildId = readReleaseManifest(releaseDir).buildId;
+                    for (;;) {
+                        try {
+                            const status = await callController(home, "controller.status", {});
+                            if (typeof status === "object" && status !== null
+                                && status.running === true) {
+                                // Verify the running Controller is the target release, not a
+                                // stale/previous Controller that happened to answer.
+                                const identity = await callController(home, "controller.identity", {});
+                                if (identity.buildId !== expectedBuildId) {
+                                    throw new Error(`Controller is running build ${String(identity.buildId)}, `
+                                        + `not the target release build ${expectedBuildId}.`);
+                                }
+                                return;
                             }
-                            return;
                         }
+                        catch (error) {
+                            if (!isUnavailableError(error))
+                                throw error;
+                        }
+                        if (Date.now() >= deadline) {
+                            throw new Error("Controller did not become ready within 30000 ms.");
+                        }
+                        await sleep(100);
                     }
-                    catch (error) {
-                        if (!isUnavailableError(error))
-                            throw error;
-                    }
-                    if (Date.now() >= deadline) {
-                        throw new Error("Controller did not become ready within 30000 ms.");
-                    }
-                    await sleep(100);
+                }
+                catch (error) {
+                    throw new ControllerStartUnconfirmedError(pid, `Startup process may still be running: ${messageOf(error)}`);
                 }
             }),
         runPreflight: overrides.runPreflight ?? ((releaseDir, home) => {
@@ -364,7 +370,7 @@ export function createReleaseActivatePorts(overrides = {}) {
             }
         }),
         killOwnedProcess: overrides.killOwnedProcess ?? ((owner) => {
-            if (readLinuxProcessStartIdentity(owner.pid) !== owner.processStartIdentity)
+            if (!processGenerationIsLive(owner.pid, owner.processStartIdentity))
                 return;
             process.kill(owner.pid, "SIGTERM");
         }),
@@ -404,6 +410,9 @@ function spawnDetachedController(home, releaseDir, extraEnv) {
     Object.assign(environment, extraEnv);
     const child = spawn(process.execPath, [join(releaseDir, "dist", "controller", "controllerMain.js")], { env: environment, detached: true, stdio: "ignore" });
     child.unref();
+    if (child.pid === undefined)
+        throw new Error("Controller spawn did not return a PID.");
+    return child.pid;
 }
 function runInstallSmoke(releaseDir, expectedVersion) {
     const cli = join(releaseDir, "dist", "cli.js");

package/dist/commands/taskCommands.js

@@ -56,7 +56,7 @@ import { archiveSettlementChecks } from "../task/archivePreflight.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { assertDraftTaskExecutionFree, validateDraftWorkItemEdit } from "../task/draftPlan.js";
 import { assertTaskRemoteDeliveryProof, projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
-import { addTaskProjectBinding, archiveTask, completeTask, createTask, reopenTask, retireTask, taskOwnsManagedWorkspace, updateTaskMetadata } from "../task/task.js";
+import { addTaskProjectBinding, archiveTask, completeTask, createTask, reopenTask, retireTask, updateTaskMetadata } from "../task/task.js";
 import { recordTaskActivationRequestInTransaction, taskActivationOperationRef } from "../task/taskActivationService.js";
 import { assertTaskDeliveryAuthority, assertTaskInputControlAuthority } from "../task/taskAuthority.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
@@ -580,8 +580,8 @@ function routeUserSubmission(tx, task, actor, body, intent, now, submissionKey,
         enteredPlanning,
         activation,
         executionEnabled: task.executionGate.state === "enabled",
-        // develop adopts no extra resource by guessing: the workspace is still built
-        // from the Task's own Project bindings when it activates (§2.3).
+        // develop adopts no extra environment by guessing; activation always
+        // prepares the Task's managed main workspace (§2.3).
         developEnvironmentPlan: { kind: "empty" }
     });
     let queuedForLeader = false;
@@ -1015,22 +1015,11 @@ function activateTaskCommand(args, store, options) {
                 || activation.path !== task.cwd) {
                 throw usageError(`Task workspace activation proof does not match ${task.id}.`);
             }
-            // An empty environment plan over no bound Project is a legal Task shape,
-            // so the proof of adoption is the *absence* of a workspace rather than a
-            // ManagedWorkspace record. Demanding one here would have forced every
-            // such activation to create a worktree purely to satisfy this check.
-            if (taskOwnsManagedWorkspace(task)) {
-                if (workspace === null
-                    || workspace.owner.type !== "task"
-                    || workspace.owner.taskId !== task.id
-                    || workspace.root !== task.cwd) {
-                    throw usageError(`Task workspace activation proof does not match ${task.id}.`);
-                }
-            }
-            else if (workspace !== null
-                || task.workspaceIdentity !== undefined
-                || activation.path !== undefined) {
-                throw usageError(`Workspace-free Task activation proof claims a workspace: ${task.id}.`);
+            if (workspace === null
+                || workspace.owner.type !== "task"
+                || workspace.owner.taskId !== task.id
+                || workspace.root !== task.cwd) {
+                throw usageError(`Task workspace activation proof does not match ${task.id}.`);
             }
             return { task, changed: activation.changed };
         }
@@ -3469,13 +3458,13 @@ function dispatchWork(args, store, options) {
             throw usageError(`Work Item ${item.id} retains open ExecutionGroup ${currentGroup.id}; retry or settle its exact Lane AgentRuns.`);
         }
         assertWorkItemDependenciesCompletedForCommand(tx, item);
-        const leaderOwned = item.assignee === "leader";
-        const workspace = leaderOwned
+        const usesTaskMain = item.assignee === "leader" || task.projectBindings.length === 0;
+        const workspace = usesTaskMain
             ? tx.getTaskWorkspace(task.id)
             : tx.getWorkItemWorkspace(task.id, item.id);
         if (workspace === null) {
-            throw usageError(leaderOwned
-                ? `Leader-owned Work Item ${item.id} requires the Task main workspace.`
+            throw usageError(usesTaskMain
+                ? `Work Item ${item.id} requires the Task main workspace.`
                 : `Work Item ${item.id} must be isolated with its approved Project scope before dispatch.`);
         }
         const visible = workspace.entries.map(({ projectId }) => projectId).sort();
@@ -5063,7 +5052,8 @@ function retryRunOperation(args, store, options) {
             const storedMainWorkspace = previous.workspace === undefined
                 ? null
                 : tx.getManagedWorkspace(previous.workspace.owner);
-            const currentMainWorkspace = retryItem?.assignee === "leader"
+            const currentMainWorkspace = retryItem !== null
+                && (retryItem.assignee === "leader" || task.projectBindings.length === 0)
                 ? tx.getTaskWorkspace(task.id)
                 : retryItem === null
                     ? null
@@ -5080,7 +5070,8 @@ function retryRunOperation(args, store, options) {
             const storedDirectWorkspace = previous.workspace === undefined
                 ? null
                 : tx.getManagedWorkspace(previous.workspace.owner);
-            const currentDirectWorkspace = retryItem?.assignee === "leader"
+            const currentDirectWorkspace = retryItem !== null
+                && (retryItem.assignee === "leader" || task.projectBindings.length === 0)
                 ? tx.getTaskWorkspace(task.id)
                 : retryItem === null
                     ? null

package/dist/commands/taskFactCommands.js

@@ -18,14 +18,18 @@ export function taskBriefCommand(args, store, options) {
             return output(`Task ${task.id} has no brief.\n`, { taskId: task.id, brief: null });
         }
         const timeZone = store.getConfig().timeZone;
+        const working = task.status === "draft" || task.status === "active";
         return output([
             `Task: ${task.id}`,
+            `Task status: ${task.status}`,
+            ...(task.completionSummary === undefined ? [] : [`Recorded completion: ${task.completionSummary}`]),
+            ...(task.retirementSummary === undefined ? [] : [`Recorded retirement: ${task.retirementSummary}`]),
             `Objective: ${brief.objective}`,
             `Boundaries:`,
             ...(brief.boundaries.length === 0 ? ["  (none)"] : brief.boundaries.map((b) => `  - ${b}`)),
             `Technical approach: ${brief.technicalApproach || "(not defined)"}`,
-            `Current focus: ${brief.currentFocus}`,
-            `Leader summary: ${brief.leaderSummary}`,
+            `${working ? "Current focus" : "Last working focus"}: ${brief.currentFocus}`,
+            `${working ? "Leader summary" : "Last working summary"}: ${brief.leaderSummary}`,
             `Updated by: ${brief.updatedBy}`,
             `Updated at: ${presentTime(brief.updatedAt, timeZone)}`
         ].join("\n").concat("\n"), { taskId: task.id, brief });

package/dist/controller/clientRuntime.js

@@ -42,7 +42,10 @@ export async function assertFileTaskControllerStorageCompatible(home, options =
         if (isDefinitelyNotRunning(error))
             return;
         if (isUnavailable(error)) {
-            throw new Error("Controller compatibility could not be verified. Retry or run `yui controller restart`.", { cause: error });
+            throw new Error("Controller compatibility could not be verified before this command: "
+                + `${error instanceof Error ? error.message : String(error)} `
+                + "Run `yui doctor` with this Session's YUI_HOME and CLI; ask the Operator or user "
+                + "to restore it with `yui start` or `yui controller restart` as diagnosed.", { cause: error });
         }
         throw error;
     }
@@ -88,7 +91,9 @@ export async function ensureFileTaskController(home, options = {}) {
             if (Date.now() >= deadline) {
                 throw new Error(`Controller did not become ready within ${timeoutMs} ms.`
                     + (startupPid === undefined ? "" : ` Startup PID: ${startupPid}.`)
-                    + " Read current process state before retrying; timeout does not prove it stopped.", { cause: error });
+                    + " Read current process state before retrying; timeout does not prove it stopped."
+                    + " Run `yui doctor` with this Session's YUI_HOME and CLI, then ask the Operator "
+                    + "or user to restore the Controller if needed.", { cause: error });
             }
             await delay(pollMs);
         }

package/dist/controller/domainIdentity.js

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { chmodSync, closeSync, openSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { currentProcessStartIdentity, readProcessStartIdentity } from "../core/fileLockOwner.js";
 /** Durable identity written by an isolated integration-test runtime. */
 export const CONTROLLER_DOMAIN_PATH = "runtime/domain.json";
 const EPHEMERAL_DOMAIN_LOCK_PATH = "runtime/domain.identity.lock";
@@ -21,9 +22,11 @@ export const EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES = [
 export function createEphemeralDomainIdentity(options) {
     const hostPid = options.hostPid ?? process.pid;
     const hostProcessStartIdentity = options.hostProcessStartIdentity
-        ?? readLinuxProcessStartIdentity(hostPid);
+        ?? (hostPid === process.pid
+            ? currentProcessStartIdentity()
+            : readProcessStartIdentity(hostPid));
     if (hostProcessStartIdentity === undefined) {
-        throw new Error(`Cannot read Linux process start identity for host PID ${hostPid}.`);
+        throw new Error(`Cannot read process start identity for host PID ${hostPid}.`);
     }
     const token = options.token ?? randomBytes(32).toString("hex");
     const identity = {
@@ -407,10 +410,7 @@ function acquireEphemeralDomainIdentityLock(home) {
     const directory = dirname(lockPath);
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     chmodSync(directory, 0o700);
-    const processStartIdentity = readLinuxProcessStartIdentity(process.pid);
-    if (processStartIdentity === undefined) {
-        throw new Error(`Cannot read Linux process start identity for lock owner PID ${process.pid}.`);
-    }
+    const processStartIdentity = currentProcessStartIdentity();
     const owner = {
         pid: process.pid,
         processStartIdentity,
@@ -469,7 +469,7 @@ function reclaimStaleEphemeralDomainLock(lockPath) {
     catch {
         return false;
     }
-    const currentStartIdentity = readLinuxProcessStartIdentity(owner.pid);
+    const currentStartIdentity = readProcessStartIdentity(owner.pid);
     if (currentStartIdentity !== undefined
         && currentStartIdentity === owner.processStartIdentity)
         return false;