@tea-agent/loop-agent 0.33.6 → 0.33.7-beta.0

package/dist/worker/console/chat/resource-loader.js

@@ -8,10 +8,9 @@
  * denied. Interview/Official loaders are unchanged.
  *
  * Note: this adapter is NOT the SDK's own ResourceLoader (that is
- * DefaultResourceLoader, created inside createAgentSessionServices with the
- * standard OPEN surface since ADR 0012 — no noContextFiles/noSkills/
- * noExtensions switches). This adapter is the operator-chat declarative
- * surface used for capabilities reporting and red-team checks.
+ * DefaultResourceLoader, created inside createAgentSessionServices with
+ * noContextFiles/noSkills/noExtensions). This adapter is the operator-chat
+ * declarative surface used for capabilities reporting and red-team checks.
  * The three-gate authorization (authorizeOperatorChatTool) is the actual
  * enforcement; this adapter describes what that gate admits.
  */
@@ -30,7 +29,7 @@ export const OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS = Object.freeze([
 export function createOperatorChatResourceLoader() {
     let active = new Set();
     return {
-        mode: "operator-chat-open",
+        mode: "operator-chat-closed",
         allowedToolIds: OPERATOR_CHAT_ALLOWED_TOOLS,
         deniedToolIds: OPERATOR_CHAT_DENIED_TOOLS,
         deniedOperatorActions: OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS,

package/dist/worker/console/chat/routes.js

@@ -6,22 +6,24 @@
  *   GET  /sessions/:id          — fetch session metadata + messages
  *   POST /sessions/:id/prompt   — SSE stream: send a prompt, stream events
  *   GET  /sessions/:id/events   — SSE stream: (re)connect to live events
- *   GET  /capabilities          — Chat tool surface
+ *   GET  /capabilities          — Chat tool surface + instruction skills
  *   DELETE /sessions/:id        — dispose a Chat session
  *
  * Mutation routes go through the Console mutation gate (boot token + Origin).
  * Read routes (GET capabilities / sessions) are open to loopback.
  */
+import { createHash } from "node:crypto";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, } from "./tools.js";
+import { OPERATOR_CHAT_ALLOWED_INSTRUCTION_SKILLS, OPERATOR_CHAT_DENIED_INSTRUCTION_SKILLS, OPERATOR_CHAT_WORKFLOW_CONDITIONAL_SKILLS, composeInstructionSkillsPrompt, loadOperatorChatInstructionSkills, } from "./instruction-skills.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
-import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
+import { THINKING_LEVELS, composeOperatorChatSystemPrompt, } from "./pi-runtime.js";
 import { ComposerDraftStore } from "./composer-draft-store.js";
 import { walkRepoFiles } from "./repo-walk.js";
 import { isSensitivePath, scrubSecrets } from "./explore-tools.js";
 import { listRepoDirectory, readRepoPreview, RepoBrowserError, } from "./repo-browser.js";
 import { projectRuntimeContext } from "./runtime-context.js";
-import { patchModelsConfig, readModelsConfig, readPackageInventory, } from "./pi-console-config.js";
+import { patchModelsConfig, readModelsConfig, readPackageInventory, readSkillPreferences, writeSkillPreferences, } from "./pi-console-config.js";
 import { ChatInterviewAdapter, projectChatInterviewState, } from "./interview-adapter.js";
 import { classifyChatCompactionFailure } from "./compaction-errors.js";
 import { evaluateMutationGate, isMutationMethod } from "../security.js";
@@ -31,24 +33,9 @@ import { ContractApplyReceiptStore } from "./contract-apply-receipt-store.js";
 import { projectTaskContext } from "./context-panel.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
-import { openSseResponse, writeSseEvent } from "../operation-sse.js";
-/** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
- * the same wire shape; its prefix intentionally fails the current process
- * epoch comparison and triggers safe snapshot recovery (M5.1). */
-function parseChatEventCursor(header) {
-    if (!header?.trim())
-        return { epoch: null, seq: 0 };
-    const raw = header.trim();
-    const colon = raw.lastIndexOf(":");
-    const seqPart = colon >= 0 ? raw.slice(colon + 1) : raw;
-    const seq = Number.parseInt(seqPart, 10);
-    return {
-        epoch: colon > 0 ? raw.slice(0, colon) : null,
-        seq: Number.isFinite(seq) && seq >= 0 ? seq : 0,
-    };
-}
+import { openSseResponse, parseLastEventId, writeSseEvent, } from "../operation-sse.js";
 function writeChatSse(res, event) {
-    // Persisted Chat events carry their own eventId (`<epoch>:<seq>`); write
+    // Persisted Chat events carry their own eventId (<sessionId>:<seq>); write
     // it as the SSE `id:` frame so the browser tracks Last-Event-ID for reconnect.
     if ("seq" in event && event.eventId) {
         res.write(`id: ${event.eventId}\n`);
@@ -106,32 +93,21 @@ function turnEventToStorePartial(event) {
             return undefined;
     }
 }
-/** Guarantee durable terminal events for a turn that ended without the SDK
- *  emitting them (client abort, pre-prompt persistence failure, runtime
- *  error). Without `agent_end`, reconnect replay stops mid-turn; without
- *  `agent_settled`, the single-stream UI keeps idle-grace streaming forever
- *  (M4.4). Idempotent for normal settled turns that already have both. */
+/** Guarantee a durable terminal event for a turn that ended without the SDK
+ *  emitting agent_end (client abort, pre-prompt persistence failure, runtime
+ *  error). Without it, a reconnect replay stops at agent_start and the UI stays
+ *  streaming forever. Idempotent: normal settled turns already carry the SDK's
+ *  agent_end in the ring, so they are skipped. */
 function ensureAgentEndEvent(deps, sessionId, turnId) {
-    const snap = deps.events.snapshot(sessionId);
-    const hasAgentEnd = snap.some((event) => event.turnId === turnId && event.kind === "agent_end");
-    if (!hasAgentEnd) {
+    const already = deps.events
+        .snapshot(sessionId)
+        .some((event) => event.turnId === turnId && event.kind === "agent_end");
+    if (!already) {
         deps.events.append(sessionId, turnId, {
             kind: "agent_end",
             data: { willRetry: false },
         });
     }
-    // Error/abort paths historically only forced agent_end. After the M4 single
-    // stream keeps UI streaming through agent_end for idle grace, a matching
-    // agent_settled is required so state reconcile and the applier both finish.
-    const hasSettled = deps.events
-        .snapshot(sessionId)
-        .some((event) => event.turnId === turnId && event.kind === "agent_settled");
-    if (!hasSettled) {
-        deps.events.append(sessionId, turnId, {
-            kind: "agent_settled",
-            data: {},
-        });
-    }
 }
 async function readJsonBody(req, maxBytes = 2 * 1024 * 1024) {
     const chunks = [];
@@ -222,23 +198,9 @@ function gateMutation(req, deps) {
     }
     return { ok: true };
 }
-/**
- * RF-02: map a RuntimeSnapshotUnavailableError (critical snapshot projection
- * failure — model enumeration / system prompt) to 503 PI_RUNTIME_UNAVAILABLE.
- * Returns true when the response was sent; other errors keep their existing
- * 409/500 branches so the mutation/reload semantics never regress.
- */
-function sendRuntimeUnavailable(res, error) {
-    if (!(error instanceof RuntimeSnapshotUnavailableError))
-        return false;
-    sendJson(res, 503, {
-        ok: false,
-        error: { code: error.code, message: error.message },
-    });
-    return true;
-}
 export async function handleChatCapabilities(_req, res, deps) {
     const toolSchemas = buildModelCallableToolSchemas();
+    const skills = await loadOperatorChatInstructionSkills(deps.skillsDir);
     sendJson(res, 200, {
         ok: true,
         schemaVersion: 1,
@@ -246,6 +208,18 @@ export async function handleChatCapabilities(_req, res, deps) {
         deniedTools: OPERATOR_CHAT_DENIED_TOOLS,
         deniedOperatorActions: OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS,
         tools: toolSchemas,
+        instructionSkills: {
+            allowed: OPERATOR_CHAT_ALLOWED_INSTRUCTION_SKILLS,
+            loaded: skills.loaded.map((s) => ({
+                name: s.name,
+                description: s.description,
+                charCount: s.charCount,
+            })),
+            failures: skills.failures,
+            skipped: skills.skipped,
+            promptFragmentCharCount: composeInstructionSkillsPrompt(skills.loaded)
+                .length,
+        },
         // ADR 0011: full Pi tools including bash are default-active.
         hasBash: true,
     });
@@ -302,7 +276,10 @@ export async function handleCreateChatSession(req, res, deps) {
         return;
     }
     try {
-        const snapshot = snapshotInput === undefined ? undefined : projectCompactSnapshot(snapshotInput);
+        deps.runtime.setDisabledInstructionSkills(await readSkillPreferences(deps.appData));
+        const snapshot = snapshotInput === undefined
+            ? undefined
+            : projectCompactSnapshot(snapshotInput);
         const handle = await deps.runtime.createSession({
             ...(provider && modelId ? { model: { provider, modelId } } : {}),
             ...(snapshot
@@ -514,7 +491,6 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
     const lastEvent = snapshot.at(-1);
     sendJson(res, 200, {
         ok: true,
-        eventEpoch: deps.events.epoch(sessionId),
         session: {
             ...record,
             composerDraft,
@@ -1049,31 +1025,23 @@ export async function handleChatEventsStream(req, res, deps, sessionId) {
     }
     await deps.operationLinker.recoverSession(sessionId);
     openSseResponse(res);
-    // Resume from the client's last seen eventId (`<epoch>:<seq>`). A previous
-    // Console boot/legacy cursor has a different prefix and receives snapshot.
+    // Resume from the client's last seen eventId (Last-Event-ID header, T04).
     const lastEventIdHeader = req.headers["last-event-id"];
-    const cursor = parseChatEventCursor(Array.isArray(lastEventIdHeader) ? lastEventIdHeader[0] : lastEventIdHeader);
-    const replay = deps.events.listFrom(sessionId, cursor);
-    let lastSeq = cursor.seq;
+    const afterSeq = parseLastEventId(Array.isArray(lastEventIdHeader) ? lastEventIdHeader[0] : lastEventIdHeader);
+    const replay = deps.events.listFrom(sessionId, afterSeq);
+    let lastSeq = afterSeq;
     if ("error" in replay) {
         // Cursor aged out of the bounded ring (T07 fence): tell the client to
         // reconcile from a fresh snapshot rather than render a gap as if current.
-        // The frame carries the ring tail (latestEventId) so the client can resume
-        // the replayed snapshot with a fresh Last-Event-ID (recovery cursor).
-        const retained = deps.events.snapshot(sessionId);
         writeChatSse(res, {
             kind: "reconcile",
             sessionId,
-            reason: replay.error === "CURSOR_EPOCH_MISMATCH"
-                ? "epoch_mismatch"
-                : "cursor_expired",
+            reason: "cursor_expired",
             minSeq: replay.minSeq,
-            epoch: replay.epoch,
             latestTurnId: deps.events.latestTurnId(sessionId),
-            latestEventId: retained.at(-1)?.eventId ?? null,
         });
         // Fall back to full retained snapshot so the client can re-render.
-        for (const ev of retained) {
+        for (const ev of deps.events.snapshot(sessionId)) {
             writeChatSse(res, ev);
             lastSeq = Math.max(lastSeq, ev.seq);
         }
@@ -1084,15 +1052,6 @@ export async function handleChatEventsStream(req, res, deps, sessionId) {
             lastSeq = Math.max(lastSeq, ev.seq);
         }
     }
-    // Delimit retained replay from follow mode. The client uses this marker to
-    // ensure its sole GET /events consumer is ready before POST /turns (M4.1).
-    const retainedTail = deps.events.snapshot(sessionId).at(-1);
-    writeChatSse(res, {
-        kind: "stream_ready",
-        sessionId,
-        epoch: deps.events.epoch(sessionId),
-        latestEventId: retainedTail?.eventId ?? null,
-    });
     let closed = false;
     res.once("close", () => {
         closed = true;
@@ -1252,6 +1211,47 @@ async function handlePiConfig(req, res, deps, resource) {
             });
             return;
         }
+        if (req.method === "GET") {
+            const disabledNames = await readSkillPreferences(deps.appData);
+            const loaded = await loadOperatorChatInstructionSkills(deps.skillsDir);
+            sendJson(res, 200, {
+                ok: true,
+                data: {
+                    allowed: OPERATOR_CHAT_ALLOWED_INSTRUCTION_SKILLS.map((name) => {
+                        const skill = loaded.loaded.find((item) => item.name === name);
+                        return {
+                            name,
+                            description: skill?.description ?? "",
+                            contentHash: skill
+                                ? createHash("sha256").update(skill.bodyText).digest("hex")
+                                : undefined,
+                        };
+                    }),
+                    conditional: OPERATOR_CHAT_WORKFLOW_CONDITIONAL_SKILLS,
+                    denied: OPERATOR_CHAT_DENIED_INSTRUCTION_SKILLS,
+                    disabledNames,
+                },
+            });
+        }
+        else {
+            const gate = gateMutation(req, deps);
+            if (!gate.ok) {
+                sendJson(res, gate.status, {
+                    ok: false,
+                    error: { code: gate.code, message: gate.message },
+                });
+                return;
+            }
+            const body = await readJsonBody(req);
+            const disabledNames = await writeSkillPreferences(deps.appData, Array.isArray(body.disabledNames)
+                ? body.disabledNames.filter((name) => typeof name === "string")
+                : []);
+            deps.runtime.setDisabledInstructionSkills(disabledNames);
+            sendJson(res, 200, {
+                ok: true,
+                data: { disabledNames, appliesTo: "new-sessions" },
+            });
+        }
     }
     catch (error) {
         const failure = error;
@@ -1279,148 +1279,94 @@ async function handleChatFiles(res, deps, sessionId, query) {
         .map((path) => ({ path }));
     sendJson(res, 200, { ok: true, files });
 }
-export async function handleRuntimeContext(res, deps, sessionId) {
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
-        return;
-    }
-    // AC-03: system prompt comes from the REAL Pi session (agent.state.systemPrompt
-    // fallback chain); resources come from that session's ResourceLoader. The raw
-    // prompt stays server-side; the browser only ever receives the scrubbed +
-    // length-limited projection. RF-02: a critical projection failure is 503
-    // PI_RUNTIME_UNAVAILABLE — never a 500 leak or a fake-empty context.
-    let snapshot;
-    try {
-        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId, {
-            includeRaw: true,
-        });
-    }
-    catch (error) {
-        if (sendRuntimeUnavailable(res, error))
-            return;
-        throw error;
-    }
-    if (!snapshot) {
-        sendJson(res, 503, {
-            ok: false,
-            error: {
-                code: "PI_RUNTIME_UNAVAILABLE",
-                message: `chat session not active: ${sessionId}`,
-            },
-        });
+async function handleRuntimeContext(res, deps, sessionId) {
+    const record = await deps.store.get(sessionId);
+    if (!record) {
+        sendJson(res, 404, { ok: false });
         return;
     }
+    const skills = await loadOperatorChatInstructionSkills(deps.skillsDir);
+    const selection = deps.runtime.getRuntimeSelection(sessionId);
+    const skillFragment = composeInstructionSkillsPrompt(skills.loaded);
+    const systemPrompt = composeOperatorChatSystemPrompt({ skillFragment });
     sendJson(res, 200, {
         ok: true,
         context: projectRuntimeContext({
-            systemPrompt: snapshot.systemPrompt.raw ?? "",
-            model: snapshot.selection.model
-                ? {
-                    provider: snapshot.selection.model.provider,
-                    modelId: snapshot.selection.model.id,
-                }
-                : undefined,
-            thinkingLevel: snapshot.selection.thinkingSelection === "auto"
-                ? snapshot.selection.effectiveThinkingLevel
-                : snapshot.selection.thinkingSelection,
-            activeTools: snapshot.activeTools,
-            contextFiles: snapshot.contextFiles,
-            skills: snapshot.skills,
-            extensions: snapshot.extensions,
-            packages: snapshot.packages.map((pkg) => ({
-                name: pkg.spec,
-                source: pkg.spec,
-                scope: pkg.scope,
-                enabled: pkg.enabled,
-                ...(pkg.version ? { version: pkg.version } : {}),
-                ...(pkg.path ? { path: pkg.path } : {}),
-                ...(pkg.cwd ? { cwd: pkg.cwd } : {}),
-                resolved: pkg.resolved,
-                diagnostics: pkg.diagnostics,
+            systemPrompt,
+            skills: skills.loaded.map((skill) => ({
+                name: skill.name,
+                description: skill.description,
+                charCount: skill.charCount,
+                bodyText: skill.bodyText,
             })),
-            diagnostics: snapshot.diagnostics,
+            model: selection.model ??
+                (record.modelProvider && record.modelId
+                    ? { provider: record.modelProvider, modelId: record.modelId }
+                    : undefined),
+            thinkingLevel: selection.thinkingLevel ?? record.thinkingLevel,
+            activeTools: selection.activeTools,
         }),
     });
 }
-// Exported for the direct handler-boundary tests (trace binding for
-// vt-route-model-errors); router dispatch behavior is unchanged.
-export async function handleModels(req, res, deps, sessionId) {
-    // AC-01/AC-06: models (and model/thinking mutation) requests reuse the same
-    // activation path. A missing/reopen-failed runtime is a STRUCTURED error —
-    // never a fabricated empty model list.
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
+async function handleModels(req, res, deps, sessionId) {
+    if (!(await requireChatSession(res, deps, sessionId)))
         return;
-    }
     try {
         if ((req.method ?? "GET").toUpperCase() === "GET") {
-            let models;
-            try {
-                models = await deps.runtime.listModels(sessionId);
-            }
-            catch (error) {
-                // AC-06: a model-list failure is a STRUCTURED runtime error — never
-                // folded into a fake empty list.
-                sendJson(res, 503, {
-                    ok: false,
-                    error: {
-                        code: "PI_RUNTIME_UNAVAILABLE",
-                        message: error instanceof Error ? error.message : String(error),
-                    },
-                });
-                return;
-            }
             sendJson(res, 200, {
                 ok: true,
-                models: models.map((model) => ({
-                    provider: model.provider,
-                    id: model.id ?? model.modelId ?? "",
-                    ...(model.name ? { name: model.name } : {}),
-                    hasCredentials: model.hasCredentials,
-                })),
+                models: await deps.runtime.listModels(sessionId),
                 thinkingLevels: THINKING_LEVELS,
             });
             return;
         }
         const gate = gateMutation(req, deps);
         if (!gate.ok) {
-            sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+            sendJson(res, gate.status, {
+                ok: false,
+                error: { code: gate.code, message: gate.message },
+            });
             return;
         }
         const body = await readJsonBody(req);
         let updated;
         if (typeof body.provider === "string" && typeof body.modelId === "string") {
-            const model = await deps.runtime.applyModel(sessionId, { provider: body.provider, modelId: body.modelId });
-            updated = await deps.store.setRuntimeSelection(sessionId, { modelProvider: model.provider, modelId: model.modelId });
+            const model = await deps.runtime.applyModel(sessionId, {
+                provider: body.provider,
+                modelId: body.modelId,
+            });
+            updated = await deps.store.setRuntimeSelection(sessionId, {
+                modelProvider: model.provider,
+                modelId: model.modelId,
+            });
         }
-        else if (typeof body.thinkingLevel === "string" && (body.thinkingLevel === "auto" || THINKING_LEVELS.includes(body.thinkingLevel))) {
+        else if (typeof body.thinkingLevel === "string" &&
+            THINKING_LEVELS.includes(body.thinkingLevel)) {
             const thinkingLevel = deps.runtime.applyThinkingLevel(sessionId, body.thinkingLevel);
-            updated = await deps.store.setRuntimeSelection(sessionId, thinkingLevel === "auto" ? {} : { thinkingLevel });
+            updated = await deps.store.setRuntimeSelection(sessionId, {
+                thinkingLevel,
+            });
         }
         else {
-            sendJson(res, 400, { ok: false, error: { code: "INVALID_INPUT", message: "provider/modelId or thinkingLevel is required" } });
-            return;
-        }
-        // Design §5: mutations return the fresh snapshot so the browser can
-        // atomically replace its state (revision increments server-side).
-        // RF-02: the mutation may already be applied server-side, but a failed
-        // snapshot read must surface as 503 PI_RUNTIME_UNAVAILABLE — NOT be
-        // folded into a 409 MODEL_SWITCH_FAILED (the frontend refresh path
-        // re-reads the snapshot to converge on the applied selection).
-        const snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
-        sendJson(res, 200, { ok: true, session: updated, snapshot });
-    }
-    catch (error) {
-        if (error instanceof RuntimeSnapshotUnavailableError) {
-            sendJson(res, 503, {
+            sendJson(res, 400, {
                 ok: false,
-                error: { code: error.code, message: error.message },
+                error: {
+                    code: "INVALID_INPUT",
+                    message: "provider/modelId or thinkingLevel is required",
+                },
             });
             return;
         }
-        sendJson(res, 409, { ok: false, error: { code: "MODEL_SWITCH_FAILED", message: error instanceof Error ? error.message : String(error) } });
+        sendJson(res, 200, { ok: true, session: updated });
+    }
+    catch (error) {
+        sendJson(res, 409, {
+            ok: false,
+            error: {
+                code: "MODEL_SWITCH_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
     }
 }
 async function requireChatSession(res, deps, sessionId) {
@@ -1435,132 +1381,6 @@ async function requireChatSession(res, deps, sessionId) {
     });
     return false;
 }
-/**
- * Unified session activation (design §2.1 / AC-01): models, runtime snapshot,
- * reload and model/thinking mutation requests all flow through this path.
- *
- * - runtime already holds the session → ok;
- * - only a persisted record exists → reopen from record.sessionFile;
- * - no record / missing session file → 404 PI_SESSION_NOT_FOUND;
- * - SDK reopen failure → 503 PI_RUNTIME_UNAVAILABLE.
- *
- * Never fabricates a fresh session or an empty model list.
- */
-export async function ensureActiveSession(deps, sessionId) {
-    if (deps.runtime.hasSession(sessionId))
-        return { ok: true };
-    const record = await deps.store.get(sessionId);
-    if (!record) {
-        return {
-            ok: false,
-            status: 404,
-            code: "PI_SESSION_NOT_FOUND",
-            message: `chat session not found: ${sessionId}`,
-        };
-    }
-    const reopened = await deps.runtime.reopenSession({
-        sessionId,
-        sessionFile: record.sessionFile,
-        ...(record.modelProvider && record.modelId
-            ? { model: { provider: record.modelProvider, modelId: record.modelId } }
-            : {}),
-    });
-    if (!reopened.ok) {
-        return reopened.code === "NO_SESSION_FILE"
-            ? {
-                ok: false,
-                status: 404,
-                code: "PI_SESSION_NOT_FOUND",
-                message: reopened.message,
-            }
-            : {
-                ok: false,
-                status: 503,
-                code: "PI_RUNTIME_UNAVAILABLE",
-                message: reopened.message,
-            };
-    }
-    return { ok: true };
-}
-/**
- * POST /sessions/:id/reload (AC-05 / AC-06): official session.reload() with
- * structured busy/failure semantics. Never aborts, never silently queues.
- */
-export async function handleReloadSession(req, res, deps, sessionId) {
-    const gate = gateMutation(req, deps);
-    if (!gate.ok) {
-        sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
-        return;
-    }
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
-        return;
-    }
-    const result = await deps.runtime.reloadSession(sessionId);
-    if (!result.ok) {
-        const status = result.code === "PI_SESSION_NOT_FOUND"
-            ? 404
-            : result.code === "PI_SESSION_BUSY"
-                ? 409
-                : 500;
-        sendJson(res, status, { ok: false, error: { code: result.code, message: result.message } });
-        return;
-    }
-    // RF-02: the reload succeeded, but a failed snapshot read is still a
-    // structured 503 — never a 200 with fake-empty resources.
-    let snapshot;
-    try {
-        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
-    }
-    catch (error) {
-        if (sendRuntimeUnavailable(res, error))
-            return;
-        throw error;
-    }
-    sendJson(res, 200, {
-        ok: true,
-        revision: result.revision,
-        snapshot,
-        resourceCounts: snapshot
-            ? {
-                skills: snapshot.skills.length,
-                extensions: snapshot.extensions.length,
-                packages: snapshot.packages.length,
-                contextFiles: snapshot.contextFiles.length,
-            }
-            : undefined,
-    });
-}
-/**
- * GET /sessions/:id/runtime-snapshot (AC-01): the unified live snapshot.
- */
-export async function handleRuntimeSnapshot(_res, res, deps, sessionId) {
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
-        return;
-    }
-    // RF-02: a critical snapshot projection failure is 503 PI_RUNTIME_UNAVAILABLE
-    // — never a 200 fake-empty snapshot.
-    let snapshot;
-    try {
-        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
-    }
-    catch (error) {
-        if (sendRuntimeUnavailable(res, error))
-            return;
-        throw error;
-    }
-    if (!snapshot) {
-        sendJson(res, 503, {
-            ok: false,
-            error: { code: "PI_RUNTIME_UNAVAILABLE", message: `chat session not active: ${sessionId}` },
-        });
-        return;
-    }
-    sendJson(res, 200, { ok: true, snapshot });
-}
 async function handleLinkWorkspaceOperation(req, res, deps, sessionId) {
     const gate = gateMutation(req, deps);
     if (!gate.ok) {
@@ -2333,6 +2153,16 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handlePiConfig(req, res, deps, "packages");
         return true;
     }
+    if (pathname === "/api/operator/v1/chat/instruction-skills" &&
+        method === "GET") {
+        await handlePiConfig(req, res, deps, "skills");
+        return true;
+    }
+    if (pathname === "/api/operator/v1/chat/instruction-skills/preferences" &&
+        method === "PUT") {
+        await handlePiConfig(req, res, deps, "skills");
+        return true;
+    }
     if (method === "GET" && pathname === "/api/operator/v1/chat/capabilities") {
         await handleChatCapabilities(req, res, deps);
         return true;
@@ -2391,7 +2221,7 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleMutationHumanGate(req, res, deps, decodeURIComponent(mutationHumanGate[1]));
         return true;
     }
-    const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|models|model|reload)$/);
+    const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|models|model)$/);
     if (m4Route) {
         const id = decodeURIComponent(m4Route[1]);
         const route = m4Route[2];
@@ -2407,10 +2237,6 @@ export async function handleChatRequest(req, res, deps, pathname) {
             await handleRuntimeContext(res, deps, id);
             return true;
         }
-        if (route === "runtime-snapshot" && method === "GET") {
-            await handleRuntimeSnapshot(req, res, deps, id);
-            return true;
-        }
         if (route === "models" && method === "GET") {
             await handleModels(req, res, deps, id);
             return true;
@@ -2419,10 +2245,6 @@ export async function handleChatRequest(req, res, deps, pathname) {
             await handleModels(req, res, deps, id);
             return true;
         }
-        if (route === "reload" && method === "POST") {
-            await handleReloadSession(req, res, deps, id);
-            return true;
-        }
     }
     const sessionMainline = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/branch\/mainline$/);
     if (method === "POST" && sessionMainline) {