@zq-silk/yui 2.3.0 → 2.4.0

package/dist/web/webSettings.js

@@ -0,0 +1,331 @@
+import { createHash } from "node:crypto";
+import { CONFIG_DOMAINS, configDefinitionsForDomain } from "../config/configCatalog.js";
+import { effectiveConfigData, runConfigCommand } from "../commands/configCommands.js";
+import { runAgentCommand } from "../commands/agentCommands.js";
+import { runGlobalRoleCommand, previewGlobalRoleAgentConfigurationMutation } from "../commands/globalRoleCommands.js";
+import { runProfileCommand, previewProfileAgentConfigurationMutation } from "../commands/profileCommands.js";
+import { roleOptionSpecs } from "../commands/roleConfiguration.js";
+import { staticAgentConfigurationFields } from "../executor/agentConfigurationFields.js";
+import { validateAgentLaunchConfiguration } from "../executor/agentConfigurationCatalog.js";
+import { resolveAgentProfileView } from "../profile/agentProfileRuntime.js";
+import { webLocalMutation, WebRequestRejected } from "./webMutation.js";
+const ROLE_NOTICE = "Saved desired configuration applies to a subsequent Role launch, not the current Session. Existing Task bindings are unchanged. No Session is restarted here.";
+const PROFILE_NOTICE = "Profile behavior is copied into newly created Task Roles. Inherited runtime resolves from the global Worker when applied. Existing Task Roles are not rebound.";
+const AGENT_NOTICE = "Command, arguments and environment references apply to subsequent Host processes. Authentication remains with the native Agent. Only reference names and presence in the Controller environment are shown; no environment values are returned.";
+/** A view adapter over existing commands, not another writable configuration store. */
+export function createWebSettings(store, options) {
+    function groups() {
+        return [
+            { id: "system", title: "system", section: "general", advanced: false },
+            ...store.listGlobalRoles().map(r => ({ id: `role/${r.name}`, title: r.name, section: "roles", advanced: false })),
+            ...CONFIG_DOMAINS.filter(id => id !== "system").map(id => ({ id, title: id, section: "advanced", advanced: true })),
+            ...store.listConfiguredAgents().map(a => ({ id: `agent/${a.id}`, title: a.id, section: "agents", advanced: true })),
+            ...store.listAgentProfiles().map(p => ({ id: `profile/${p.id}`, title: p.id, section: "profiles", advanced: true }))
+        ];
+    }
+    function index(query = "", cursor = "0") {
+        if (query.length > 256 || !/^\d{1,8}$/.test(cursor))
+            throw new WebRequestRejected("Invalid settings search or cursor.");
+        const needle = query.trim().toLowerCase();
+        const all = groups().filter(g => !needle || [
+            g.id, g.title, g.section,
+            ...readGroup(g).fields.map(f => `${f.key} ${f.label} ${f.summary ?? ""}`)
+        ].join(" ").toLowerCase().includes(needle));
+        const offset = Number(cursor);
+        return { groups: all.slice(offset, offset + 50), total: all.length,
+            nextCursor: offset + 50 < all.length ? String(offset + 50) : null };
+    }
+    function read(id) {
+        const meta = groups().find(group => group.id === id);
+        if (!meta)
+            throw new WebRequestRejected("Configuration group not found.");
+        return readGroup(meta);
+    }
+    function readGroup(meta) {
+        const { id } = meta;
+        let fields;
+        let notice = "Saved values and effective defaults share the CLI configuration source. Reset removes the stored override; it does not restart services.";
+        let observation;
+        let agentId;
+        let version;
+        if (CONFIG_DOMAINS.includes(id)) {
+            const domain = id;
+            const config = store.getConfig();
+            const effective = effectiveConfigData(config, domain);
+            const defaults = effectiveConfigData({ schemaVersion: 1 }, domain);
+            fields = configDefinitionsForDomain(domain).map(def => ({
+                key: def.key, label: def.label, value: effective[def.property],
+                kind: def.key === "review" ? "json" : kind(effective[def.property]), summary: def.summary, takesEffect: def.takesEffect,
+                source: config[def.property] === undefined ? "default" : "stored",
+                defaultValue: defaults[def.property], reset: true,
+                ...(def.key === "default-agent" ? { choices: store.listConfiguredAgents().map(a => a.id) } : {}),
+                ...(def.key === "resources-gc-mode" ? { choices: ["report", "quarantine"] } : {})
+            }));
+            version = fields;
+        }
+        else if (id.startsWith("agent/")) {
+            const agent = store.getConfiguredAgent(id.slice(6));
+            agentId = agent.id;
+            version = agent;
+            notice = AGENT_NOTICE;
+            fields = [
+                field("command", agent.command),
+                field("baseArgs", agent.baseArgs, "json"),
+                { ...field("environment", agent.environment, "json"), summary: "Array of {target, source: \"process\", sourceName, required: true}. Only process-variable references are accepted." }
+            ];
+            observation = { component: agent.component, adapterId: agent.adapterId,
+                environment: agent.environment.map(b => ({ ...b, present: !!options.environment[b.sourceName] })) };
+        }
+        else if (id.startsWith("role/")) {
+            const role = store.getGlobalRole(id.slice(5));
+            const binding = role.agentBindings[role.activeAgentId];
+            agentId = role.activeAgentId;
+            version = role;
+            notice = ROLE_NOTICE;
+            const specs = roleOptionSpecs({ update: true, includeWorkspace: true });
+            fields = [
+                { ...field("activeAgentId", role.activeAgentId), choices: store.listConfiguredAgents().map(a => a.id),
+                    summary: "Explicit global Role Agent selection. Save this field alone, then edit the selected Agent's settings. Existing live-session and lifecycle guards apply; no Task is rebound." },
+                field("workspace", role.workspace),
+                ...["description", "systemPrompt", "expectedOutput", "responsibilities", "constraints", "skills"]
+                    .map(key => ({ ...field(key, role[key] ?? (["responsibilities", "constraints", "skills"].includes(key) ? [] : ""), ["responsibilities", "constraints", "skills"].includes(key) ? "json" : "multiline"), reset: true })),
+                ...staticAgentConfigurationFields(binding.adapterId)
+                    .filter(f => ROLE_FIELDS[f.key] && specs.has(ROLE_FIELDS[f.key].set))
+                    .map(f => ({
+                    ...field(f.key, getPath(binding.config, f.key) ?? "", f.key.endsWith("Tools") ? "json" : "text"),
+                    summary: f.reason, choices: f.allowCustom ? undefined : f.choices.map(c => c.value),
+                    reset: !!ROLE_FIELDS[f.key].clear,
+                    source: getPath(binding.config, f.key) === undefined ? "native/default" : "stored"
+                }))
+            ];
+            observation = { activeAgentId: agentId, launchRevision: role.launchRevision,
+                defaultAccess: role.defaultAccess, agentBindings: Object.keys(role.agentBindings),
+                session: store.getGlobalRoleSessionSet(role.name)?.sessions[role.activeAgentId]?.status ?? "absent" };
+        }
+        else {
+            const profile = store.getAgentProfile(id.slice(8));
+            const view = resolveAgentProfileView(profile, store);
+            version = profile;
+            notice = PROFILE_NOTICE;
+            agentId = view.runtime.status === "resolved" ? view.runtime.binding.agentId : undefined;
+            fields = [
+                { ...field("access", profile.defaultAccess), choices: ["read", "write"] },
+                { ...field("description", profile.description ?? "", "multiline"), reset: true },
+                { ...field("instructions", profile.instructions ?? "", "multiline"), reset: true },
+                { ...field("skills", profile.skills ?? [], "json"), reset: true },
+                { ...field("agent", profile.runtime.source === "explicit" ? profile.runtime.agentId : ""), choices: ["", ...store.listConfiguredAgents().map(a => a.id)], summary: "Empty = inherit global Worker; an explicit Agent enables model/effort overrides." },
+                { ...field("model", profile.runtime.source === "explicit" ? profile.runtime.model ?? "" : ""), reset: true },
+                { ...field("effort", profile.runtime.source === "explicit" ? profile.runtime.effort ?? "" : ""), reset: true }
+            ];
+            observation = view.runtime;
+        }
+        return { ...meta, fields, notice, agentId, observation,
+            revision: createHash("sha256").update(JSON.stringify(version)).digest("hex") };
+    }
+    async function capabilities(id, refresh) {
+        const group = read(id);
+        if (!group.agentId)
+            throw new WebRequestRejected("This group has no resolved Agent.");
+        const agent = store.getConfiguredAgent(group.agentId);
+        if (!agent)
+            throw new WebRequestRejected("Configured Agent not found.");
+        const role = id.startsWith("role/") ? store.getGlobalRole(id.slice(5)) : null;
+        return options.catalogs.resolve({ agent, refresh,
+            cwd: role?.workspace ?? store.getConfig().defaultWorkspace ?? process.cwd(),
+            ...(role ? { config: role.agentBindings[role.activeAgentId].config } : {}) });
+    }
+    async function save(input) {
+        let mutationEntered = false;
+        try {
+            const body = record(input);
+            if (Object.keys(body).some(k => !["id", "revision", "changes", "acknowledgeLive"].includes(k))
+                || typeof body.id !== "string" || typeof body.revision !== "string"
+                || !Array.isArray(body.changes) || !body.changes.length || body.changes.length > 64
+                || (body.acknowledgeLive !== undefined && typeof body.acknowledgeLive !== "boolean")) {
+                throw new WebRequestRejected("Expected a group, its read revision, and changed fields.");
+            }
+            const id = body.id;
+            const current = read(id);
+            if (current.revision !== body.revision)
+                throw new WebRequestRejected("Configuration changed since it was read. Compare current values before saving again.");
+            const seen = new Set();
+            const changes = body.changes.map(value => {
+                const change = record(value);
+                const def = current.fields.find(f => f.key === change.key);
+                if (!def || seen.has(def.key) || Object.keys(change).some(k => !["key", "value", "reset"].includes(k))
+                    || (change.reset !== undefined && change.reset !== true) || (change.reset === true && !def.reset)
+                    || (change.reset === true ? Object.hasOwn(change, "value") : !Object.hasOwn(change, "value"))) {
+                    throw new WebRequestRejected("Invalid or duplicate configuration field.");
+                }
+                seen.add(def.key);
+                return { key: def.key, value: change.value, reset: change.reset === true };
+            });
+            const args = objectArguments(id, changes);
+            if (id.startsWith("role/") && changes.some(c => c.key === "activeAgentId") && changes.length !== 1) {
+                throw new WebRequestRejected("Save the Agent selection alone, then read its supported settings.");
+            }
+            // The same complete candidate and transactional recheck as the CLI.
+            const mutation = id.startsWith("profile/")
+                ? previewProfileAgentConfigurationMutation(["update", id.slice(8), ...args], store)
+                : id.startsWith("role/") && !changes.some(c => c.key === "activeAgentId")
+                    ? previewGlobalRoleAgentConfigurationMutation(["update", id.slice(5), ...args], store, { yuiHome: store.rootDirectory() }) : undefined;
+            let validated;
+            if (mutation) {
+                const agent = store.getConfiguredAgent(mutation.agentId);
+                if (!agent)
+                    throw new WebRequestRejected("Configured Agent not found.");
+                validated = await options.catalogs.resolve({ agent, cwd: mutation.cwd, config: mutation.config });
+                validateAgentLaunchConfiguration(validated.catalog, mutation.config);
+            }
+            const validation = {
+                validateAgentConfiguration: (candidate) => {
+                    if (!mutation || JSON.stringify(candidate) !== JSON.stringify(mutation) || !validated) {
+                        throw new Error("Agent configuration changed after capability validation. Read it again.");
+                    }
+                    validateAgentLaunchConfiguration(validated.catalog, candidate.config);
+                }
+            };
+            mutationEntered = true;
+            const output = webLocalMutation(store, tx => {
+                if (read(id).revision !== body.revision)
+                    throw new Error("Configuration changed since it was read. Compare current values before saving again.");
+                if (CONFIG_DOMAINS.includes(id)) {
+                    return changes.map(change => runConfigCommand(id, change.reset ? ["clear", change.key] : ["set", change.key, ...configArguments(change.key, change.value)], tx).output).join("");
+                }
+                const ack = body.acknowledgeLive === true ? ["--yes"] : [];
+                if (id.startsWith("agent/"))
+                    return runAgentCommand(["update", id.slice(6), ...args, ...ack], tx);
+                if (id.startsWith("role/")) {
+                    const binding = changes.find(c => c.key === "activeAgentId");
+                    if (binding && changes.length !== 1)
+                        throw new Error("Save the Agent selection alone, then read its supported settings.");
+                    return runGlobalRoleCommand(binding
+                        ? ["bind", id.slice(5), text(binding.value)]
+                        : ["update", id.slice(5), ...args, ...ack], tx, {
+                        yuiHome: store.rootDirectory(), env: options.environment, ...validation
+                    });
+                }
+                return runProfileCommand(["update", id.slice(8), ...args], tx, () => new Date(), validation).output;
+            });
+            let refresh = "not-required";
+            if (changes.some(c => c.key === "reconciliation-interval-seconds")) {
+                try {
+                    options.refreshConfiguration?.();
+                    refresh = options.refreshConfiguration ? "applied" : "restart-required";
+                }
+                catch {
+                    refresh = "saved-refresh-failed";
+                }
+            }
+            return { status: "saved", output, group: read(id), adoption: "No existing Session or Task was rebound.", refresh };
+        }
+        catch (error) {
+            if (!mutationEntered)
+                throw new WebRequestRejected(error instanceof Error ? error.message : "Invalid settings request.");
+            throw error;
+        }
+    }
+    return { index, read, save, capabilities };
+}
+function kind(value) {
+    return typeof value === "boolean" ? "boolean" : typeof value === "number" ? "number"
+        : value !== null && typeof value === "object" ? "json" : "text";
+}
+function field(key, value, type = "text") {
+    return { key, label: key, value, kind: type };
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new WebRequestRejected("Expected an object.");
+    return value;
+}
+function text(value) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new WebRequestRejected("Expected text.");
+    return value;
+}
+function strings(value) {
+    if (!Array.isArray(value))
+        throw new WebRequestRejected("Expected a JSON array of strings.");
+    return value.map(text);
+}
+function getPath(value, path) {
+    return path.split(".").reduce((v, k) => v && typeof v === "object" ? v[k] : undefined, value);
+}
+function configArguments(key, value) {
+    if (key === "runtime-health") {
+        const v = record(value);
+        if (Object.keys(v).some(k => !["quietAfterSeconds", "diagnosticAfterSeconds", "stallAfterSeconds"].includes(k)))
+            throw new WebRequestRejected("Unknown health field.");
+        return ["--quiet-after-seconds", String(v.quietAfterSeconds), "--diagnostic-after-seconds", String(v.diagnosticAfterSeconds), "--stall-after-seconds", String(v.stallAfterSeconds)];
+    }
+    if (key === "review") {
+        const v = record(value);
+        if (Object.keys(v).some(k => !["roleName", "trigger"].includes(k)))
+            throw new WebRequestRejected("Unknown review field.");
+        return ["--role", text(v.roleName), "--trigger", text(v.trigger)];
+    }
+    if (!["string", "number", "boolean"].includes(typeof value))
+        throw new WebRequestRejected("Expected a scalar setting.");
+    return [String(value)];
+}
+const ROLE_FIELDS = {
+    model: { set: "--model", clear: "--clear-model" }, effort: { set: "--effort", clear: "--clear-effort" },
+    "permission.strategy": { set: "--permission-strategy" }, "permission.sandbox": { set: "--sandbox" },
+    "permission.approval": { set: "--approval" }, "permission.mode": { set: "--permission-mode" },
+    "permission.allowedTools": { set: "--allowed-tool", clear: "--clear-allowed-tools", many: true },
+    "permission.disallowedTools": { set: "--disallowed-tool", clear: "--clear-disallowed-tools", many: true },
+    search: { set: "--search", clear: "--clear-search" },
+    workspace: { set: "--workspace" }, description: { set: "--description", clear: "--clear-description" },
+    systemPrompt: { set: "--system-prompt", clear: "--clear-system-prompt" },
+    expectedOutput: { set: "--expected-output", clear: "--clear-expected-output" },
+    responsibilities: { set: "--responsibility", clear: "--clear-responsibilities", many: true },
+    constraints: { set: "--constraint", clear: "--clear-constraints", many: true },
+    skills: { set: "--skill", clear: "--clear-skills", many: true }
+};
+function objectArguments(id, changes) {
+    if (CONFIG_DOMAINS.includes(id))
+        return [];
+    return changes.flatMap(c => {
+        if (id.startsWith("role/") && c.key === "activeAgentId")
+            return [];
+        if (id.startsWith("agent/")) {
+            if (c.key === "command")
+                return ["--command", text(c.value)];
+            if (c.key === "baseArgs") {
+                const values = strings(c.value);
+                return values.length ? values.flatMap(v => ["--arg", v]) : ["--clear-args"];
+            }
+            if (!Array.isArray(c.value))
+                throw new WebRequestRejected("Expected an environment reference array.");
+            return c.value.length ? c.value.flatMap(value => {
+                const b = record(value);
+                if (Object.keys(b).some(k => !["target", "source", "sourceName", "required"].includes(k))
+                    || b.source !== "process" || b.required !== true)
+                    throw new WebRequestRejected("Only required process-variable references are supported by the Agent command.");
+                return ["--env", `${text(b.target)}=${text(b.sourceName)}`];
+            }) : ["--clear-env"];
+        }
+        if (id.startsWith("profile/")) {
+            if (c.key === "agent")
+                return c.value === "" ? ["--inherit-worker"] : ["--agent", text(c.value)];
+            if (c.reset)
+                return [`--clear-${c.key}`];
+            if (c.key === "skills") {
+                const values = strings(c.value);
+                return values.length ? values.flatMap(v => ["--skill", v]) : ["--clear-skills"];
+            }
+            return [`--${c.key}`, text(c.value)];
+        }
+        const spec = ROLE_FIELDS[c.key];
+        if (!spec)
+            throw new WebRequestRejected("Unsupported Role field.");
+        if (c.reset)
+            return [spec.clear];
+        if (spec.many) {
+            const values = strings(c.value);
+            return values.length ? values.flatMap(v => [spec.set, v]) : [spec.clear];
+        }
+        return [spec.set, typeof c.value === "boolean" ? String(c.value) : text(c.value)];
+    });
+}

package/dist/web/webSkills.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import { listSkillSources, readFrozenSkill, readSkillSource } from "../context/skillCatalog.js";
+import { runGlobalRoleCommand } from "../commands/globalRoleCommands.js";
+import { runTaskCommand } from "../commands/taskCommands.js";
+import { webLocalMutation, WebRequestRejected } from "./webMutation.js";
+function target(input) {
+    if (!input || typeof input !== "object")
+        throw new WebRequestRejected("Choose an explicit Role scope.");
+    const v = input;
+    if (!["global", "task"].includes(String(v.scope)) || typeof v.role !== "string" || !v.role
+        || (v.scope === "task" ? typeof v.task !== "string" || !v.task : v.task !== undefined && v.task !== "")) {
+        throw new WebRequestRejected("Choose an explicit global or Task Role.");
+    }
+    return { scope: v.scope, role: v.role, ...(v.scope === "task" ? { task: v.task } : {}) };
+}
+const revision = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+/** Local-human adapter; all writes retain CLI Role guards, validation and revision semantics. */
+export function createWebSkills(store) {
+    const home = store.rootDirectory();
+    function roleState(input) {
+        const selected = target(input);
+        const role = selected.scope === "global" ? store.getGlobalRole(selected.role) : store.getRole(selected.task, selected.role);
+        if (!role)
+            throw new WebRequestRejected("Role not found in the selected scope.");
+        const sessions = selected.scope === "global" ? store.getGlobalRoleSessionSet(selected.role)
+            : store.getRoleSessionSet(selected.task, selected.role);
+        const session = sessions?.sessions[role.activeAgentId];
+        return { target: selected, revision: revision(role), skills: role.skills ?? [], launchRevision: role.launchRevision,
+            session: session ? { nativeSessionId: session.nativeSessionId, status: session.status,
+                sourceDesiredRevision: session.effective.sourceDesiredRevision, packages: session.effective.skillPackages ?? null } : null,
+            notice: "Configured bindings apply on a subsequent launch. Saving does not load a Skill, restart a Session, rewrite a frozen Run, or delete a package." };
+    }
+    return {
+        catalog: listSkillSources.bind(null, home),
+        roles(scope, task) {
+            if (scope !== "global" && scope !== "task")
+                throw new WebRequestRejected("Choose global or Task scope.");
+            if (scope === "task" && (!task || !store.getTask(task)))
+                throw new WebRequestRejected("Task not found.");
+            return (scope === "global" ? store.listGlobalRoles() : store.listRoles(task)).map(role => ({ name: role.name }));
+        },
+        role: roleState,
+        file(input) {
+            if (!input.frozen)
+                return readSkillSource(home, input.id, input.resource);
+            const state = roleState(input.target);
+            let packages = state.session?.packages;
+            if (input.run) {
+                if (state.target.scope !== "task")
+                    throw new WebRequestRejected("A frozen Run requires Task scope.");
+                const run = store.getRun(state.target.task, input.run);
+                if (!run || run.roleName !== state.target.role)
+                    throw new WebRequestRejected("Run not found for this Task Role.");
+                packages = run.effective.skillPackages;
+            }
+            const ref = packages?.find(p => p.id === input.id);
+            if (!ref)
+                throw new WebRequestRejected("No frozen package evidence for this Skill. Current source is not a substitute.");
+            if (ref.digest !== input.digest)
+                throw new WebRequestRejected("Frozen package version changed or was not specified. Reload its evidence.");
+            return readFrozenSkill(ref, input.resource);
+        },
+        save(input) {
+            if (!input || typeof input !== "object")
+                throw new WebRequestRejected("Invalid Skill binding request.");
+            const body = input;
+            if (Object.keys(body).some(k => !["target", "revision", "skills", "acknowledgeLive"].includes(k))
+                || typeof body.revision !== "string" || !Array.isArray(body.skills) || body.skills.length > 128
+                || body.skills.some(s => typeof s !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(s))
+                || (body.acknowledgeLive !== undefined && typeof body.acknowledgeLive !== "boolean")) {
+                throw new WebRequestRejected("Expected a Role read revision and Skill IDs.");
+            }
+            const selected = target(body.target);
+            const skills = [...new Set(body.skills)];
+            const args = skills.length ? skills.flatMap(id => ["--skill", id]) : ["--clear-skills"];
+            const output = webLocalMutation(store, tx => {
+                if (roleState(selected).revision !== body.revision)
+                    throw new Error("Role changed since it was read. Reload before saving.");
+                if (selected.scope === "global")
+                    return runGlobalRoleCommand(["update", selected.role, ...args, ...(body.acknowledgeLive ? ["--yes"] : [])], tx, { yuiHome: home, env: {} });
+                return runTaskCommand(["role", "update", selected.task, selected.role, ...args], tx, { yuiHome: home, environment: {} }).output;
+            });
+            return { status: "saved", output, role: roleState(selected) };
+        }
+    };
+}

package/dist/web/webSnapshot.js

@@ -32,7 +32,7 @@ export function buildWebPageSessions(store, options, now) {
         return { scope: "current-catalog-page", readAt: now.toISOString(), tasks };
     });
 }
-export function buildWebTaskDetail(store, taskId, now = new Date()) {
+export function buildWebTaskDetail(store, taskId, now = new Date(), compact = false) {
     return store.transaction((reader) => {
         const task = reader.getTask(taskId);
         if (task === null)
@@ -86,6 +86,7 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
                     adapterId: activeSession.adapterId,
                     nativeSessionId: activeSession.nativeSessionId ?? null,
                     status: activeSession.status,
+                    skillPackages: activeSession.effective.skillPackages ?? null,
                     endpointImplementation: activeSession.endpointImplementation ?? null
                 },
                 effectiveLaunchSource: activeRun === undefined
@@ -98,9 +99,44 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
         const execution = buildTaskExecutionProjection(reader, taskId, now);
         if (execution === null)
             return null;
+        const brief = reader.getTaskBrief(taskId);
+        const roleSessionSets = reader.listRoleSessionSets(taskId);
+        const sessions = projectWebSessions({ taskId, sessionSets: roleSessionSets, events, now,
+            ...(brief?.updatedAt === undefined ? {} : { semanticProgressAt: brief.updatedAt }),
+            policy: resolveRuntimeHealth(reader.getConfig().runtimeHealth) });
+        if (compact) {
+            // Observation is not semantic progress. No Task/Message/Run bodies,
+            // Role history or validation logs ride the default polling response.
+            const clip = (text) => text?.slice(0, 1200);
+            return {
+                execution: {
+                    status: execution.status, owner: execution.owner, action: execution.action, next: execution.next,
+                    summary: clip(execution.summary), reason: clip(execution.reason),
+                    monitoring: execution.monitoring, failClosed: execution.failClosed,
+                    activeRuns: execution.activeRuns.slice(0, 16).map(run => ({ id: run.id })),
+                    activeRunCount: execution.activeRuns.length,
+                    attention: execution.attention.slice(0, 8).map(item => ({ ...item, summary: clip(item.summary) })),
+                    blockers: execution.blockers.slice(0, 8).map(item => ({ ...item, summary: clip(item.summary) }))
+                },
+                roles: roles.slice(0, 16).map(role => ({
+                    name: role.name, status: role.status, runtimeSession: role.runtimeSession
+                })),
+                sessions: { ...sessions, sessions: sessions.sessions.slice(0, 16).map(session => ({
+                        ...session, reason: session.reason.slice(0, 1200),
+                        operations: session.operations.slice(0, 16), background: session.background.slice(0, 16)
+                    })) },
+                observability: {
+                    cost: execution.observability.cost,
+                    readyCount: execution.observability.dag.readyIds.length,
+                    context: {
+                        snapshotCount: execution.observability.context.snapshotCount,
+                        totalBytes: execution.observability.context.totalBytes
+                    }
+                }
+            };
+        }
         const remoteDelivery = webRemoteDelivery(reader, task);
         const workItems = reader.listWorkItems(taskId);
-        const roleSessionSets = reader.listRoleSessionSets(taskId);
         const workItemObservability = new Map(execution.observability.workItems.map((item) => [item.workItemId, item]));
         return {
             task: {
@@ -108,14 +144,10 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
                 ...(projectNames.length === 0 ? {} : { projectNames })
             },
             execution,
-            sessions: projectWebSessions({ taskId, sessionSets: roleSessionSets, events, now,
-                ...(reader.getTaskBrief(taskId)?.updatedAt === undefined ? {} : {
-                    semanticProgressAt: reader.getTaskBrief(taskId).updatedAt
-                }),
-                policy: resolveRuntimeHealth(reader.getConfig().runtimeHealth) }),
+            sessions,
             remoteDelivery,
             observability: execution.observability,
-            brief: reader.getTaskBrief(taskId),
+            brief,
             roles,
             workItems: workItems.map((item) => ({
                 ...item,