@zq-silk/yui 1.0.1 → 1.1.0

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;

package/dist/web/assets/client/app.js

@@ -30,6 +30,12 @@ const elements = {
   topbar: document.querySelector(".topbar"),
   detailBack: document.querySelector("#detail-back"),
   detailTabs: document.querySelector("#detail-tabs"),
+  conversationToggle: document.querySelector("#conversation-toggle"),
+  conversationPanel: document.querySelector("#conversation-panel"),
+  conversationContent: document.querySelector("#conversation-content"),
+  conversationClose: document.querySelector("#conversation-close"),
+  conversationSwap: document.querySelector("#conversation-swap"),
+  paneDivider: document.querySelector("#pane-divider"),
   pageTitle: document.querySelector("#page-title"),
   toast: document.querySelector("#toast"),
   lastSync: document.querySelector("#last-sync"),
@@ -68,6 +74,10 @@ const VALID_ATTENTION = ["openInputs", "pendingOperations", "unknownOperations",
 let terminalSession = null;
 let terminalStateKey = "terminal.closed";
 const submittedRequests = new Set();
+let conversationVisible = true;
+let paneWidth = Number(localStorage.getItem("yui.conversation.width")) || 400;
+const paneSide = localStorage.getItem("yui.conversation.side") === "left" ? "left" : "right";
+document.body.classList.toggle("pane-left", paneSide === "left");
 
 const i18n = createI18n(elements.locale);
 createThemeController(elements.theme);
@@ -146,6 +156,7 @@ function syncUrlFromState(options) {
 
 function detailActions() {
   return {
+    conversationHost: elements.conversationContent,
     answerInput: answerInput,
     openTerminal: openTerminal,
     inspect: inspectRecord,
@@ -190,6 +201,33 @@ function setDetailActive(active) {
       elements.pageTitle.dataset.i18n = "page.title";
     }
   }
+  updateConversationLayout();
+}
+
+function maxPaneWidth() {
+  return Math.max(280, Math.min(640,
+    window.innerWidth - elements.tasks.closest(".sidebar").offsetWidth - 460 - 8));
+}
+
+function setPaneWidth(width, persist, keepPreference) {
+  const effectiveWidth = Math.max(280, Math.min(maxPaneWidth(), width));
+  if (!keepPreference) paneWidth = effectiveWidth;
+  document.documentElement.style.setProperty("--pane-w", effectiveWidth + "px");
+  elements.paneDivider.setAttribute("aria-valuemax", String(maxPaneWidth()));
+  elements.paneDivider.setAttribute("aria-valuenow", String(effectiveWidth));
+  if (persist) localStorage.setItem("yui.conversation.width", String(effectiveWidth));
+}
+
+function updateConversationLayout() {
+  const visible = !!state.selected && conversationVisible && !terminalPanelOpen();
+  document.body.classList.toggle("conversation-active", visible);
+  elements.conversationPanel.hidden = !visible;
+  elements.paneDivider.hidden = !visible;
+  elements.conversationToggle.hidden = !state.selected || terminalPanelOpen();
+  elements.conversationToggle.setAttribute("aria-expanded", String(visible));
+  elements.conversationToggle.textContent = i18n.t(visible ? "conversation.hide" : "conversation.show");
+  elements.conversationToggle.setAttribute("aria-label", elements.conversationToggle.textContent);
+  setPaneWidth(paneWidth, false, true);
 }
 
 function showOverview() {
@@ -237,12 +275,17 @@ function renderCurrentDetail(force) {
     if (elements.detail.dataset.taskId === state.detail.task.id
       && (elements.detail.querySelector('[data-unsent="true"]')
         || elements.detail.querySelector('[data-reading="true"]')
-        || elements.detail.contains(document.activeElement))) return;
+        || elements.detail.contains(document.activeElement)
+        || elements.conversationContent.querySelector('[data-unsent="true"]')
+        || elements.conversationContent.contains(document.activeElement))) return;
     const key = i18n.getLocale() + "|" + state.detailKey
       + "|" + runtimeSignatureOf(state.detail);
     if (!force && key === renderedDetailKey) return;
     const openSections = Array.from(elements.detail.querySelectorAll("details[data-view-key][open]"))
       .map(element => element.dataset.viewKey);
+    const oldFeed = elements.conversationContent.querySelector(".conversation-feed");
+    const feedScroll = oldFeed ? oldFeed.scrollTop : 0;
+    const atFeedEnd = oldFeed && oldFeed.scrollHeight - oldFeed.clientHeight - feedScroll < 32;
     renderTaskDetail(
       elements.detail,
       state.detail,
@@ -253,6 +296,8 @@ function renderCurrentDetail(force) {
     elements.detail.querySelectorAll("details[data-view-key]").forEach(element => {
       element.open = openSections.includes(element.dataset.viewKey);
     });
+    const newFeed = elements.conversationContent.querySelector(".conversation-feed");
+    if (newFeed) newFeed.scrollTop = atFeedEnd ? newFeed.scrollHeight : feedScroll;
     renderedDetailKey = key;
   } else if (!state.selected) {
     renderedDetailKey = null;
@@ -342,6 +387,7 @@ function clearSelection() {
   state.selected = null;
   state.detail = null;
   setDetailActive(false);
+  elements.conversationContent.replaceChildren();
   syncUrlFromState({ replace: !urlTaskId() });
   showOverview();
   const savedTaskScroll = elements.tasks.scrollTop;
@@ -386,12 +432,16 @@ async function submitMutation(key, path, body) {
   }
 }
 
-async function loadTaskDetail(taskId, showLoading) {
-  if (showLoading) {
+async function loadTaskDetail(taskId, navigate) {
+  // navigate marks an explicit user navigation (task selection, deep link,
+  // back/forward). Only a navigation may move the viewport; the 5s background
+  // refresh (navigate=false) preserves the current scroll, so a quiet tick
+  // never yanks the page back to the URL section.
+  if (navigate) {
     renderLoading(elements.detail, i18n.t, "loading.detail");
     elements.mainCol.scrollTop = 0;
   }
-  const savedScrollTop = showLoading ? 0 : elements.mainCol.scrollTop;
+  const savedScrollTop = elements.mainCol.scrollTop;
   const base = "/api/tasks/" + encodeURIComponent(taskId);
   // Rendering consumes the current snapshot, not event pages. Reconnect uses
   // this same read; the independent delta API retains its fixed-bound contract.
@@ -428,11 +478,17 @@ async function loadTaskDetail(taskId, showLoading) {
   // Reveal the tab bar before measuring/scroll so anchors land correctly.
   setDetailActive(true);
   updateStickyOffsets();
-  // A section in the URL wins over the preserved scroll offset.
-  const section = readQuery().get("section");
-  const anchor = section ? elements.detail.querySelector("#detail-" + section) : null;
-  if (anchor) {
-    anchor.scrollIntoView({ block: "start" });
+  // Only an explicit navigation may reposition the viewport. On navigation a
+  // section in the URL wins over the top; a background refresh keeps the reader
+  // where they are so the page does not jump on every poll.
+  if (navigate) {
+    const section = readQuery().get("section");
+    const anchor = section ? elements.detail.querySelector("#detail-" + section) : null;
+    if (anchor) {
+      anchor.scrollIntoView({ block: "start" });
+    } else {
+      elements.mainCol.scrollTop = savedScrollTop;
+    }
   } else {
     elements.mainCol.scrollTop = savedScrollTop;
   }
@@ -477,6 +533,8 @@ async function selectTask(taskId) {
   }
   state.selected = taskId;
   state.detail = null;
+  conversationVisible = true;
+  elements.conversationContent.replaceChildren();
   renderedDetailKey = null;
   // When the selection is driven by the URL (initial load or popstate), the
   // URL already reflects the task id, so replace instead of pushing a
@@ -496,12 +554,14 @@ async function selectTask(taskId) {
 }
 
 function canLeaveDetail() {
-  return !elements.detail.querySelector('[data-unsent="true"]') || window.confirm(
+  return !(elements.detail.querySelector('[data-unsent="true"]')
+    || elements.conversationContent.querySelector('[data-unsent="true"]')) || window.confirm(
     i18n.getLocale().startsWith("zh") ? "此任务有未提交或结果尚不确定的输入。仍要离开？"
       : "This Task has unsent input or an unresolved submission. Leave anyway?");
 }
 window.addEventListener("beforeunload", event => {
-  if (!elements.detail.querySelector('[data-unsent="true"]')) return;
+  if (!elements.detail.querySelector('[data-unsent="true"]')
+    && !elements.conversationContent.querySelector('[data-unsent="true"]')) return;
   event.preventDefault();
   event.returnValue = "";
 });
@@ -621,6 +681,7 @@ function openTerminalPanel() {
   elements.terminalPanel.hidden = false;
   elements.terminalPanel.setAttribute("aria-hidden", "false");
   document.body.classList.add("terminal-active");
+  updateConversationLayout();
 }
 
 function closeTerminalPanel() {
@@ -628,6 +689,7 @@ function closeTerminalPanel() {
   document.body.classList.remove("terminal-active");
   elements.terminalPanel.setAttribute("aria-hidden", "true");
   elements.terminalPanel.hidden = true;
+  updateConversationLayout();
 }
 
 function disposeTerminal() {
@@ -856,6 +918,52 @@ globalForm.addEventListener("submit", async event => {
 });
 elements.detailBack.addEventListener("click", clearSelection);
 elements.terminalClose.addEventListener("click", closeTerminalPanel);
+elements.conversationToggle.addEventListener("click", function () {
+  conversationVisible = !conversationVisible;
+  updateConversationLayout();
+});
+elements.conversationClose.addEventListener("click", function () {
+  conversationVisible = false;
+  updateConversationLayout();
+  elements.conversationToggle.focus();
+});
+elements.conversationSwap.addEventListener("click", function () {
+  const left = !document.body.classList.contains("pane-left");
+  document.body.classList.toggle("pane-left", left);
+  localStorage.setItem("yui.conversation.side", left ? "left" : "right");
+});
+let resizingPane = false;
+elements.paneDivider.addEventListener("pointerdown", function (event) {
+  if (event.button !== 0 || elements.paneDivider.hidden || window.innerWidth <= 900) return;
+  resizingPane = true;
+  elements.paneDivider.setPointerCapture(event.pointerId);
+  document.body.classList.add("pane-resizing");
+  event.preventDefault();
+});
+elements.paneDivider.addEventListener("pointermove", function (event) {
+  if (!resizingPane) return;
+  const left = document.body.classList.contains("pane-left");
+  const width = left ? event.clientX - elements.tasks.closest(".sidebar").offsetWidth
+    : window.innerWidth - event.clientX;
+  setPaneWidth(width - 4, false);
+});
+function finishPaneResize() {
+  if (!resizingPane) return;
+  resizingPane = false;
+  document.body.classList.remove("pane-resizing");
+  localStorage.setItem("yui.conversation.width", String(paneWidth));
+}
+elements.paneDivider.addEventListener("pointerup", finishPaneResize);
+elements.paneDivider.addEventListener("pointercancel", finishPaneResize);
+elements.paneDivider.addEventListener("keydown", function (event) {
+  const left = document.body.classList.contains("pane-left");
+  const delta = left ? (event.key === "ArrowRight" ? 20 : event.key === "ArrowLeft" ? -20 : 0)
+    : (event.key === "ArrowLeft" ? 20 : event.key === "ArrowRight" ? -20 : 0);
+  if (!delta && !["Home", "End"].includes(event.key)) return;
+  event.preventDefault();
+  setPaneWidth(event.key === "Home" ? 280 : event.key === "End" ? maxPaneWidth() : paneWidth + delta, true);
+});
+window.addEventListener("resize", function () { setPaneWidth(paneWidth, false, true); });
 document.addEventListener("keydown", function (event) {
   if (globalDialog.open) return;
   const active = document.activeElement;
@@ -864,6 +972,12 @@ document.addEventListener("keydown", function (event) {
     closeTerminalPanel();
     return;
   }
+  if (event.key === "Escape" && document.body.classList.contains("conversation-active")) {
+    conversationVisible = false;
+    updateConversationLayout();
+    elements.conversationToggle.focus();
+    return;
+  }
   if (event.key === "Escape" && state.selected) {
     clearSelection();
     return;
@@ -901,9 +1015,14 @@ function applyStateFromUrl() {
   if (taskId) {
     selectTask(taskId);
   } else {
+    if (state.selected && !canLeaveDetail()) {
+      syncUrlFromState({ replace: true });
+      return;
+    }
     state.selected = null;
     state.detail = null;
     setDetailActive(false);
+    elements.conversationContent.replaceChildren();
     showOverview();
   }
 }
@@ -916,6 +1035,7 @@ window.addEventListener("popstate", function () {
 i18n.subscribe(function () {
   renderDynamicContent();
   if (terminalSession) setTerminalState(terminalStateKey);
+  updateConversationLayout();
   if (!state.selected && elements.pageTitle) elements.pageTitle.textContent = i18n.t("page.title");
 });
 showOverview();

package/dist/web/assets/client/i18n.js

@@ -34,6 +34,15 @@ const messages = {
     "sync.label": "LAST SYNC",
     "actions.openSession": "Open Session",
     "actions.operator": "Operator session",
+    "conversation.title": "Task discussion",
+    "conversation.source": "Recorded Task messages · not a Session transcript",
+    "conversation.show": "Discussion",
+    "conversation.hide": "Hide discussion",
+    "conversation.swap": "Move discussion to the other side",
+    "conversation.resize": "Resize task discussion",
+    "tabs.workResults": "Work & results",
+    "tabs.executionReviews": "Execution & reviews",
+    "tabs.historyMessages": "History & messages",
     "actions.refresh": "Refresh",
     "actions.showLess": "Show less",
     "actions.showMore": "Show more",
@@ -458,6 +467,15 @@ const messages = {
     "sync.label": "最近同步",
     "actions.openSession": "打开会话",
     "actions.operator": "Operator 会话",
+    "conversation.title": "任务讨论",
+    "conversation.source": "已记录的 Task 消息 · 非 Session 完整记录",
+    "conversation.show": "讨论",
+    "conversation.hide": "收起讨论",
+    "conversation.swap": "将讨论移至另一侧",
+    "conversation.resize": "调整讨论栏宽度",
+    "tabs.workResults": "工作与结果",
+    "tabs.executionReviews": "执行与审阅",
+    "tabs.historyMessages": "历史与消息",
     "actions.refresh": "刷新",
     "actions.showLess": "收起",
     "actions.showMore": "展开更多",

package/dist/web/assets/client/taskSummary.js

@@ -99,10 +99,15 @@ export function renderTaskSummary(container, data, t, locale, actions, recordCar
   const progress = block(say("Task progress", "任务进展"), "progress");
   const briefEntry = entries("task-brief")[0];
   const brief = available("task-brief")[0];
+  const working = data.task.status === "draft" || data.task.status === "active";
   if (data.task.completionSummary) progress.append(richText(say("Recorded completion", "已记录完成"), data.task.completionSummary, t));
   if (brief) {
-    progress.append(richText(say("Current focus", "当前工作"), brief.currentFocus, t));
-    progress.append(richText(say("Leader's progress report", "Leader 进展摘要"), brief.leaderSummary, t));
+    progress.append(richText(working
+      ? say("Current focus", "当前工作")
+      : say("Last working focus", "结束前的工作重点"), brief.currentFocus, t));
+    progress.append(richText(working
+      ? say("Leader's progress report", "Leader 进展摘要")
+      : say("Last working report", "结束前的进展摘要"), brief.leaderSummary, t));
     progress.append(node("small", "muted", say("Brief updated: ", "Brief 更新：") + formatDateTime(brief.updatedAt, locale)));
   } else if (briefEntry) progress.append(recordCard(briefEntry));
   else progress.append(node("p", "muted", say("No progress summary in this read; no percentage or ETA is inferred.",