@zq-silk/yui 1.0.1 → 1.1.2

package/dist/runtime/structuredProviderHost.js

@@ -1,7 +1,8 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { Duplex } from "node:stream";
-import { fileURLToPath } from "node:url";
+import { nativeExecutable } from "./nativeExecutable.js";
+import { startMissingCodexSharedDaemon } from "./codexSharedDaemon.js";
 import { ProviderConversationMissingError, ProviderDeliveryUnknownError, ProviderTurnBusyError, ProviderTurnRejectedError } from "./providerErrors.js";
 import WebSocket from "ws";
 import { YUI_VERSION } from "../version.js";
@@ -24,15 +25,32 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control === undefined) {
         throw new Error("Managed Agent Host launch requires Provider control metadata.");
     }
+    const mirror = input.mirrorOutput ?? defaultMirrorOutput;
+    if (control.adapterId === "codex" && control.transport === "codex-app-server-proxy") {
+        const proxy = await connectCodexProxy(payload, mirror, true);
+        try {
+            const opened = await CodexStructuredProviderSession.open(proxy.child, proxy.exit, proxy.processInstanceId, payload, control, proxy.channel, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, input.onDiagnostic, mirror);
+            return Object.freeze({
+                session: opened.session,
+                ...(opened.recoveredTerminal === undefined
+                    ? {}
+                    : { recoveredTerminal: opened.recoveredTerminal }),
+                goal: opened.goal
+            });
+        }
+        catch (error) {
+            terminateProcessGroup(proxy.child, "SIGTERM");
+            throw error;
+        }
+    }
     const ownedClaude = control.adapterId === "claude" && control.transport !== "acp-stdio";
-    const child = spawn(ownedClaude ? fileURLToPath(new URL("./claude-process-owner", import.meta.url)) : payload.command, ownedClaude ? [payload.command, ...payload.args] : [...payload.args], {
+    const child = spawn(ownedClaude ? nativeExecutable("claude-process-owner") : payload.command, ownedClaude ? [payload.command, ...payload.args] : [...payload.args], {
         cwd: payload.cwd,
         env: { ...payload.environment },
         stdio: ["pipe", "pipe", "pipe"],
         detached: true
     });
     const processInstanceId = randomUUID();
-    const mirror = input.mirrorOutput ?? defaultMirrorOutput;
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (chunk) => mirror("stderr", chunk));
     const exit = childExit(child, processInstanceId);
@@ -81,16 +99,6 @@ export async function startStructuredProviderSession(payload, input = {}) {
             }
             return Object.freeze({ session });
         }
-        if (control.adapterId === "codex") {
-            const opened = await CodexStructuredProviderSession.open(child, exit, processInstanceId, payload, control, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, input.onDiagnostic, mirror);
-            return Object.freeze({
-                session: opened.session,
-                ...(opened.recoveredTerminal === undefined
-                    ? {}
-                    : { recoveredTerminal: opened.recoveredTerminal }),
-                goal: opened.goal
-            });
-        }
         const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, input.onDiagnostic, mirror);
         if (isPostCreateOperatorTitle(payload)) {
             input.onDiagnostic?.({
@@ -120,20 +128,38 @@ function isPostCreateOperatorTitle(payload) {
  * Open an uninitialized, transparent connection for a native TUI. The TUI
  * owns its requests; Yui observes only its exact startup response.
  */
-export async function openCodexInteractiveConnection(launch) {
-    const child = spawn(launch.command, [...launch.args], {
-        cwd: launch.cwd,
-        env: { ...launch.environment },
-        stdio: ["pipe", "pipe", "pipe"],
-        detached: true
-    });
-    child.stderr.resume();
+export async function openCodexInteractiveConnection(launch, startMissingDaemon = false) {
+    return (await connectCodexProxy(launch, () => { }, startMissingDaemon)).channel;
+}
+async function connectCodexProxy(launch, mirror, startMissingDaemon) {
+    const attempt = async () => {
+        const child = spawn(launch.command, [...launch.args], {
+            cwd: launch.cwd,
+            env: { ...launch.environment },
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: true
+        });
+        const processInstanceId = randomUUID();
+        const exit = childExit(child, processInstanceId);
+        void exit.catch(() => { });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => mirror("stderr", chunk));
+        try {
+            const channel = await CodexProxyWebSocketChannel.connect(child, mirror);
+            return { child, channel, exit, processInstanceId };
+        }
+        catch (error) {
+            terminateProcessGroup(child, "SIGTERM");
+            throw error;
+        }
+    };
     try {
-        return await CodexProxyWebSocketChannel.connect(child, () => { });
+        return await attempt();
     }
     catch (error) {
-        terminateProcessGroup(child, "SIGTERM");
-        throw error;
+        if (!startMissingDaemon || !await startMissingCodexSharedDaemon(launch))
+            throw error;
+        return await attempt();
     }
 }
 class CodexProxyWebSocketChannel {
@@ -379,8 +405,7 @@ class CodexStructuredProviderSession {
         this.mirror = mirror;
         this.nativeAccountHome = nativeAccountHome;
     }
-    static async open(child, exit, processInstanceId, payload, control, onStarted, onTerminal, onGoal, onInput, onActivity, onDiagnostic, mirror) {
-        const channel = await CodexProxyWebSocketChannel.connect(child, mirror);
+    static async open(child, exit, processInstanceId, payload, control, channel, onStarted, onTerminal, onGoal, onInput, onActivity, onDiagnostic, mirror) {
         const openingMessages = [];
         const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
         const initialized = await channel.request("initialize", codexClientInitialization());

package/dist/scheduler/activeRoleRunDelivery.js

@@ -8,7 +8,6 @@ import { formatProviderDeliveryFailure, providerDeliveryFailureFacts, innermostC
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { formatRunReceiptId } from "../task/taskRecordReference.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { runInputEnvelope } from "../agentRun/agentRun.js";
 import { captureRoleRunDispatch } from "../coordination/workMailboxQueue.js";
 import { isSchedulerPlanningDraft, isSchedulerTaskWorkspaceReady, selectedActiveSchedulerTasks, selectedSchedulerRoles } from "./ports.js";
@@ -136,16 +135,8 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
             effective: run.effective,
             workspace: run.effective.workspace.root,
             ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
-            // A Task owning no workspace by design states that explicitly, so the
-            // launch does not read the absent workspace as a missing one and fail
-            // closed (S27). Two distinct cases qualify: a Task activated with an
-            // empty plan and binding no Project, and a Draft planning conversation,
-            // which may already bind a Project but has not activated, so no worktree
-            // exists or is owed yet. Declaring it free is what keeps the isolation
-            // fence honest instead of letting it fail on a workspace nobody promised.
-            ...(run.workspace === undefined
-                && (isSchedulerPlanningDraft(task, run.purpose)
-                    || !taskOwnsManagedWorkspace(task))
+            // Draft planning has no delivery workspace or worktree to isolate.
+            ...(run.workspace === undefined && isSchedulerPlanningDraft(task, run.purpose)
                 ? { workspaceFree: true }
                 : {}),
             mode,

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,7 +1,6 @@
 import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { hasImmediateWakeReason } from "./wakeReason.js";
 import { providerRetryPending } from "../runtime/providerRetry.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
@@ -78,7 +77,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 taskId: task.id, roleName: role.name, agentId: effective.agentId,
                 adapterId: effective.adapterId, effective, workspace: effective.workspace.root,
                 ...(role.managedWorkspace === undefined ? {} : { managedWorkspace: role.managedWorkspace }),
-                ...(task.status === "draft" || !taskOwnsManagedWorkspace(task)
+                ...(task.status === "draft"
                     ? { workspaceFree: true } : {}),
                 mode, ...(mode === "resume" && session?.nativeSessionId !== undefined
                     ? { nativeSessionId: session.nativeSessionId } : {})

package/dist/scheduler/ports.js

@@ -1,12 +1,8 @@
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 /**
  * Whether the Task's workspace state admits a launch.
  *
- * A Task that owns no managed workspace — activated with an empty environment
- * plan, binding no Project — is admitted with no workspace record at all. The
- * scheduler must not wait for a worktree that was deliberately never created.
- * Every Task that does own one still needs the full ownership proof.
+ * Active Tasks always need the full Task-owned workspace proof.
  *
  * A Draft planning conversation is a third case: the Task may already bind a
  * Project, yet activation has not run, so no worktree exists or is owed. It is
@@ -18,9 +14,6 @@ export function isSchedulerTaskWorkspaceReady(task, workspace, purpose) {
     if (isSchedulerPlanningDraft(task, purpose)) {
         return workspace === null || workspace === undefined;
     }
-    if (!taskOwnsManagedWorkspace(task)) {
-        return workspace === null || workspace === undefined;
-    }
     return isTaskOwnedWorkspace(workspace, task.id, task.cwd, task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory })));
 }
 /**

package/dist/scheduler/taskExecutionProjection.js

@@ -1,7 +1,6 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { providerRetryProjection } from "../runtime/providerRetry.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
@@ -651,11 +650,7 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
             summary: request.question
         });
     }
-    // A Task activated with an empty environment plan owns no workspace and no
-    // cwd by design; only a Task that should own one is blocked by its absence.
-    if (task.status === "active"
-        && taskOwnsManagedWorkspace(task)
-        && task.cwd === undefined) {
+    if (task.status === "active" && task.cwd === undefined) {
         blockers.push({
             kind: "identity",
             id: `workspace:${task.id}`,

package/dist/storage/sqliteSchema.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import Database from "better-sqlite3";
 import { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES } from "./baselineSchema.js";
+import { migrateTaskMainWorkspaces } from "./upgrade/taskMainWorkspaceMigration.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION, STORAGE_FORMAT, isMinorStorageUpgrade, isStorageVersion, storageVersionParts } from "./storageVersions.js";
 export { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES };
 export const TELEMETRY_KEEP_PER_RUN = 200;
@@ -14,8 +15,16 @@ export class SqliteSchemaError extends Error {
     }
 }
 // Only explicit, contiguous minor changes in this baseline may be added here.
-// The initial 1.0 release has no upgrade steps and carries no older format code.
-const MINOR_UPGRADES = Object.freeze([]);
+const MINOR_UPGRADES = Object.freeze([{
+        fromVersion: "1.0",
+        toVersion: "1.1",
+        name: "task-main-workspace",
+        introducedIn: "1.1.0",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sql: "",
+        dataMigration: "task-main-workspace"
+    }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)
         return [];
@@ -109,7 +118,7 @@ export function initializeSqliteSchema(db) {
     })();
 }
 /** Called only after an explicit minor upgrade has obtained its maintenance fence. */
-export function applySqliteMinorUpgrades(db) {
+export function applySqliteMinorUpgrades(db, home, createdRoots = []) {
     db.transaction(() => {
         const before = inspectSqliteSchema(db);
         const plan = storageMinorUpgradePlan(before.currentVersion);
@@ -121,6 +130,9 @@ export function applySqliteMinorUpgrades(db) {
                 throw new SqliteSchemaError("minor upgrade source changed.");
             }
             db.exec(step.sql);
+            if (step.dataMigration === "task-main-workspace") {
+                migrateTaskMainWorkspaces(db, home, createdRoots);
+            }
             const { major, minor } = storageVersionParts(step.toVersion);
             db.prepare("UPDATE storage_schema SET major=?,minor=?,checksum=? WHERE id=1")
                 .run(major, minor, step.targetChecksum);

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.0";
+export const CURRENT_STORAGE_VERSION = "1.1";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/storage/taskCatalog.js

@@ -57,6 +57,14 @@ export function queryTaskCatalog(db, query) {
         after.push("(createdAt, id) > (@afterDate, @afterId)");
     }
     const count = (table, condition) => `(SELECT count(*) FROM ${table} x WHERE x.task_id = c.task_id AND (${condition}))`;
+    const displaySummary = `CASE
+    WHEN page.status IN ('completed','archived')
+      AND json_extract(r.payload,'$.completionSummary') IS NOT NULL
+      THEN json_extract(r.payload,'$.completionSummary')
+    WHEN page.status IN ('cancelled','archived')
+      AND json_extract(r.payload,'$.retirementSummary') IS NOT NULL
+      THEN json_extract(r.payload,'$.retirementSummary')
+    ELSE json_extract(r.brief,'$.leaderSummary') END`;
     // Execution signals deliberately preserve raw inspectable conditions:
     // live runs (including unknown admission/identity/stall), unresolved work,
     // integrations, and pending Leader recovery. They are NOT a second
@@ -94,8 +102,8 @@ export function queryTaskCatalog(db, query) {
     (SELECT json_group_array(json_object(
       'id',page.id,'createdAt',page.createdAt,'updatedAt',page.updatedAt,'status',page.status,
       'title',substr(json_extract(r.payload,'$.title'),1,256),
-      'summary',substr(json_extract(r.brief,'$.leaderSummary'),1,512),
-      'summaryPresent',json(CASE WHEN r.brief IS NULL THEN 'false' ELSE 'true' END),
+      'summary',substr(${displaySummary},1,512),
+      'summaryPresent',json(CASE WHEN ${displaySummary} IS NULL THEN 'false' ELSE 'true' END),
       'workItems',page.workItems,'activeRuns',page.activeRuns,
       'openInputs',page.openInputs,'pendingOperations',page.pendingOperations,
       'unknownOperations',page.unknownOperations,'executionSignals',page.executionSignals)

package/dist/storage/upgrade/taskMainWorkspaceMigration.js

@@ -0,0 +1,83 @@
+import { existsSync, lstatSync, mkdirSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { updateRole, validateTaskRole } from "../../role/role.js";
+import { validateRoleSessionSet } from "../../executor/agentExecutor.js";
+import { validateTask } from "../../task/task.js";
+import { createManagedWorkspace } from "../../worktree/managedWorkspace.js";
+import { managedTaskRoot } from "../homeLayout.js";
+/** 1.0 -> 1.1: give old workspace-free Tasks the same main owner as new activations. */
+export function migrateTaskMainWorkspaces(db, home, createdRoots) {
+    const candidates = db.prepare("SELECT task_id, payload FROM task_records ORDER BY task_id").all()
+        .map(row => validateTask(JSON.parse(row.payload)))
+        .filter(task => task.cwd === undefined
+        && (task.status === "active"
+            || (task.status === "completed" && task.projectBindings.length === 0)));
+    const taskRoot = managedTaskRoot(home);
+    for (const task of candidates) {
+        if (task.workspaceIdentity !== undefined
+            || db.prepare("SELECT 1 FROM managed_workspaces WHERE owner_kind='task' AND owner_id=?")
+                .get(`task:${task.id}`) !== undefined) {
+            throw new Error(`Task ${task.id} has conflicting workspace state; preserve it for diagnosis.`);
+        }
+        if (db.prepare("SELECT 1 FROM active_turns WHERE task_id=? LIMIT 1").get(task.id) !== undefined) {
+            throw new Error(`Task ${task.id} has an active Turn; settle it before workspace migration.`);
+        }
+        for (const row of db.prepare("SELECT payload FROM role_session_sets WHERE task_id=?")
+            .all(task.id)) {
+            const set = validateRoleSessionSet(JSON.parse(row.payload));
+            if (Object.values(set.sessions).some(session => session.status !== "ended")
+                || set.providerBinding !== null) {
+                throw new Error(`Task ${task.id} has a native Session or unsettled Provider binding; stop it before workspace migration.`);
+            }
+        }
+        const root = join(taskRoot, task.id, "main");
+        if (existsSync(root)) {
+            throw new Error(`Task ${task.id} has an unowned main directory: ${root}.`);
+        }
+        // Existing Task directories may contain independently owned WorkItems.
+        // Refuse symbolic ancestors before creating this Task's new main directory.
+        for (let path = dirname(root); path !== dirname(resolve(home)); path = dirname(path)) {
+            if (existsSync(path) && lstatSync(path).isSymbolicLink()) {
+                throw new Error(`Task ${task.id} workspace ancestor is a symlink: ${path}.`);
+            }
+        }
+    }
+    for (const task of candidates) {
+        const root = join(taskRoot, task.id, "main");
+        const missing = [];
+        for (let path = root; !existsSync(path); path = dirname(path))
+            missing.push(path);
+        for (const path of missing.reverse()) {
+            mkdirSync(path, { mode: 0o700 });
+            createdRoots.push(path);
+        }
+        if (realpathSync(root) !== root) {
+            throw new Error(`Task ${task.id} main workspace is not a physical directory: ${root}.`);
+        }
+        const timestamp = new Date(Math.max(Date.now(), Date.parse(task.updatedAt))).toISOString();
+        const workspace = createManagedWorkspace({
+            owner: { type: "task", taskId: task.id }, root, entries: []
+        }, new Date(timestamp));
+        db.prepare(`INSERT INTO managed_workspaces
+      (owner_kind,owner_id,task_id,path,payload,status,created_at,updated_at)
+      VALUES ('task',?,?,?,?,?,?,?)`)
+            .run(`task:${task.id}`, task.id, root, JSON.stringify(workspace), "active", timestamp, timestamp);
+        const updatedTask = validateTask({ ...task, cwd: root, updatedAt: timestamp });
+        db.prepare("UPDATE task_records SET payload=?,updated_at=? WHERE task_id=?")
+            .run(JSON.stringify(updatedTask), timestamp, task.id);
+        db.prepare("UPDATE tasks_catalog SET updated_at=? WHERE task_id=?")
+            .run(timestamp, task.id);
+        for (const row of db.prepare("SELECT role_name,payload FROM task_roles WHERE task_id=?")
+            .all(task.id)) {
+            const role = validateTaskRole(JSON.parse(row.payload));
+            const isolated = db.prepare(`SELECT 1 FROM managed_workspaces
+        WHERE task_id=? AND owner_kind!='task' AND path=? LIMIT 1`)
+                .get(task.id, role.workspace);
+            if (isolated !== undefined)
+                continue;
+            const updatedRole = updateRole(role, { workspace: root }, new Date(timestamp));
+            db.prepare("UPDATE task_roles SET payload=?,updated_at=? WHERE task_id=? AND role_name=?")
+                .run(JSON.stringify(updatedRole), timestamp, task.id, row.role_name);
+        }
+    }
+}

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, rmdirSync, rmSync } from "node:fs";
 import Database from "better-sqlite3";
 import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation } from "../../runtime/runtimeObservation.js";
 import { RUNTIME_PROCESS_EXIT_TASK_EVENT, validateRuntimeProcessExitObservation } from "../../runtime/processExitObservation.js";
@@ -113,6 +113,7 @@ export async function runStorageUpgrade(options) {
         };
     }
     let migrationCommitted = false;
+    const createdWorkspaceDirectories = [];
     try {
         const database = new Database(join(options.home, CURRENT_DATABASE_FILENAME));
         try {
@@ -120,7 +121,7 @@ export async function runStorageUpgrade(options) {
             database.pragma("synchronous = FULL");
             database.pragma("foreign_keys = ON");
             database.pragma("busy_timeout = 5000");
-            applySqliteMinorUpgrades(database);
+            applySqliteMinorUpgrades(database, options.home, createdWorkspaceDirectories);
             migrationCommitted = true;
         }
         finally {
@@ -132,10 +133,19 @@ export async function runStorageUpgrade(options) {
         const restoration = migrationCommitted
             ? tryRestoreDatabaseBackup(options.home, backupPath)
             : { restored: true };
+        let directoryCleanupError;
+        try {
+            for (const path of createdWorkspaceDirectories.reverse())
+                rmdirSync(path);
+        }
+        catch (cleanupError) {
+            directoryCleanupError = messageOf(cleanupError);
+        }
         return {
             outcome: "failed",
             stage: "migration",
-            message: `Storage migration failed: ${messageOf(error)}`,
+            message: `Storage migration failed: ${messageOf(error)}`
+                + (directoryCleanupError === undefined ? "" : ` Directory cleanup failed: ${directoryCleanupError}`),
             action: restoration.restored
                 ? "The original database was restored from the timestamped backup. "
                     + "Resolve the reported problem and rerun `yui upgrade`."
@@ -143,16 +153,25 @@ export async function runStorageUpgrade(options) {
                     + `${backupPath} manually before retrying. Restore error: ${restoration.error}`,
             backupPath,
             classification,
-            sceneUnchanged: restoration.restored
+            sceneUnchanged: restoration.restored && directoryCleanupError === undefined
         };
     }
     const finalState = inspectStorageSchema(options.home);
     if (finalState.status !== "current") {
         const restoration = tryRestoreDatabaseBackup(options.home, backupPath);
+        let directoryCleanupError;
+        try {
+            for (const path of createdWorkspaceDirectories.reverse())
+                rmdirSync(path);
+        }
+        catch (cleanupError) {
+            directoryCleanupError = messageOf(cleanupError);
+        }
         return {
             outcome: "failed",
             stage: "migration",
-            message: `Storage migration did not reach version ${CURRENT_STORAGE_VERSION}.`,
+            message: `Storage migration did not reach version ${CURRENT_STORAGE_VERSION}.`
+                + (directoryCleanupError === undefined ? "" : ` Directory cleanup failed: ${directoryCleanupError}`),
             action: restoration.restored
                 ? "The original database was restored from the timestamped backup. "
                     + "Inspect the migration registry before retrying."
@@ -160,7 +179,7 @@ export async function runStorageUpgrade(options) {
                     + `${backupPath} manually before retrying. Restore error: ${restoration.error}`,
             backupPath,
             classification,
-            sceneUnchanged: restoration.restored
+            sceneUnchanged: restoration.restored && directoryCleanupError === undefined
         };
     }
     return {

package/dist/task/task.js

@@ -370,18 +370,6 @@ export function isTaskArchived(task) {
 export function isTaskExecutionEnabled(task) {
     return task.executionGate.state === "enabled";
 }
-/**
- * Whether this Task owns a managed Git workspace at all.
- *
- * A Task activated with an empty environment plan legitimately owns none: it
- * binds no Project and adopted no directory, so there is no worktree to be
- * ready and no cwd to verify. Workspace fences use this to distinguish "not
- * prepared yet" from "correctly owns nothing", instead of creating a workspace
- * only to satisfy the fence.
- */
-export function taskOwnsManagedWorkspace(task) {
-    return task.projectBindings.length > 0 || task.cwd !== undefined;
-}
 export function stopTaskExecution(task, now) {
     validateTask(task);
     if (task.status !== "active" && task.status !== "draft") {

package/dist/tmux/tmuxManager.js

@@ -4,6 +4,7 @@ import { runtimeError } from "../errors/cliError.js";
 import { usableInteractiveTerminal } from "../output/terminal.js";
 import { handoffTerminal } from "./terminalHandoff.js";
 import { CommandExecutionError } from "./commandExecutor.js";
+import { tmuxInvocationEnvironment } from "./tmuxSocketEndpoint.js";
 const DEFAULT_READINESS_TIMEOUT_MS = 15_000;
 const DEFAULT_READINESS_POLL_MS = 50;
 const DEFAULT_COMMAND_TIMEOUT_MS = 5_000;
@@ -1082,13 +1083,18 @@ export class TmuxManager {
     run(args, options) {
         const bounded = options?.inheritStdio === true
             ? options
-            : { ...options, timeoutMs: options?.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS };
+            : {
+                ...options,
+                timeoutMs: options?.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
+                environment: tmuxInvocationEnvironment({ ...process.env, ...options?.environment })
+            };
         return this.executor.run(this.tmuxBin, ["-L", this.#serverName, ...args], bounded);
     }
     runAsync(args, options) {
         const bounded = {
             ...options,
-            timeoutMs: options?.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS
+            timeoutMs: options?.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
+            environment: tmuxInvocationEnvironment({ ...process.env, ...options?.environment })
         };
         if (this.executor.runAsync !== undefined) {
             return this.executor.runAsync(this.tmuxBin, ["-L", this.#serverName, ...args], bounded);

package/dist/tmux/tmuxSocketEndpoint.js

@@ -11,9 +11,31 @@ export function tmuxSocketDirectory(environment = process.env) {
 export function tmuxSocketEnvironment(environment = process.env) {
     return {
         ...environment,
-        TMUX_TMPDIR: nonEmptyTmuxTmpdir(environment)
+        TMUX_TMPDIR: nonEmptyTmuxTmpdir(environment),
+        ...tmuxLocaleEnvironment(environment)
     };
 }
+/**
+ * tmux 3.6+ substitutes `_` for non-printable bytes (such as the 0x1f field
+ * separator in -F output) when it starts in the C/POSIX locale. Guarantee a
+ * UTF-8 capable locale for tmux invocations while leaving an explicit UTF-8
+ * user locale untouched. macOS always provides the portable "UTF-8" locale;
+ * glibc systems provide C.UTF-8.
+ */
+export function tmuxLocaleEnvironment(environment = process.env) {
+    const effectiveLocale = environment.LC_ALL ?? environment.LC_CTYPE ?? environment.LANG;
+    if (typeof effectiveLocale === "string" && /utf-?8/iu.test(effectiveLocale)) {
+        return {};
+    }
+    return {
+        // LC_ALL wins over LANG/LC_CTYPE, so it also repairs an explicit C value.
+        LC_ALL: process.platform === "darwin" ? "UTF-8" : "C.UTF-8"
+    };
+}
+/** Environment for tmux lifecycle/inspection calls that do not pin a socket root. */
+export function tmuxInvocationEnvironment(environment = process.env) {
+    return { ...environment, ...tmuxLocaleEnvironment(environment) };
+}
 function nonEmptyTmuxTmpdir(environment) {
     const configured = environment.TMUX_TMPDIR;
     return configured !== undefined && configured.length > 0 ? configured : undefined;