@ordewell/cli 0.7.1 → 0.8.0

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core37 = require("@ordewell/core");
+var import_core38 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -100,7 +100,7 @@ an id.
 Planning:
   ordewell                        Full-screen terminal UI (everything the VS Code extension does)
   ordewell tui                    The same thing, named \u2014 for scripts and aliases
-  ordewell plan --goal "text"     Plan a goal conversationally (honours verify)
+  ordewell plan --goal "text"     Plan a goal conversationally
   ordewell run                    Execute the last generated plan (streams status)
   ordewell approve                Sign off a plan paused for review, and continue it
   ordewell stop                   Stop execution of the last session (or --server)
@@ -123,7 +123,6 @@ Tasks (<id> is an order number or a task ID):
   ordewell continue <id> <msg>    Continue a finished task in its saved runner session
   ordewell checkpoint <id> approve|reject [reason]  Answer the checkpoint a task waits at
   ordewell cancel <id>            Kill a running task
-  ordewell terminal <id>          Open a real terminal attached to a task's runner
 
 Per-task assignment (omit the value to list the options):
   ordewell task-runner <id> [runner]   Set a task's executor (re-picks its model, effort and mode)
@@ -131,6 +130,7 @@ Per-task assignment (omit the value to list the options):
   ordewell task-effort <id> [level]    Set a task's thinking effort ("default" to clear)
   ordewell task-mode <id> [mode]       Set a task's runner mode
   ordewell task-deps <id> [a,b|none]   Set which earlier tasks a task waits for
+  ordewell task-skills <id> [a,b|none] Set the skills attached to a task (applies-to: task); none clears them
   ordewell task-ops <id> [on|off]      Make a task an ops task (runs in your checkout once its dependencies are merged) or a change task
 
 Planner, models and runners:
@@ -141,19 +141,14 @@ Planner, models and runners:
   ordewell runners [<id> on|off]  Enable or disable runners (claude-code, opencode, codex)
   ordewell allowlist set|clear|show       Limit which models a runner may use
   ordewell auto [full|guarded]    Autonomy level for new sessions: Full or Guarded
-  ordewell transport [terminal|structured]   Structured (default) or terminal task transport, from the next run
   ordewell parallel [<n>]         How many AI tasks run at once (default 3; applies to a live run)
   ordewell refresh                Re-discover runners and model catalogs
   ordewell models                 List every provider's catalog (works without a server)
 
-Modes:
-  ordewell tdd [on|off]         Toggle Test-Driven Development mode (or show status)
-  ordewell verify [on|off]    Toggle verification mode \u2014 adds a final evidence-based task that runs the full suite (or show status)
-
 Other:
   ordewell web                    Start the API server (foreground; --daemon for background)
   ordewell setup                  Interactive first-run setup wizard
-  ordewell plugins list|install|remove|create   Manage runner plugins
+  ordewell skills                 List installed skills and shadowed workspace duplicates
   ordewell --help               Show this help
   ordewell --version            Print the installed version (alias: version, -v)
 
@@ -171,7 +166,7 @@ Plan options:
   --goal "text"       Task description (required)
   --runner <id>       Runner to use (repeatable; default: all enabled runners)
   --workspace /path   Workspace directory (default: cwd)
-  --no-chat           One-shot plan; skips the planner dialogue (and its toggles)
+  --no-chat           One-shot plan; skips the planner dialogue
 
 Run options:
   --session-id <id>   Execute a specific session (default: last session)
@@ -185,6 +180,10 @@ Sessions options:
   --workspace /path   Workspace to list sessions from (default: cwd)
   --json              Output the list as JSON
 
+Skills options:
+  --workspace /path   Workspace to read skills from (default: cwd)
+  --json              Output resolved skills and shadowed duplicates as JSON
+
 Task options (add-task):
   --title "text"      Task title (required)
   --description "..." Task description (default: the title)
@@ -247,13 +246,13 @@ function oldPidFileFor(port) {
   return port === DEFAULT_PORT ? (0, import_path2.join)(OLD_CONFIG_DIR, "server.pid") : (0, import_path2.join)(OLD_CONFIG_DIR, `server-${port}.pid`);
 }
 function httpGet(url, timeoutMs = 2e3, headers = {}) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const req = import_http.default.get(url, { timeout: timeoutMs, headers }, (res) => {
       let data = "";
       res.on("data", (chunk) => {
         data += chunk.toString();
       });
-      res.on("end", () => resolve3({ status: res.statusCode || 0, data }));
+      res.on("end", () => resolve4({ status: res.statusCode || 0, data }));
     });
     req.on("error", reject);
     req.on("timeout", () => {
@@ -406,15 +405,30 @@ var import_http2 = __toESM(require("http"));
 var import_ws = __toESM(require("ws"));
 var import_core3 = require("@ordewell/core");
 var DEFAULT_HTTP_TIMEOUT_MS = 15 * 60 * 1e3;
-var WorkspaceInitNeededError = class extends Error {
-  constructor(message, workspace) {
+var DaemonError = class extends Error {
+  constructor(message, status, code) {
     super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "DaemonError";
+  }
+  status;
+  code;
+};
+var WorkspaceInitNeededError = class extends DaemonError {
+  constructor(message, workspace) {
+    super(message, 400, "workspace_not_a_project");
     this.workspace = workspace;
     this.name = "WorkspaceInitNeededError";
   }
   workspace;
 };
 var SESSION_PATH = /^\/api\/(?:plans|sessions)\/([^/?]+)/;
+function daemonError(status, data, fallback) {
+  const { error, code, workspace } = typeof data === "object" && data !== null ? data : {};
+  if (code === "workspace_not_a_project") return new WorkspaceInitNeededError(error || "Not a project directory", workspace ?? "");
+  return new DaemonError(error || fallback, status, code);
+}
 var ApiClient = class _ApiClient {
   /** Where a CLI invocation's sessions live, when a client is built without one: `--workspace`, else the cwd. */
   static defaultWorkspace;
@@ -422,6 +436,7 @@ var ApiClient = class _ApiClient {
   workspace;
   /** A session's open execution stream, so a new one can end it: one run is reported once. */
   executionStreams = /* @__PURE__ */ new Map();
+  executionStreamEnds = /* @__PURE__ */ new WeakMap();
   constructor(port, workspace) {
     this.port = port || DEFAULT_PORT;
     this.workspace = workspace ?? _ApiClient.defaultWorkspace ?? process.cwd();
@@ -436,7 +451,7 @@ var ApiClient = class _ApiClient {
   }
   /**
    * A daemon holds only the sessions adopted since it started, so after a
-   * restart every session-scoped call answered "Session not found" until the
+   * restart every session-scoped call answered "session not found" until the
    * user ran `ordewell sessions load`. The saved session is adopted here
    * instead — idempotent for one the daemon still holds — and the call made
    * once more; a 404 means the first attempt never ran, so the retry cannot
@@ -445,13 +460,19 @@ var ApiClient = class _ApiClient {
   async httpRequest(method, urlPath, body) {
     const res = await this.rawRequest(method, urlPath, body);
     const sessionId = urlPath.match(SESSION_PATH)?.[1];
-    const missing = res.status === 404 && res.data?.error === "Session not found";
+    const missing = res.status === 404 && res.data?.code === "session_not_found";
     if (!missing || !sessionId || urlPath.split("?")[0].endsWith("/load")) return res;
     const adopted2 = await this.rawRequest("POST", `/api/sessions/${sessionId}/load?workspace=${encodeURIComponent(this.workspace)}`);
     return adopted2.status === 200 ? this.rawRequest(method, urlPath, body) : res;
   }
+  /** One request whose only good answer is a 200: anything else becomes a {@link DaemonError} carrying the daemon's code. */
+  async call(method, urlPath, fallback, body) {
+    const res = await this.httpRequest(method, urlPath, body);
+    if (res.status !== 200) throw daemonError(res.status, res.data, fallback);
+    return res.data;
+  }
   rawRequest(method, urlPath, body) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const url = new URL(urlPath, `http://127.0.0.1:${this.port}`);
       const configuredTimeout = Number.parseInt(process.env.ORDEWELL_HTTP_TIMEOUT_MS || "", 10);
       const token = this.token();
@@ -476,9 +497,9 @@ var ApiClient = class _ApiClient {
         });
         res.on("end", () => {
           try {
-            resolve3({ status: res.statusCode || 0, data: JSON.parse(data) });
+            resolve4({ status: res.statusCode || 0, data: JSON.parse(data) });
           } catch {
-            resolve3({ status: res.statusCode || 0, data });
+            resolve4({ status: res.statusCode || 0, data });
           }
         });
       });
@@ -492,74 +513,43 @@ var ApiClient = class _ApiClient {
     });
   }
   async generatePlan(goal, runners2, workspace, sessionId = (0, import_core3.mintSessionId)()) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/generate`, {
+    const { plan, models, modelsByRunner, notes } = await this.call("POST", `/api/plans/${sessionId}/generate`, "Plan generation failed", {
       goal,
       runners: runners2 || void 0,
       workspace
     });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Plan generation failed");
-    }
-    return { sessionId, plan: res.data.plan, models: res.data.models, modelsByRunner: res.data.modelsByRunner };
+    return { sessionId, plan, models, modelsByRunner, ...notes ? { notes } : {} };
   }
   /**
-   * Open the ADR-0002 planner dialogue. Unlike `generatePlan`, this path honours
-   * the verify toggle, so the returned plan may be a question
-   * (empty `tasks`, last word in `conversationHistory`) rather than a committed plan.
+   * Open the ADR-0002 planner dialogue. Unlike `generatePlan`, the returned plan
+   * may be a question (empty `tasks`, last word in `conversationHistory`) rather
+   * than a committed plan.
    */
   async startConversation(sessionId, goal, runners2, workspace, allowInit) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/converse/start`, {
+    const res = await this.call("POST", `/api/plans/${sessionId}/converse/start`, "Planning failed", {
       goal,
       runners: runners2 || void 0,
       workspace,
       allowInit
     });
-    if (res.status !== 200) {
-      if (res.data?.code === "workspace_not_a_project") {
-        throw new WorkspaceInitNeededError(res.data.error || "Not a project directory", res.data.workspace || workspace || "");
-      }
-      throw new Error(res.data?.error || "Planning failed");
-    }
-    return res.data.plan;
+    return res.plan;
   }
   async sendConversationMessage(sessionId, message) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/converse/message`, { message });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Planner message failed");
-    }
-    return res.data.plan;
+    const res = await this.call("POST", `/api/plans/${sessionId}/converse/message`, "Planner message failed", { message });
+    return res.plan;
   }
-  async getRunners() {
-    const res = await this.httpRequest("GET", "/api/runners");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch runners");
-    }
-    return res.data;
+  getRunners() {
+    return this.call("GET", "/api/runners", "Failed to fetch runners");
   }
   /** The full provider catalog the daemon has discovered (used by the TUI model picker). */
-  async getModels() {
-    const res = await this.httpRequest("GET", "/api/models");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch models");
-    }
-    return res.data;
+  getModels() {
+    return this.call("GET", "/api/models", "Failed to fetch models");
   }
-  async setRunnerEnabled(runner, enabled) {
-    const res = await this.httpRequest("PUT", `/api/runners/${runner}`, { enabled });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || `Failed to ${enabled ? "enable" : "disable"} ${runner}`);
-    }
-    return res.data;
+  setRunnerEnabled(runner, enabled) {
+    return this.call("PUT", `/api/runners/${runner}`, `Failed to ${enabled ? "enable" : "disable"} ${runner}`, { enabled });
   }
-  async executePlan(sessionId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/execute`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Execute failed");
-    }
-    return res.data;
+  executePlan(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/execute`, "Execute failed");
   }
   /**
    * Sign off a plan waiting on `review_needed` and let it continue.
@@ -568,228 +558,111 @@ var ApiClient = class _ApiClient {
    * `resetForRun`) before approving, which is right for starting a plan and
    * wrong for releasing one that is already part-way through a review pause.
    */
-  async approveReview(sessionId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/review/approve`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Approve failed");
-    }
-    return res.data;
+  approveReview(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/review/approve`, "Approve failed");
   }
-  async markTaskComplete(sessionId, taskId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/complete`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Mark complete failed");
-    }
-    return res.data;
+  markTaskComplete(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/complete`, "Mark complete failed");
   }
-  async markTaskIncomplete(sessionId, taskId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/uncomplete`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Mark not done failed");
-    }
-    return res.data;
+  markTaskIncomplete(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/uncomplete`, "Mark not done failed");
   }
   /** run | force-start | retry | cancel — real orchestrator work, not a status patch. */
-  async taskControl(sessionId, taskId, action) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/${action}`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || `${action} failed`);
-    }
-    return res.data;
+  taskControl(sessionId, taskId, action) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/${action}`, `${action} failed`);
   }
   /** A user message to a structured task: delivered now if it waits for input, else queued behind its turn. */
-  async sendTaskMessage(sessionId, taskId, text) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages`, { text });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Send message failed");
-    }
-    return res.data;
+  sendTaskMessage(sessionId, taskId, text) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages`, "Send message failed", { text });
   }
   /** Force send: interrupt the task's running turn and deliver `text` next, ahead of anything queued (ADR-0023, F1). */
-  async forceSendTaskMessage(sessionId, taskId, text) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/now`, { text });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Send now failed");
-    }
-    return res.data;
+  forceSendTaskMessage(sessionId, taskId, text) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/now`, "Send now failed", { text });
   }
   /** Force send a message still queued; `sent` is false once the runner already has it. */
-  async forceSendQueuedTaskMessage(sessionId, taskId, messageId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}/now`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Send now failed");
-    }
-    return res.data;
+  forceSendQueuedTaskMessage(sessionId, taskId, messageId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}/now`, "Send now failed");
   }
   /** Continue a finished structured task in its saved session, with `text` as its next turn. */
-  async continueTask(sessionId, taskId, text) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/continue`, { text });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Continue failed");
-    }
-    return res.data;
+  continueTask(sessionId, taskId, text) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/continue`, "Continue failed", { text });
   }
   /** `removed` is false once the message was already delivered. */
-  async removeQueuedTaskMessage(sessionId, taskId, messageId) {
-    const res = await this.httpRequest(
-      "DELETE",
-      `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Remove message failed");
-    }
-    return res.data;
+  removeQueuedTaskMessage(sessionId, taskId, messageId) {
+    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}`, "Remove message failed");
   }
-  async interruptTask(sessionId, taskId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/interrupt`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Interrupt failed");
-    }
-    return res.data;
+  interruptTask(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/interrupt`, "Interrupt failed");
   }
   /** Let a task go on from the checkpoint it waits at; refused, with the reason, when none waits. */
-  async approveTaskCheckpoint(sessionId, taskId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/approve`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Approve checkpoint failed");
-    }
-    return res.data;
+  approveTaskCheckpoint(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/approve`, "Approve checkpoint failed");
   }
   /** Turn a task back at its checkpoint; `reason` is what the agent is told. */
-  async rejectTaskCheckpoint(sessionId, taskId, reason) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/reject`,
-      reason ? { reason } : {}
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Reject checkpoint failed");
-    }
-    return res.data;
+  rejectTaskCheckpoint(sessionId, taskId, reason) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/reject`, "Reject checkpoint failed", reason ? { reason } : {});
   }
-  async addTask(sessionId, task) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks`, task);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Add task failed");
-    }
-    return res.data;
+  addTask(sessionId, task) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks`, "Add task failed", task);
   }
-  async updateTask(sessionId, taskId, changes) {
-    const res = await this.httpRequest("PUT", `/api/plans/${sessionId}/tasks/${taskId}`, changes);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Update task failed");
-    }
-    return res.data;
+  updateTask(sessionId, taskId, changes) {
+    return this.call("PUT", `/api/plans/${sessionId}/tasks/${taskId}`, "Update task failed", changes);
   }
-  async removeTask(sessionId, taskId) {
-    const res = await this.httpRequest("DELETE", `/api/plans/${sessionId}/tasks/${taskId}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Remove task failed");
-    }
-    return res.data;
+  removeTask(sessionId, taskId) {
+    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${taskId}`, "Remove task failed");
   }
   /**
    * Make a saved session live on the server. `getSession` only reads the file;
    * until the session is adopted there is no orchestrator behind it, so
-   * execute/retry/cancel answer "Session not found".
+   * execute/retry/cancel answer `session_not_found`.
    */
   async adoptSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("POST", `/api/sessions/${sessionId}/load${qs}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to load session");
-    }
-    return { plan: res.data.plan, goal: res.data.goal ?? "" };
+    const res = await this.call("POST", `/api/sessions/${sessionId}/load${qs}`, "Failed to load session");
+    return { plan: res.plan, goal: res.goal ?? "" };
   }
-  async deleteSession(sessionId, workspace) {
+  deleteSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("DELETE", `/api/sessions/${sessionId}${qs}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Delete session failed");
-    }
-    return res.data;
+    return this.call("DELETE", `/api/sessions/${sessionId}${qs}`, "Delete session failed");
   }
   /** Copy the conversation and its tasks into a new session the daemon has already adopted. */
-  async forkConversation(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/fork`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Fork failed");
-    }
-    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan };
+  forkConversation(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/conversation/fork`, "Fork failed");
   }
   async rewindTargets(sessionId) {
-    const res = await this.httpRequest("GET", `/api/plans/${sessionId}/conversation/rewind-targets`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to list rewind targets");
-    }
-    return res.data.targets;
+    const res = await this.call("GET", `/api/plans/${sessionId}/conversation/rewind-targets`, "Failed to list rewind targets");
+    return res.targets;
   }
   /**
    * Fork the conversation from just before the user message at `index` (a
    * transcript position) into a session the daemon has already adopted. The
    * original is left as it was; `rewoundMessage` is that message in full.
    */
-  async rewindConversation(sessionId, index) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/rewind`, { index });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Rewind failed");
-    }
-    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan, rewoundMessage: res.data.rewoundMessage };
+  rewindConversation(sessionId, index) {
+    return this.call("POST", `/api/plans/${sessionId}/conversation/rewind`, "Rewind failed", { index });
   }
   /**
    * Condense the conversation into a summary. One planner call, so it can take
    * as long as a reply; a refusal or failure leaves the conversation as it was.
    */
-  async compactConversation(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/compact`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Compaction failed");
-    }
-    return { plan: res.data.plan, summary: res.data.summary, keptMessages: res.data.keptMessages };
+  compactConversation(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/conversation/compact`, "Compaction failed");
   }
   /** The dependencies a task waits on at its merge gate (ADR-0020); empty when nothing gates it. */
   async getMergeGate(sessionId, taskId) {
-    const res = await this.httpRequest(
-      "GET",
-      `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Could not read the merge gate");
-    }
-    return res.data.mergeGate ?? [];
+    const res = await this.call("GET", `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`, "Could not read the merge gate");
+    return res.mergeGate ?? [];
   }
   async reviewRunDiff(sessionId) {
-    const res = await this.httpRequest("GET", `/api/plans/${sessionId}/isolation/diff`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Could not read the diff");
-    }
-    return res.data.diff;
+    const res = await this.call("GET", `/api/plans/${sessionId}/isolation/diff`, "Could not read the diff");
+    return res.diff;
   }
   /**
    * A conflict or a block is an outcome, not an error. Passed on whole: which
    * repos blocked the merge, or landed before it stopped, is the answer.
    */
-  async mergeRun(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/isolation/merge`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Merge failed");
-    }
-    return res.data;
+  mergeRun(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/isolation/merge`, "Merge failed");
   }
   discardRun(sessionId) {
     return this.isolationAction(sessionId, "discard", "Discard failed");
@@ -804,17 +677,11 @@ var ApiClient = class _ApiClient {
     return this.isolationAction(sessionId, "run-without", "Could not continue without isolation");
   }
   async isolationAction(sessionId, segment, failure) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/isolation/${segment}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || failure);
-    }
+    await this.call("POST", `/api/plans/${sessionId}/isolation/${segment}`, failure);
   }
   async resolveConflictAsTask(sessionId, taskId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/resolve-conflict`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Could not add a resolver task");
-    }
-    return res.data.plan;
+    const res = await this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resolve-conflict`, "Could not add a resolver task");
+    return res.plan;
   }
   async closeSession(sessionId) {
     const res = await this.httpRequest("POST", `/api/sessions/${sessionId}/close`);
@@ -829,42 +696,26 @@ var ApiClient = class _ApiClient {
     const res = await this.httpRequest("POST", `/api/plans/${sessionId}/planning/stop`);
     return res.data;
   }
-  async processQueued(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/process-queued`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Process queued failed");
-    }
-    return res.data;
-  }
   async getSessions(workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
     const res = await this.httpRequest("GET", `/api/sessions${qs}`);
     return res.data || [];
   }
-  async getSession(sessionId, workspace) {
+  getSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest(
-      "GET",
-      `/api/sessions/${sessionId}${qs}`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Session not found");
-    }
-    return res.data;
+    return this.call("GET", `/api/sessions/${sessionId}${qs}`, "Session not found");
   }
   /** The attempts of a structured task that have a saved log, oldest first. */
   async getTaskLogAttempts(sessionId, taskId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log${qs}`);
-    if (res.status !== 200) throw new Error(res.data?.error || "Could not read the task log");
-    return res.data.attempts;
+    const res = await this.call("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log${qs}`, "Could not read the task log");
+    return res.attempts;
   }
   /** One attempt's saved log, for `replayTaskLog`. */
   async getTaskLog(sessionId, taskId, attempt, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log/${attempt}${qs}`);
-    if (res.status !== 200) throw new Error(res.data?.error || "Could not read the task log");
-    return res.data.events;
+    const res = await this.call("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log/${attempt}${qs}`, "Could not read the task log");
+    return res.events;
   }
   /**
    * The one place a session socket is built, so the token travels on both
@@ -895,8 +746,14 @@ var ApiClient = class _ApiClient {
     });
     return socket;
   }
+  /** Ends one stream `streamExecution` returned, leaving any newer stream the session has opened since alone. */
+  closeExecutionStream(stream) {
+    this.executionStreamEnds.get(stream)?.();
+  }
   streamExecution(sessionId, onEvent, onReady) {
-    return new Promise((resolve3, reject) => {
+    let endStream = () => {
+    };
+    const stream = new Promise((resolve4, reject) => {
       this.executionStreams.get(sessionId)?.();
       const socket = this.openSessionSocket(sessionId);
       let resolved = false;
@@ -909,9 +766,10 @@ var ApiClient = class _ApiClient {
         if (resolved) return;
         resolved = true;
         socket.close();
-        resolve3();
+        resolve4();
       };
       this.executionStreams.set(sessionId, end);
+      endStream = end;
       socket.on("open", () => {
         opened = true;
         onReady?.();
@@ -928,8 +786,12 @@ var ApiClient = class _ApiClient {
       socket.on("error", (err) => {
         forget();
         if (!opened) onReady?.(err);
-        if (!resolved) {
-          resolved = true;
+        if (resolved) return;
+        resolved = true;
+        if (opened) {
+          socket.close();
+          resolve4("lost");
+        } else {
           reject(err);
         }
       });
@@ -938,10 +800,12 @@ var ApiClient = class _ApiClient {
         if (!opened) onReady?.(new Error("Execution stream closed before connecting"));
         if (!resolved) {
           resolved = true;
-          resolve3();
+          resolve4("lost");
         }
       });
     });
+    this.executionStreamEnds.set(stream, endStream);
+    return stream;
   }
   /**
    * Answer an approval prompt: the planner's with a yes/no, a task runner's
@@ -954,7 +818,7 @@ var ApiClient = class _ApiClient {
       `/api/approvals/${encodeURIComponent(sessionId)}/${encodeURIComponent(approvalId)}`,
       typeof answer === "boolean" ? { granted: answer } : answer
     );
-    if (status !== 200) throw new Error(`Failed to answer approval ${approvalId} (HTTP ${status})`);
+    if (status !== 200) throw new DaemonError(`Failed to answer approval ${approvalId} (HTTP ${status})`, status, data.code);
     return data;
   }
   /**
@@ -964,10 +828,10 @@ var ApiClient = class _ApiClient {
    */
   streamPlanning(sessionId, onEvent) {
     const socket = this.openSessionSocket(sessionId);
-    const ready = new Promise((resolve3) => {
-      socket.once("open", () => resolve3());
-      socket.once("error", () => resolve3());
-      socket.once("close", () => resolve3());
+    const ready = new Promise((resolve4) => {
+      socket.once("open", () => resolve4());
+      socket.once("error", () => resolve4());
+      socket.once("close", () => resolve4());
     });
     socket.on("message", (data) => {
       try {
@@ -979,33 +843,11 @@ var ApiClient = class _ApiClient {
     });
     return { ready, close: () => socket.close() };
   }
-  async getCommands() {
-    const res = await this.httpRequest("GET", "/api/commands");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch commands");
-    }
-    return res.data;
+  getSettings() {
+    return this.call("GET", "/api/settings", "Failed to fetch settings");
   }
-  async sendCommand(name, args = {}) {
-    const res = await this.httpRequest("POST", `/api/commands/${name}`, { args });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || `Command ${name} failed`);
-    }
-    return res.data;
-  }
-  async getSettings() {
-    const res = await this.httpRequest("GET", "/api/settings");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch settings");
-    }
-    return res.data;
-  }
-  async updateSettings(changes) {
-    const res = await this.httpRequest("PATCH", "/api/settings", changes);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to update settings");
-    }
-    return res.data;
+  updateSettings(changes) {
+    return this.call("PATCH", "/api/settings", "Failed to update settings", changes);
   }
 };
 
@@ -1253,16 +1095,24 @@ var import_core7 = require("@ordewell/core");
 function planTasks(plan) {
   return plan ? allTasksOf(plan) : [];
 }
+function runnersOf(plan, requested) {
+  return "runners" in plan && plan.runners || requested;
+}
 function hasCommittedPlan(plan) {
   return planTasks(plan).length > 0;
 }
 function lastPlannerMessage(plan) {
-  const history = plan?.conversationHistory || [];
+  const history = "conversationHistory" in plan && plan.conversationHistory || [];
   for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i].role === "assistant") return history[i].content;
+    if (history[i].role === "assistant" && history[i].kind !== "skill_load") return history[i].content;
   }
   return "(the planner returned no plan and no message)";
 }
+function commitNotes(plan) {
+  const history = "conversationHistory" in plan && plan.conversationHistory || [];
+  const marker2 = history.map((e) => e.kind).lastIndexOf("plan_generated");
+  return marker2 < 0 ? [] : history.slice(marker2 + 1).filter((e) => e.kind === "system").map((e) => e.content);
+}
 function stdinReader(input = process.stdin) {
   const rl = (0, import_readline.createInterface)({ input, output: process.stderr });
   const buffered = [];
@@ -1270,9 +1120,9 @@ function stdinReader(input = process.stdin) {
   let ended = false;
   const settle = (answer) => {
     if (!waiting) return false;
-    const resolve3 = waiting;
+    const resolve4 = waiting;
     waiting = null;
-    resolve3(answer);
+    resolve4(answer);
     return true;
   };
   rl.on("line", (line) => {
@@ -1288,8 +1138,8 @@ function stdinReader(input = process.stdin) {
       if (ended) return Promise.resolve(null);
       rl.setPrompt(question);
       rl.prompt();
-      return new Promise((resolve3) => {
-        waiting = resolve3;
+      return new Promise((resolve4) => {
+        waiting = resolve4;
       });
     },
     close() {
@@ -1319,7 +1169,7 @@ function printPlan(plan, sessionId, runners2, models) {
     return rp ? ` (${task.assignedModel.modelLabel} \xB7 ${label})` : ` (${task.assignedModel.modelLabel})`;
   };
   console.log(`
-Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${manCount} Manual) \u2014 ${(plan.runners || runners2).join(", ")}`);
+Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${manCount} Manual) \u2014 ${runnersOf(plan, runners2).join(", ")}`);
   console.log(`Session: ${sessionId}
 `);
   for (const t of tasks) {
@@ -1423,6 +1273,7 @@ async function handlePlan(subArgs, deps = {}) {
     await stream.ready;
     let plan;
     let models = [];
+    let notes = [];
     if (oneShot) {
       const result = await withSpinner(
         "Researching codebase and building task plan",
@@ -1430,6 +1281,7 @@ async function handlePlan(subArgs, deps = {}) {
       );
       plan = result.plan;
       models = result.models ?? [];
+      notes = result.notes ?? [];
     } else {
       plan = await withSpinner(
         "Researching codebase and building task plan",
@@ -1461,12 +1313,15 @@ ${lastPlannerMessage(plan)}
         plan = await withSpinner("Thinking", () => api.sendConversationMessage(sessionId, reply));
       }
       reader?.close();
+      notes = commitNotes(plan);
     }
     closeStream();
     if (isTty && lastLineLength > 0) process.stderr.write("\r\x1B[2K");
     process.stderr.write("\n");
     printPlan(plan, sessionId, runners2, models);
-    saveLastSession(sessionId, goal, plan.runners || runners2, workspace);
+    for (const note of notes) console.log(`
+${note}`);
+    saveLastSession(sessionId, goal, runnersOf(plan, runners2), workspace);
     console.log(`
   Run 'ordewell run' to execute, 'ordewell status' to inspect, or 'ordewell tui' for the full UI.`);
   } catch (err) {
@@ -1584,23 +1439,27 @@ function mergeOutcome(result, branch, group, repaired = []) {
 }
 
 // src/utils/output.ts
+var import_core9 = require("@ordewell/core");
 function iconFor(status) {
-  switch (status) {
-    case "completed":
+  switch ((0, import_core9.taskStatusKind)({ status })) {
+    case "done":
       return "\x1B[32m\u2713\x1B[0m";
-    case "in_progress":
+    case "running":
+    case "quiet":
       return "\x1B[34m\u27F3\x1B[0m";
     case "failed":
       return "\x1B[31m\u2717\x1B[0m";
     case "blocked":
       return "\x1B[33m\u2298\x1B[0m";
-    default:
+    case "awaiting":
+      return "\x1B[33m?\x1B[0m";
+    case "todo":
       return "\x1B[90m\u25CB\x1B[0m";
   }
 }
 
 // src/commands/run.ts
-var import_core9 = require("@ordewell/core");
+var import_core10 = require("@ordewell/core");
 
 // src/commands/shared.ts
 var import_readline2 = require("readline");
@@ -1664,7 +1523,7 @@ async function askYesNo(question) {
   if (!process.stdin.isTTY) return false;
   const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stderr });
   try {
-    const answer = await new Promise((resolve3) => rl.question(`${question} [y/N] `, resolve3));
+    const answer = await new Promise((resolve4) => rl.question(`${question} [y/N] `, resolve4));
     return /^y(es)?$/i.test(answer.trim());
   } finally {
     rl.close();
@@ -1696,7 +1555,8 @@ function toTaskView(task) {
     taskMode: task.taskMode || void 0,
     assignedModel: task.assignedModel ?? void 0,
     subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView),
-    ...task.ops ? { ops: true } : {}
+    ...task.ops ? { ops: true } : {},
+    ...task.skills?.length ? { skills: [...task.skills] } : {}
   };
 }
 function taskViews(plan) {
@@ -1746,21 +1606,21 @@ async function followExecution(api, sessionId, start, onBlocked) {
   let pausedAtGate = false;
   let noteBlocked = () => {
   };
-  const blockedSeen = new Promise((resolve3) => {
-    noteBlocked = resolve3;
+  const blockedSeen = new Promise((resolve4) => {
+    noteBlocked = resolve4;
   });
   let settleReady = () => {
   };
-  const streamReady = new Promise((resolve3, reject) => {
-    settleReady = (error) => error ? reject(error) : resolve3();
+  const streamReady = new Promise((resolve4, reject) => {
+    settleReady = (error) => error ? reject(error) : resolve4();
   });
   const stream = api.streamExecution(sessionId, (event) => {
     if (event.type === "task_started") {
-      process.stderr.write(`\xB7 ${(0, import_core9.taskStartedNotice)(event.title, event.runner)}
+      process.stderr.write(`\xB7 ${(0, import_core10.taskStartedNotice)(event.title, event.runner)}
 `);
     }
     if (event.type === "checkpoint") {
-      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core9.truncateCheckpointSummary)(event.summary)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
+      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core10.truncateCheckpointSummary)(event.summary)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
 `);
     }
     if (event.type === "status_update" && event.tasks) {
@@ -1805,7 +1665,11 @@ Run finished on ${handoffBranch(event)}${where} \u2014 ${n} task${n === 1 ? "" :
   void stream.catch(settleReady);
   await streamReady.catch(streamFailed);
   await start();
-  await Promise.race([stream, blockedSeen]).catch(streamFailed);
+  const outcome = await Promise.race([stream, blockedSeen]).catch(streamFailed);
+  if (outcome === "lost") {
+    console.error("Lost the connection to the daemon \u2014 the run is no longer being followed, but the daemon may still be running it. `ordewell status` shows where it stands.");
+    process.exit(1);
+  }
   if (blocked === null) return;
   if (!onBlocked) {
     await api.stopExecution(sessionId);
@@ -1833,7 +1697,7 @@ async function handleRun(subArgs, injectedApi) {
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
-var import_core10 = require("@ordewell/core");
+var import_core11 = require("@ordewell/core");
 async function handleStatus(subArgs, injectedApi) {
   const sessionId = flag(subArgs, "--session-id");
   const workspace = flag(subArgs, "--workspace") || process.cwd();
@@ -1904,12 +1768,12 @@ function printOneSession(sessionId, meta, plan) {
     const icon = iconFor(t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
-    console.log(`  ${(0, import_core10.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
+    console.log(`  ${(0, import_core11.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
     for (const sub of t.subtasks || []) {
       const subIcon = iconFor(sub.status);
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
-      console.log(`    ${(0, import_core10.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
+      console.log(`    ${(0, import_core11.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
     }
   }
 }
@@ -1961,10 +1825,10 @@ async function handleWeb(subArgs) {
 }
 
 // src/commands/models.ts
-var import_core12 = require("@ordewell/core");
+var import_core13 = require("@ordewell/core");
 
 // src/commands/model.ts
-var import_core11 = require("@ordewell/core");
+var import_core12 = require("@ordewell/core");
 var USAGE = "Usage: ordewell model [show | set <model-id>]";
 async function handleModel(subArgs, injectedApi) {
   const [action, modelId] = positionals(subArgs);
@@ -1979,7 +1843,7 @@ async function handleModel(subArgs, injectedApi) {
   if (!modelId) fail(USAGE);
   const settings = await api.getSettings();
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  const runner = (0, import_core11.runnerForProvider)(provider);
+  const runner = (0, import_core12.runnerForProvider)(provider);
   if (runner) {
     const known = (await fetchCatalog(api)).models.filter((m) => m.runners?.includes(runner));
     if (known.length > 0 && !known.some((m) => m.id === modelId)) {
@@ -1998,7 +1862,7 @@ async function showModels(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const current = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const runner = (0, import_core11.runnerForProvider)(provider);
+  const runner = (0, import_core12.runnerForProvider)(provider);
   const options = runner ? catalog.models.filter((m) => m.runners?.includes(runner)) : catalog.orchestratorModels;
   console.log(`
 Planner model: ${current || "(backend default)"}`);
@@ -2032,8 +1896,8 @@ async function handleModels(subArgs) {
     const rest = subArgs.filter((_, i) => i !== setIdx && i !== setIdx + 1);
     return handleModel(["set", subArgs[setIdx + 1], ...rest]);
   }
-  const config = new import_core12.EnvConfig();
-  const providers = (0, import_core12.configuredProviders)(config);
+  const config = new import_core13.EnvConfig();
+  const providers = (0, import_core13.configuredProviders)(config);
   if (providers.length === 0) {
     console.error("No providers configured. Set an API key for a provider, e.g.:");
     console.error("  OPENROUTER_API_KEY=...   (OpenRouter)");
@@ -2042,19 +1906,19 @@ async function handleModels(subArgs) {
     console.error("  OPENAI_COMPATIBLE_BASE_URL=...  (self-hosted / OpenAI-compatible)");
     process.exit(1);
   }
-  const { apiKeys, baseUrls } = (0, import_core12.collectProviderCredentials)(config);
+  const { apiKeys, baseUrls } = (0, import_core13.collectProviderCredentials)(config);
   let models;
   let errors;
   try {
-    const result = await (0, import_core12.fetchAllProviderModels)({ apiKeys, baseUrls });
-    models = (0, import_core12.toOrchestratorOptions)(result.models, import_core12.ORCHESTRATOR_SHORTCUTS);
+    const result = await (0, import_core13.fetchAllProviderModels)({ apiKeys, baseUrls });
+    models = (0, import_core13.toOrchestratorOptions)(result.models, import_core13.ORCHESTRATOR_SHORTCUTS);
     errors = result.errors;
   } catch (err) {
     console.error(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
     return;
   }
-  const providerLabel = (p) => (0, import_core12.getProviderMeta)(p)?.label ?? p;
+  const providerLabel = (p) => (0, import_core13.getProviderMeta)(p)?.label ?? p;
   console.log(
     `
 Available models (${models.length}) across ${providers.length} configured provider(s):`
@@ -2094,7 +1958,7 @@ ${providerLabel(provider)}`);
 
 // src/commands/setup.ts
 var import_fs6 = require("fs");
-var import_core13 = require("@ordewell/core");
+var import_core14 = require("@ordewell/core");
 function handleSetup(subArgs) {
   const modelIdx = subArgs.indexOf("--model");
   const chosenModel = modelIdx !== -1 ? subArgs[modelIdx + 1] : null;
@@ -2166,105 +2030,65 @@ function handleSetup(subArgs) {
 # STEPFUN_API_KEY=...
 # SILICONFLOW_API_KEY=...
 `;
-  (0, import_core13.writePrivateFile)(envFile, content);
+  (0, import_core14.writePrivateFile)(envFile, content);
   console.log(`Wrote: ${envFile}`);
   console.log("Review and edit the file, then run: ordewell tui");
 }
 
-// src/commands/plugins.ts
-var import_core14 = require("@ordewell/core");
-function handlePlugins(subArgs) {
-  const registry = new import_core14.RunnerRegistry();
-  registry.loadUserPlugins();
-  const sub = subArgs[0];
-  if (sub === "list" || !sub) {
-    const plugins = registry.list();
-    if (plugins.length === 0) {
-      console.log("No plugins installed.");
-      return;
-    }
-    const nameWidth = Math.max(...plugins.map((p) => p.manifest.name.length), 4);
-    const versionWidth = Math.max(...plugins.map((p) => p.manifest.version.length), 7);
-    const sourceWidth = Math.max(...plugins.map((p) => p.source.length), 6);
-    console.log(`
-${plugins.length} plugin(s):
-`);
-    console.log(
-      `${"Name".padEnd(nameWidth)}  ${"Version".padEnd(versionWidth)}  ${"Source".padEnd(sourceWidth)}  Description`
-    );
-    console.log(
-      `${"-".repeat(nameWidth)}  ${"-".repeat(versionWidth)}  ${"-".repeat(sourceWidth)}  ${"-".repeat(20)}`
-    );
-    for (const p of plugins) {
-      const status = p.source === "builtin" ? "(built-in)" : "user";
-      console.log(
-        `${p.manifest.name.padEnd(nameWidth)}  ${p.manifest.version.padEnd(versionWidth)}  ${status.padEnd(sourceWidth)}  ${p.manifest.description}`
-      );
-    }
-    return;
-  }
-  if (sub === "install") {
-    const source = subArgs[1];
-    if (!source) {
-      console.error("Usage: ordewell plugins install <path|github:user/repo|name>");
-      process.exit(1);
-    }
-    try {
-      const resolved = (0, import_core14.classifyPluginSource)(source);
-      const manifest = resolved.kind === "git" ? registry.installFromGit(resolved.url) : registry.installFromPath(resolved.path);
-      console.log(`Installed plugin: ${manifest.name} v${manifest.version}`);
-    } catch (err) {
-      console.error(`Install failed: ${err.message}`);
-      process.exit(1);
-    }
-    return;
-  }
-  if (sub === "remove") {
-    const name = subArgs[1];
-    if (!name) {
-      console.error("Usage: ordewell plugins remove <name>");
-      process.exit(1);
-    }
-    try {
-      registry.remove(name);
-      console.log(`Removed plugin: ${name}`);
-    } catch (err) {
-      console.error(`Remove failed: ${err.message}`);
-      process.exit(1);
-    }
+// src/commands/skills.ts
+var import_core15 = require("@ordewell/core");
+var import_path5 = require("path");
+function invocation(skill) {
+  if (skill.userInvocable && skill.modelInvocable) return "both";
+  if (skill.userInvocable) return "user";
+  if (skill.modelInvocable) return "model";
+  return "none";
+}
+function handleSkills(subArgs) {
+  if (positionals(subArgs).length > 0) {
+    fail("Usage: ordewell skills [--workspace /path] [--json]");
+  }
+  const workspace = (0, import_path5.resolve)(flag(subArgs, "--workspace") || process.cwd());
+  const catalog = (0, import_core15.createSkillsService)(workspace, new import_core15.EnvConfig().workspaceRepos).readCatalog();
+  const skills = catalog.skills.map((skill) => ({
+    name: skill.name,
+    scope: skill.source,
+    appliesTo: skill.appliesTo,
+    invocation: invocation(skill),
+    path: (0, import_core15.abbreviateHome)(skill.path)
+  }));
+  const shadowed = catalog.shadowed.map(({ skill, shadowedBy }) => ({
+    name: skill.name,
+    path: (0, import_core15.abbreviateHome)(skill.path),
+    shadowedBy: { scope: shadowedBy.source, path: (0, import_core15.abbreviateHome)(shadowedBy.path) }
+  }));
+  const invalid = catalog.invalid.map((skill) => ({
+    name: skill.name,
+    path: (0, import_core15.abbreviateHome)(skill.path),
+    reason: skill.reason
+  }));
+  if (hasFlag(subArgs, "--json")) {
+    console.log(JSON.stringify({ skills, shadowed, invalid }, null, 2));
     return;
   }
-  if (sub === "create") {
-    const name = subArgs[1];
-    if (!name) {
-      console.error("Usage: ordewell plugins create <name>");
-      process.exit(1);
-    }
-    const dir = registry.createSkeleton(name, process.cwd());
-    console.log(`Created plugin skeleton: ${dir}`);
-    console.log(`  Edit ${dir}/manifest.json to configure your runner`);
-    console.log(`  Then install with: ordewell plugins install ${dir}`);
+  const skipped = [
+    ...shadowed.map((skill) => `workspace skill "${skill.name}" shadowed by the ${skill.shadowedBy.scope} copy at ${skill.shadowedBy.path} \xB7 ${skill.path}`),
+    ...invalid.map((skill) => `skill folder "${skill.name}" skipped: ${skill.reason} \xB7 ${skill.path}`)
+  ];
+  if (skills.length === 0) {
+    console.log("No skills installed.");
+    for (const line of skipped) console.log(line);
     return;
   }
-  console.error(`Unknown plugins subcommand: ${sub}`);
-  console.error("Available: list, install <source>, remove <name>, create <name>");
-  process.exit(1);
-}
-
-// src/commands/tdd.ts
-async function handleTdd(subArgs) {
-  const action = subArgs[0];
-  const port = await ensureDaemon(resolvePort(subArgs));
-  const api = new ApiClient(port);
-  if (action === "on" || action === "off") {
-    const result = await api.sendCommand("tdd", { action });
-    const state = result.settings?.tdd;
-    console.log(`TDD mode: ${state?.enabled ? "ON" : "OFF"}`);
-  } else {
-    const settings = await api.getSettings();
-    const tdd = settings.tdd;
-    console.log(`TDD mode: ${tdd?.enabled ? "ON" : "OFF"}`);
-    console.log("Usage: ordewell tdd [on|off]");
+  const headers = ["Name", "Scope", "Applies-to", "Invocation", "SKILL.md"];
+  const rows = skills.map((skill) => [skill.name, skill.scope, skill.appliesTo, skill.invocation, skill.path]);
+  const widths = headers.map((header, i) => Math.max(header.length, ...rows.map((row) => row[i].length)));
+  const format = (row) => row.map((cell, i) => i === row.length - 1 ? cell : cell.padEnd(widths[i])).join("  ");
+  console.log(format(headers));
+  for (const row of rows) console.log(format(row));
+  if (skipped.length > 0) {
+    console.log("");
+    for (const line of skipped) console.log(line);
   }
 }
 
@@ -2354,41 +2178,8 @@ async function handleShow(args, api) {
   }
 }
 
-// src/commands/verify.ts
-async function handleVerify(subArgs, api) {
-  const action = subArgs[0];
-  const port = api ? void 0 : await ensureDaemon(resolvePort(subArgs));
-  const client = api || new ApiClient(port);
-  if (action === "on" || action === "off") {
-    const result = await client.sendCommand("verify", { action });
-    const state = result.settings?.verification;
-    console.log(`Verification mode: ${state?.enabled ? "ON" : "OFF"}`);
-  } else {
-    const settings = await client.getSettings();
-    const verification = settings.verification;
-    console.log(`Verification mode: ${verification?.enabled ? "ON" : "OFF"}`);
-    console.log("Usage: ordewell verify [on|off]");
-  }
-}
-
-// src/commands/transport.ts
-var describe = (transport) => `Runner transport: ${transport === "terminal" ? "terminal" : "structured"} \u2014 applies from the next run`;
-async function handleTransport(subArgs, api) {
-  const action = subArgs[0];
-  const port = api ? void 0 : await ensureDaemon(resolvePort(subArgs));
-  const client = api || new ApiClient(port);
-  if (action === "terminal" || action === "structured") {
-    const result = await client.sendCommand("transport", { action });
-    console.log(describe(result.settings?.runnerTransport));
-  } else {
-    const settings = await client.getSettings();
-    console.log(describe(settings.runnerTransport));
-    console.log("Usage: ordewell transport [terminal|structured]");
-  }
-}
-
 // src/commands/task-control.ts
-var import_core15 = require("@ordewell/core");
+var import_core16 = require("@ordewell/core");
 var PAST_TENSE = {
   run: "Task started.",
   "force-start": "Task force-started.",
@@ -2431,7 +2222,7 @@ async function confirmPastGate(subArgs, api, sessionId, taskId, confirm) {
   if (hasFlag(subArgs, "--yes")) return;
   const unmerged = await api.getMergeGate(sessionId, taskId).catch(() => []);
   if (unmerged.length === 0) return;
-  const question = `${(0, import_core15.pastGateConfirmation)(unmerged.map((d) => (0, import_core15.titledTaskRef)(d)))} Start it anyway?`;
+  const question = `${(0, import_core16.pastGateConfirmation)(unmerged.map((d) => (0, import_core16.titledTaskRef)(d)))} Start it anyway?`;
   if (!await confirm(question)) fail("Not started \u2014 nothing was changed. Pass --yes to start it without a prompt.");
 }
 function makeHandler(action, command = action) {
@@ -2744,24 +2535,24 @@ async function handleRewind(subArgs, injectedApi) {
 }
 
 // src/tui/transcript.ts
-var import_core16 = require("@ordewell/core");
+var import_core17 = require("@ordewell/core");
 function show(state, { view: conversation, gate: turnGate }) {
   const gated = turnGate === state.turnGate ? state : { ...state, turnGate };
   if (conversation === state.conversation) return gated;
   return { ...gated, conversation };
 }
 function fold(state, input) {
-  return show(state, { view: (0, import_core16.reduceConversation)(state.conversation, input), gate: state.turnGate });
+  return show(state, { view: (0, import_core17.reduceConversation)(state.conversation, input), gate: state.turnGate });
 }
 function say(state, role, text) {
   const said = fold(state, { type: "local_entry", role, text });
   return said.conversation.nextId > state.conversation.nextId ? { ...said, scroll: 0 } : said;
 }
 function hear(state, message) {
-  return show(state, (0, import_core16.followTurn)(state.conversation, state.turnGate, message));
+  return show(state, (0, import_core17.followTurn)(state.conversation, state.turnGate, message));
 }
 function cutTurn(state) {
-  return show(state, (0, import_core16.stopTurn)(state.conversation, state.turnGate));
+  return show(state, (0, import_core17.stopTurn)(state.conversation, state.turnGate));
 }
 function wiped(view) {
   return { ...view, blocks: view.blocks.filter((b) => b.type === "usage") };
@@ -3175,26 +2966,17 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core17 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 
 // src/plannerModelSwitch.ts
-function describePlannerSwitch(settings, provider) {
-  const model = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const effort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  if (!model) return { model: "", effort: "", source: "none" };
-  return rememberedModelFor(settings, provider) === model ? { model, effort, source: "remembered" } : { model, effort, source: "catalog-default" };
-}
-function rememberedModelFor(settings, provider) {
-  const map = settings.plannerModels;
-  if (!map || typeof map !== "object") return void 0;
-  const entry = map[provider];
-  if (!entry || typeof entry !== "object") return void 0;
-  const { model } = entry;
-  return typeof model === "string" ? model : void 0;
+function plannerSwitchRecall(settings) {
+  if (settings.switchRecall) return settings.switchRecall;
+  const model = settings.orchestratorModel;
+  return model ? { model, effort: settings.plannerThinkingEffort, source: "remembered" } : { model: "", effort: "", source: "none" };
 }
 
 // src/commands/planner.ts
-var KNOWN_PROVIDERS = Object.keys(import_core17.ALL_PROVIDERS);
+var isAiProvider = (id) => Object.hasOwn(import_core18.ALL_PROVIDERS, id);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -3203,19 +2985,19 @@ async function handlePlanner(subArgs, injectedApi) {
     return;
   }
   const provider = wanted.toLowerCase();
-  if (!KNOWN_PROVIDERS.includes(provider)) {
+  if (!isAiProvider(provider)) {
     fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
   }
   const settings = await persistEnv(api, { AI_PROVIDER: provider });
-  const recall2 = describePlannerSwitch(settings, provider);
+  const recall2 = plannerSwitchRecall(settings);
   writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
-  const meta = import_core17.ALL_PROVIDERS[provider];
+  const meta = import_core18.ALL_PROVIDERS[provider];
   const catalog = await fetchCatalog(api);
   console.log(
-    (0, import_core17.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
+    (0, import_core18.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
   console.log(plannerModelLine(recall2));
-  if (!(0, import_core17.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+  if (!(0, import_core18.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
     console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
@@ -3233,15 +3015,15 @@ async function showPlanners(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
-  for (const id of import_core17.CLI_PROVIDERS) {
-    const runner = (0, import_core17.runnerForProvider)(id);
+  for (const id of import_core18.CLI_PROVIDERS) {
+    const runner = (0, import_core18.runnerForProvider)(id);
     const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core17.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core18.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
   }
   console.log("\nAPI providers");
-  for (const id of import_core17.PROVIDER_PRIORITY) {
+  for (const id of import_core18.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core17.ALL_PROVIDERS[id];
+    const meta = import_core18.ALL_PROVIDERS[id];
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -3258,7 +3040,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
   const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  const runner = (0, import_core17.runnerForProvider)(provider);
+  const runner = isAiProvider(provider) ? (0, import_core18.runnerForProvider)(provider) : null;
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -3298,7 +3080,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core18 = require("@ordewell/core");
+var import_core19 = require("@ordewell/core");
 var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
 async function handleParallel(subArgs, injectedApi) {
   const [wanted] = positionals(subArgs);
@@ -3308,14 +3090,14 @@ async function handleParallel(subArgs, injectedApi) {
     console.log(`Up to ${String(settings.maxParallel ?? "?")} AI tasks run at once. Change with: ordewell parallel <n>`);
     return;
   }
-  const limit = (0, import_core18.parseMaxParallel)(wanted);
+  const limit = (0, import_core19.parseMaxParallel)(wanted);
   if (limit === null) fail(`"${wanted}" is not a number of tasks (1 or more).`, USAGE5);
   await persistEnv(api, { ORDEWELL_MAX_PARALLEL: String(limit) });
   console.log(`Up to ${limit} AI task${limit === 1 ? "" : "s"} now run at once.`);
 }
 
 // src/commands/key.ts
-var import_core19 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 var USAGE6 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
@@ -3326,8 +3108,8 @@ async function handleKey(subArgs, injectedApi) {
   if (action !== "set") {
     const catalog = await fetchCatalog(api);
     console.log("\nAPI provider keys\n");
-    for (const id2 of import_core19.PROVIDER_PRIORITY) {
-      const meta2 = import_core19.ALL_PROVIDERS[id2];
+    for (const id2 of import_core20.PROVIDER_PRIORITY) {
+      const meta2 = import_core20.ALL_PROVIDERS[id2];
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
@@ -3337,7 +3119,7 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core19.ALL_PROVIDERS[id];
+  const meta = import_core20.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -3348,7 +3130,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var import_core20 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 var USAGE7 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
@@ -3379,15 +3161,15 @@ function handleAuto(subArgs) {
   const currentRaw = process.env.ORDEWELL_AUTONOMOUS_MODE;
   const current = currentRaw !== "false" && currentRaw !== "0";
   if (!arg) {
-    console.log(`Autonomy level: ${(0, import_core20.autonomyLevelLabel)(current)}`);
+    console.log(`Autonomy level: ${(0, import_core21.autonomyLevelLabel)(current)}`);
     console.log(`  ${AUTO_USAGE}`);
     return;
   }
-  const enabled = (0, import_core20.parseAutonomyLevel)(arg);
+  const enabled = (0, import_core21.parseAutonomyLevel)(arg);
   if (enabled === null) fail(AUTO_USAGE);
   writeEnvVar(findEnvFile(), "ORDEWELL_AUTONOMOUS_MODE", String(enabled));
   process.env.ORDEWELL_AUTONOMOUS_MODE = String(enabled);
-  console.log(`Autonomy level: ${(0, import_core20.autonomyLevelLabel)(enabled)} for new sessions.`);
+  console.log(`Autonomy level: ${(0, import_core21.autonomyLevelLabel)(enabled)} for new sessions.`);
 }
 async function handleRefresh(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
@@ -3416,130 +3198,8 @@ async function handleApprove(subArgs, injectedApi) {
   });
 }
 
-// src/tui/terminalLauncher.ts
-var import_child_process3 = require("child_process");
-var import_util = require("util");
-var import_core21 = require("@ordewell/core");
-var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
-var defaultExecFile = async (command, args) => {
-  const { stdout, stderr } = await execFileAsync(command, args);
-  return { stdout: String(stdout), stderr: String(stderr) };
-};
-var defaultSpawn = (command, args) => {
-  (0, import_child_process3.spawn)(command, args, { detached: true, stdio: "ignore" }).unref();
-};
-var defaultWhich = (bin) => {
-  try {
-    (0, import_child_process3.execSync)(`${process.platform === "win32" ? "where" : "which"} ${bin}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-};
-async function openTaskTerminal(port, planSessionId, taskId, deps = {}) {
-  const platform = deps.platform ?? process.platform;
-  const env = deps.env ?? process.env;
-  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core21.hasTmux;
-  const execFileImpl = deps.execFileImpl ?? defaultExecFile;
-  const spawnImpl = deps.spawnImpl ?? defaultSpawn;
-  const which = deps.which ?? defaultWhich;
-  if (!hasTmuxImpl()) {
-    return { ok: false, message: "No terminal window for this task: tmux is not installed. Install tmux to get one for terminal-transport tasks; a structured task has its log view instead." };
-  }
-  const session = (0, import_core21.tmuxSessionName)(port);
-  const socket = (0, import_core21.tmuxSocketName)(port);
-  const base = (0, import_core21.tmuxWindowName)(taskId, planSessionId);
-  let windows;
-  try {
-    const { stdout } = await execFileImpl("tmux", ["-L", socket, "list-windows", "-t", session, "-F", "#{window_name}"]);
-    windows = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-  } catch {
-    return { ok: false, message: "No terminal session found for this daemon \u2014 is it still running?" };
-  }
-  const window = latestAttempt(windows, base);
-  if (!window) {
-    return { ok: false, message: "This task has no live terminal and no saved log \u2014 it may still be pending." };
-  }
-  const manualHint = `tmux -L ${socket} attach -t ${session}:${window}`;
-  const viewer = `${session}-view-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const attachCmd = `tmux -L ${socket} new-session -d -s ${viewer} -t ${session} \\; set-option -t ${viewer} destroy-unattached on \\; select-window -t ${viewer}:${window} \\; attach-session -t ${viewer}`;
-  const opened = launchTerminal(platform, env, which, spawnImpl, attachCmd);
-  if (!opened) {
-    return { ok: false, message: `Couldn't open a terminal window automatically \u2014 attach manually: ${manualHint}` };
-  }
-  return { ok: true, message: "Opened a terminal for this task." };
-}
-function latestAttempt(windows, base) {
-  let best = null;
-  let bestAttempt = 0;
-  for (const name of windows) {
-    if (name === base && bestAttempt < 1) {
-      best = name;
-      bestAttempt = 1;
-      continue;
-    }
-    const suffix = name.startsWith(`${base}-`) ? Number(name.slice(base.length + 1)) : NaN;
-    if (Number.isInteger(suffix) && suffix > bestAttempt) {
-      best = name;
-      bestAttempt = suffix;
-    }
-  }
-  return best;
-}
-function launchTerminal(platform, env, which, spawnImpl, attachCmd) {
-  if (platform === "darwin") {
-    const script = `tell application "Terminal" to do script "${attachCmd.replace(/"/g, '\\"')}"`;
-    spawnImpl("osascript", ["-e", script]);
-    return true;
-  }
-  if (platform === "win32") {
-    if (which("wt.exe")) {
-      spawnImpl("wt.exe", ["-w", "0", "nt", "bash", "-lc", attachCmd]);
-      return true;
-    }
-    if (which("cmd.exe")) {
-      spawnImpl("cmd.exe", ["/c", "start", '""', "bash", "-lc", attachCmd]);
-      return true;
-    }
-    return false;
-  }
-  if (!env.DISPLAY && !env.WAYLAND_DISPLAY) return false;
-  const candidates = [];
-  if (env.TERMINAL) candidates.push([env.TERMINAL, ["-e", "bash", "-lc", attachCmd]]);
-  candidates.push(
-    ["x-terminal-emulator", ["-e", "bash", "-lc", attachCmd]],
-    ["gnome-terminal", ["--", "bash", "-lc", attachCmd]],
-    ["konsole", ["-e", "bash", "-lc", attachCmd]],
-    ["xfce4-terminal", ["-e", `bash -lc ${JSON.stringify(attachCmd)}`]],
-    ["xterm", ["-e", "bash", "-lc", attachCmd]]
-  );
-  for (const [bin, args] of candidates) {
-    if (which(bin)) {
-      spawnImpl(bin, args);
-      return true;
-    }
-  }
-  return false;
-}
-
-// src/commands/terminal.ts
-async function handleTerminal(subArgs, injectedApi) {
-  await withResolvedTask(
-    subArgs,
-    "Usage: ordewell terminal <task-id-or-order> [--session-id <id>]",
-    injectedApi,
-    async (_api, sessionId, taskId) => {
-      const result = await openTaskTerminal(resolvePort(subArgs), sessionId, taskId);
-      if (!result.ok) {
-        console.error(result.message);
-        process.exit(1);
-      }
-      console.log(result.message);
-    }
-  );
-}
-
 // src/commands/task-assign.ts
+var import_core22 = require("@ordewell/core");
 var import_plan_utils = require("@ordewell/core/plan-utils");
 
 // src/tui/taskAssignment.ts
@@ -3579,12 +3239,13 @@ function modesForTask(modesByRunner, task) {
 }
 
 // src/commands/task-assign.ts
-async function withTask(subArgs, usage, injectedApi, run) {
+async function withTask(subArgs, usage, injectedApi, run, { joinValue = false } = {}) {
   await withResolvedTask(subArgs, usage, injectedApi, async (api, sessionId, taskId, plan) => {
     const tasks = taskViews(plan);
     const task = tasks.find((t) => t.id === taskId);
     if (!task) fail(`Task not found in the plan: ${taskId}`);
-    const value = positionals(subArgs)[1];
+    const [, ...rest] = positionals(subArgs);
+    const value = joinValue ? rest.join(" ") || void 0 : rest[0];
     await run(api, sessionId, task, tasks, value);
   });
 }
@@ -3740,6 +3401,35 @@ Dependencies \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}
     console.log(dependencies.length > 0 ? `Task ${(0, import_plan_utils.taskRef)(task)} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task ${(0, import_plan_utils.taskRef)(task)} no longer depends on anything.`);
   });
 }
+var SKILLS_USAGE = "Usage: ordewell task-skills <task-id-or-order> [<name> [<name> \u2026]|<name,name,\u2026>|none] [--session-id <id>] [--workspace <path>]";
+async function handleTaskSkills(subArgs, injectedApi) {
+  await withTask(subArgs, SKILLS_USAGE, injectedApi, async (api, sessionId, task, _tasks, value) => {
+    if (task.type !== "ai") fail("Manual tasks do not run an executor, so they take no skills.");
+    const catalog = (0, import_core22.createSkillsService)(flag(subArgs, "--workspace") || process.cwd(), new import_core22.EnvConfig().workspaceRepos).listSkills().filter((s) => s.appliesTo === "task");
+    if (!value) {
+      console.log(`
+Skills \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}
+`);
+      if (catalog.length === 0) console.log("  No task skills found (applies-to: task in .ordewell/skills/ or ~/.ordewell/skills/).");
+      for (const s of catalog) {
+        console.log(`  ${task.skills?.includes(s.name) ? "*" : " "} ${s.name}${s.description ? `  ${s.description}` : ""}`);
+      }
+      for (const name of task.skills ?? []) {
+        if (!catalog.some((s) => s.name === name)) console.log(`  * ${name} (not found)`);
+      }
+      console.log(`
+  * = attached. ${SKILLS_USAGE}`);
+      return;
+    }
+    const skills = value.toLowerCase() === "none" ? [] : [...new Set(value.toLowerCase().split(/[,\s]+/).filter(Boolean))];
+    const unknown = skills.filter((name) => !catalog.some((s) => s.name === name));
+    if (unknown.length > 0) {
+      fail(`No task skill named ${unknown.map((n) => `"${n}"`).join(", ")}.`, `Task skills: ${catalog.map((s) => s.name).join(", ") || "none"}`);
+    }
+    await api.updateTask(sessionId, task.id, { skills });
+    console.log(skills.length > 0 ? `Task ${(0, import_plan_utils.taskRef)(task)} skills set to ${skills.join(", ")}.` : `Task ${(0, import_plan_utils.taskRef)(task)} has no skills attached.`);
+  }, { joinValue: true });
+}
 var OPS_USAGE = "Usage: ordewell task-ops <task-id-or-order> [on|off] [--session-id <id>]";
 async function handleTaskOps(subArgs, injectedApi) {
   await withTask(subArgs, OPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
@@ -3760,7 +3450,7 @@ ${(0, import_plan_utils.titledTaskRef)(task)} is ${task.ops ? "an ops task: it r
 }
 
 // src/tui/index.ts
-var import_core36 = require("@ordewell/core");
+var import_core37 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3910,12 +3600,12 @@ var SLASH_COMMANDS = [
   { name: "force-start", usage: "/force-start <id>", description: "Start a task now, ignoring dependencies", category: "tasks" },
   { name: "continue", usage: "/continue <id> <message>", description: "Continue a finished task in its saved runner session, with your message", category: "tasks" },
   { name: "checkpoint", usage: "/checkpoint <id> approve|reject [reason]", description: "Answer the checkpoint a task waits at: approve lets it go on, reject tells it why not", category: "tasks" },
-  { name: "terminal", usage: "/terminal <id>", description: "Open a task: its OS terminal, or a structured task's live log", category: "tasks" },
   { name: "task-runner", usage: "/task-runner <id> [runner]", description: "Choose or set a task's executor (re-picks its model and mode)", category: "tasks" },
   { name: "task-model", usage: "/task-model <id> [model]", description: "Choose or set a task's executor model", category: "tasks" },
   { name: "task-effort", usage: "/task-effort <id> [level]", description: "Choose or set a task's thinking effort", category: "tasks" },
   { name: "task-mode", usage: "/task-mode <id> [mode]", description: "Choose or set a task's runner mode", category: "tasks" },
   { name: "task-deps", usage: "/task-deps <id>", description: "Edit which earlier tasks a task waits for", category: "tasks" },
+  { name: "task-skills", usage: "/task-skills <id> [a,b|none]", description: "Choose or set the skills attached to a task; none clears them", category: "tasks" },
   { name: "task-ops", usage: "/task-ops <id> [on|off]", description: "Make a task an ops task \u2014 run in your checkout once its dependencies are merged \u2014 or a change task", category: "tasks" },
   // Models & providers
   { name: "planner", usage: "/planner [<provider>]", description: "Choose who plans \u2014 an API provider or a coding agent (no API key)", category: "models" },
@@ -3925,12 +3615,8 @@ var SLASH_COMMANDS = [
   { name: "allowlist", usage: "/allowlist [set <runner> <ids> | clear <runner>]", description: "Limit which models a runner may use", category: "models" },
   { name: "runners", usage: "/runners [<id> on|off]", description: "Enable or disable runners (claude-code, opencode, codex)", category: "models" },
   { name: "auto", usage: "/auto [full|guarded]", description: "Autonomy level for new plans: Full or Guarded", category: "models" },
-  { name: "transport", usage: "/transport [terminal|structured]", description: "Drive tasks through each runner's protocol (structured) or a terminal, from the next run", category: "models" },
   { name: "parallel", usage: "/parallel [<n>]", description: "How many AI tasks run at once (applies to a live run)", category: "models" },
   { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
-  // Skills
-  { name: "tdd", usage: "/tdd [on|off]", description: "Test-Driven Development mode", category: "skills" },
-  { name: "verify", usage: "/verify [on|off]", description: "Verification mode \u2014 final evidence-based task that runs the suite", category: "skills" },
   // Sessions
   { name: "sessions", usage: "/sessions", description: "List saved sessions", category: "session" },
   { name: "fork", usage: "/fork", description: "Continue in a copy of this conversation and its tasks; the original stays as it is", category: "session" },
@@ -3951,11 +3637,11 @@ var skillByName = /* @__PURE__ */ new Map();
 function registerSkillCommands(skills) {
   const map = /* @__PURE__ */ new Map();
   for (const skill of skills) {
-    if (BY_NAME.has(skill.name)) continue;
+    if (BY_NAME.has(skill.name) || skill.userInvocable === false) continue;
     map.set(skill.name, {
       name: skill.name,
       usage: `/${skill.name}`,
-      description: skill.description,
+      description: skill.appliesTo === "task" ? `task skill \xB7 ${skill.description}` : skill.description,
       category: "skills",
       source: "skill"
     });
@@ -4010,7 +3696,7 @@ function tokenCompletions(token) {
 }
 
 // src/tui/blocks.ts
-var import_core22 = require("@ordewell/core");
+var import_core23 = require("@ordewell/core");
 
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
@@ -4150,9 +3836,29 @@ var ROLE_PREFIX = {
 function messageLines(block, cols) {
   const text = sanitize(block.text);
   const room = Math.max(1, cols - 2);
-  const wrapped = block.role === "planner" || block.role === "agent" ? renderMarkdown(text, room) : wrap(text, room);
+  const wrapped = block.role === "planner" || block.role === "agent" ? renderMarkdown(text, room) : block.skills ? skillPaintedLines(text, block.skills, room) : wrap(text, room);
   return wrapped.map((line, i) => i === 0 ? ROLE_PREFIX[block.role](line) : `  ${line}`);
 }
+function skillPaintedLines(text, skills, room) {
+  const tokens = (0, import_core23.loadedSkillTokens)(text, skills);
+  return wrapLines(text, room).map(({ line, start }) => {
+    let painted = "";
+    let at = 0;
+    for (const token of tokens) {
+      const from = Math.max(token.start - start, at);
+      const to = Math.min(token.end - start, line.length);
+      if (to <= from) continue;
+      painted += line.slice(at, from) + style.cyan(line.slice(from, to));
+      at = to;
+    }
+    return painted + line.slice(at);
+  });
+}
+function skillLoadLine(block, cols) {
+  const head = block.attaches ? `\u25CF /${sanitize(block.name)} will be attached to fitting tasks \xB7 ` : block.invokedBy === "planner" ? `\u25CF ${sanitize(block.name)} skill loaded by planner \xB7 ` : `\u25CF /${sanitize(block.name)} skill loaded \xB7 `;
+  const line = truncate(`${head}${truncatePath(sanitize(block.path), Math.max(1, cols - width(head)))}`, cols);
+  return `${style.green("\u25CF")}${style.grey(line.slice(1))}`;
+}
 function thinkingLines(block, cols, detailAll) {
   const text = sanitize(block.text).trim();
   const head = `\u2234 Thinking (${countOf(text ? text.split(/\s+/).length : 0, "word")})`;
@@ -4196,7 +3902,7 @@ function truncatePath(path, max) {
     if (width(char + tail) > max - 1) break;
     tail = char + tail;
   }
-  const slash = tail.indexOf("/");
+  const slash = tail.search(/[\\/]/);
   return `\u2026${slash > 0 ? tail.slice(slash) : tail}`;
 }
 function commandHeader(block, cols, detailAll) {
@@ -4230,16 +3936,16 @@ function resultLines(block, room, detailAll) {
   const fit2 = (line) => detailAll ? wrap(line, room) : [truncate(line, room)];
   const outcome = unsettledOutcome(block);
   if (outcome) {
-    const [reason, ...rest] = (0, import_core22.outputLines)(block.output).map(sanitize);
+    const [reason, ...rest] = (0, import_core23.outputLines)(block.output).map(sanitize);
     const status = fit2(reason ? `${outcome.label}: ${reason}` : outcome.label).map(outcome.paint);
     return detailAll ? [...status, ...rest.flatMap(fit2).map(style.grey)] : status;
   }
   if (detailAll) {
-    const lines2 = (0, import_core22.outputLines)(block.output).map(sanitize);
+    const lines2 = (0, import_core23.outputLines)(block.output).map(sanitize);
     const note = lines2.length > PREVIEW_LINES ? ["\u2026 (ctrl+o to collapse)"] : [];
     return lines2.length > 0 ? [...lines2.flatMap(fit2), ...note].map(style.grey) : [style.grey("(no output)")];
   }
-  const { lines, hiddenLineCount } = (0, import_core22.outputPreview)(block.output, PREVIEW_LINES);
+  const { lines, hiddenLineCount } = (0, import_core23.outputPreview)(block.output, PREVIEW_LINES);
   if (lines.length === 0) return [style.grey("(no output)")];
   const more = hiddenLineCount > 0 ? [`\u2026 +${countOf(hiddenLineCount, "line")} (ctrl+o to expand)`] : [];
   return [...lines.map(sanitize), ...more].map((line) => style.grey(truncate(line, room)));
@@ -4253,7 +3959,7 @@ var DIFF_PAINT = {
 };
 var DIFF_SIGN = { added: "+", removed: "-", context: " ", gap: "" };
 function diffLines(block, diff, room, detailAll) {
-  const rows = (0, import_core22.diffRows)(block.output);
+  const rows = (0, import_core23.diffRows)(block.output);
   const gutter = Math.max(0, ...rows.map((row) => String(row.line ?? "").length));
   const draw = (row) => {
     const text = row.kind === "gap" ? `${" ".repeat(gutter)} \u22EE` : `${String(row.line ?? "").padStart(gutter)} ${DIFF_SIGN[row.kind]} ${sanitize(row.text)}`;
@@ -4262,7 +3968,7 @@ function diffLines(block, diff, room, detailAll) {
   const shown = detailAll ? rows : rows.slice(0, DIFF_PREVIEW_ROWS);
   const hidden = rows.length - shown.length;
   const more = hidden > 0 ? [style.grey(`\u2026 +${countOf(hidden, "line")} (ctrl+o to expand)`)] : [];
-  return [(0, import_core22.diffSummary)(diff), ...shown.flatMap(draw), ...more];
+  return [(0, import_core23.diffSummary)(diff), ...shown.flatMap(draw), ...more];
 }
 function toolLines(block, cols, detailAll) {
   const room = Math.max(1, cols - OUTPUT_INDENT.length);
@@ -4350,6 +4056,8 @@ function blockLines(block, cols, detailAll) {
       return [approvalLine(block, cols)];
     case "plan":
       return [planLine(block, cols)];
+    case "skill_load":
+      return [skillLoadLine(block, cols)];
     // Pinned under the pane rather than drawn in it — see `tokenLine`.
     case "usage":
       return [];
@@ -4365,11 +4073,11 @@ function drawn(block, cols, detailAll) {
 }
 function conversationLines(blocks, cols, detailAll, answering) {
   const lines = [];
-  for (const block of blocks) {
+  for (const [i, block] of blocks.entries()) {
     if (block.type === "usage") continue;
     lines.push(...drawn(block, cols, detailAll));
     if (block === answering) lines.push(approvalKeysLine(block, cols));
-    lines.push("");
+    if (blocks[i + 1]?.type !== "skill_load") lines.push("");
   }
   return lines;
 }
@@ -4397,11 +4105,7 @@ function tokenLine(blocks, cols) {
 }
 
 // src/tui/state.ts
-var import_core23 = require("@ordewell/core");
-var SKILL_IDS = ["tdd", "verify"];
-function noSkills() {
-  return { tdd: false, verify: false };
-}
+var import_core24 = require("@ordewell/core");
 function visibleItems(picker2) {
   const filter = picker2.filter.trim().toLowerCase();
   if (!filter) return picker2.items;
@@ -4409,7 +4113,7 @@ function visibleItems(picker2) {
     (i) => i.id.toLowerCase().includes(filter) || i.label.toLowerCase().includes(filter) || (i.detail ?? "").toLowerCase().includes(filter)
   );
 }
-var anyTaskRunning = (state) => state.tasks.some(import_core23.isTaskRunning);
+var anyTaskRunning = (state) => state.tasks.some(import_core24.isTaskRunning);
 var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
 function planRows(state) {
   const rows = [];
@@ -4446,9 +4150,9 @@ function findTask(tasks, id) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core23.EMPTY_CONVERSATION,
+    conversation: import_core24.EMPTY_CONVERSATION,
     taskView: null,
-    turnGate: import_core23.NO_TURN,
+    turnGate: import_core24.NO_TURN,
     detailAll: false,
     status: "idle",
     busyLabel: "",
@@ -4462,22 +4166,21 @@ function initialState(overrides = {}) {
     taskEditor: null,
     scroll: 0,
     planScroll: null,
-    skills: noSkills(),
     runners: [],
     sessions: [],
     rewindTargets: null,
     models: [],
     modesByRunner: {},
+    taskSkills: [],
     orchestratorModels: [],
     providerErrors: {},
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
-    maxParallel: import_core23.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core24.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
-    runnerTransport: "structured",
     mouseCapture: true,
     selection: null,
     workspace: process.cwd(),
@@ -4485,7 +4188,7 @@ function initialState(overrides = {}) {
     gate: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core23.EMPTY_HOLD,
+    queuedPrompts: import_core24.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4533,7 +4236,7 @@ function chatEditorRoomFor(state, active) {
 }
 
 // src/tui/layout.ts
-var import_core24 = require("@ordewell/core");
+var import_core25 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -4542,7 +4245,7 @@ function chatInputWrap(state) {
 }
 function footerHints(state) {
   const selected = selectedPlanRow(state)?.task;
-  const markHint = selected && (0, import_core24.markAction)(selected) === "uncomplete" ? "m undone" : "m done";
+  const markHint = selected && (0, import_core25.markAction)(selected) === "uncomplete" ? "m undone" : "m done";
   const resolveHint = selected?.isolation?.state === "conflict" ? ["x resolve conflict"] : [];
   const planning = plannerInFlight(state) && !state.taskView;
   const escHint = !planning ? null : state.queuedPrompts.length > 0 ? "esc unsend" : "esc \xD72 stop planning";
@@ -4552,12 +4255,13 @@ function footerHints(state) {
     }
     return [
       ...escHint ? [escHint] : [],
-      "enter expand",
+      "\u2192 expand/edit",
       "R runner",
       "o model",
       "e effort",
       "M mode",
       "D deps",
+      "K skills",
       "O ops",
       "f start",
       "E run plan",
@@ -4567,13 +4271,13 @@ function footerHints(state) {
       "s skip",
       "a add",
       "d remove",
-      "t terminal",
+      "enter log",
       ...resolveHint,
       "pgup/pgdn scroll",
       "tab chat"
     ];
   }
-  const detailHint = (0, import_core24.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
+  const detailHint = (0, import_core25.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
   return [
     "/help",
     "tab plan",
@@ -4609,10 +4313,10 @@ function queuedTaskBubble(message, selected, cols) {
   return wrap(text, room).map((line, i) => i === 0 ? truncate(`${marker2} ${selected ? style.bold(line) : line}${style.grey(tag)}`, cols) : truncate(`  ${line}`, cols));
 }
 function taskActivity(task, working) {
-  const approvals = (0, import_core24.approvalLabel)(task?.awaitingApproval);
+  const approvals = (0, import_core25.approvalLabel)(task?.awaitingApproval);
   if (approvals) return inRow(approvals);
   if (working) return "working";
-  if (task?.status === "awaiting_user") return inRow((0, import_core24.awaitingLabel)(task) ?? "Waiting for your input");
+  if (task?.status === "awaiting_user") return inRow((0, import_core25.awaitingLabel)(task) ?? "Waiting for your input");
   return task?.status ?? "";
 }
 function taskHeaderLines(state, tv, cols) {
@@ -4687,9 +4391,9 @@ function chatScrollMax(state) {
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core24.ALL_PROVIDERS[provider];
+  const registration = import_core25.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core24.runnerForProvider)(provider);
+  const runner = (0, import_core25.runnerForProvider)(provider);
   const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
@@ -4861,7 +4565,7 @@ function planScrollExtent(state) {
 }
 function taskLines(state, planRow, index, cols, orderOf) {
   const { task, parent } = planRow;
-  const row = (0, import_core24.taskRowView)(task, { parent, orderOf, modes: modesForTask(state.modesByRunner, task) });
+  const row = (0, import_core25.taskRowView)(task, { parent, orderOf, modes: modesForTask(state.modesByRunner, task) });
   const selected = state.focus === "plan" && index === state.selectedTask;
   const expanded = state.expandedTaskId === task.id;
   const rawIcon = row.status === "running" ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[row.status];
@@ -4888,11 +4592,11 @@ function taskLines(state, planRow, index, cols, orderOf) {
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${row.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
   const bodyPad = parent ? "      " : "    ";
-  const structured = task.transport?.kind === "structured";
-  const activity = row.approvals ? `${inRow(row.approvals)} \u2014 t opens it` : row.status === "quiet" ? structured ? "quiet" : "quiet \u2014 t opens its terminal" : row.running ? "working" : row.awaiting ? inRow(row.awaiting) : "";
-  const meta = [activity, runner, structured ? "structured" : "", model].filter(Boolean).join(" \xB7 ");
+  const activity = row.approvals ? `${inRow(row.approvals)} \u2014 enter opens it` : row.status === "quiet" ? "quiet" : row.running ? "working" : row.awaiting ? inRow(row.awaiting) : "";
+  const skills = (task.skills ?? []).join(" \xB7 ");
+  const meta = [activity, runner, model].filter(Boolean).join(" \xB7 ");
   if (meta) lines.push(style.grey(truncate(`${bodyPad}${meta}`, cols)));
-  if (task.transport?.fallback) lines.push(style.yellow(truncate(`${bodyPad}terminal: ${task.transport.fallback}`, cols)));
+  if (skills) lines.push(style.grey(truncate(`${bodyPad}skills: ${skills}`, cols)));
   if (effort || mode) lines.push(style.grey(truncate(`${bodyPad}${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
   if (row.conflict) {
     const where = row.conflict.repo ? ` in ${row.conflict.repo}` : "";
@@ -4947,7 +4651,7 @@ function taskLines(state, planRow, index, cols, orderOf) {
       lines.push(...taskText("Depends on", row.dependencies.join(", "), cols, bodyPad));
     }
     lines.push(style.grey(`${bodyPad}enter save \xB7 esc cancel`));
-    lines.push(style.grey(truncate(`${bodyPad}then R runner \xB7 o model \xB7 e effort \xB7 M mode \xB7 D deps`, cols)));
+    lines.push(style.grey(truncate(`${bodyPad}then R runner \xB7 o model \xB7 e effort \xB7 M mode \xB7 D deps \xB7 K skills`, cols)));
   }
   return { lines, editorLine };
 }
@@ -4992,7 +4696,7 @@ function helpLayout(rows, cols) {
   );
   body.push(
     "",
-    style.bold("In a task view (t or /terminal on a structured task)"),
+    style.bold("In a task view (enter on a task)"),
     style.grey("  ctrl-s sends now: interrupts the running step, then delivers the composer text \u2014 or, with it empty, the selected queued message"),
     style.grey("  ctrl-n/ctrl-p select a queued message \xB7 ctrl-r removes it \xB7 ctrl-x interrupts"),
     style.grey("  ctrl-y allows a tool request (its keys sit under it) \xB7 ctrl-t allows it for the task \xB7 ctrl-g denies it, with the composer text as the note"),
@@ -5008,13 +4712,13 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core25 = require("@ordewell/core");
+var import_core26 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
   const body = state.overlay ? renderOverlay(state, rowsForBody, cols) : renderBody(state, rowsForBody, cols);
   const lines = [
-    renderSkills(state, cols),
+    renderAutonomy(state, cols),
     ...body,
     renderStatus(state, cols),
     ...renderInput(state),
@@ -5099,13 +4803,9 @@ function fit(lines, rows, anchor) {
   const blanks = Array(rows - lines.length).fill("");
   return anchor === "bottom" ? [...blanks, ...lines] : [...lines, ...blanks];
 }
-function renderSkills(state, cols) {
-  const badges = SKILL_IDS.map(
-    (id) => state.skills[id] ? style.green(`\u25CF ${id}`) : style.grey(`\u25CB ${id}`)
-  );
+function renderAutonomy(state, cols) {
   const auto = state.autonomous ? style.yellow("\u25CF Full") : style.green("\u25CF Guarded");
-  const terminal = state.runnerTransport === "terminal" ? [style.yellow("\u25CF terminal")] : [];
-  return truncate([...badges, auto, ...terminal].join(" "), cols);
+  return truncate(auto, cols);
 }
 function scrolledBackMark(state) {
   return state.focus !== "plan" && state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
@@ -5273,8 +4973,8 @@ function renderHandoff(state, overlay, rows, cols) {
     return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
   }
   const landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
-    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core25.capConflictFiles)(task.repairedFiles)})`) : "";
-    return `  ${style.green("\u2713")} ${(0, import_core25.titledTaskRef)(task)}${repaired}`;
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core26.capConflictFiles)(task.repairedFiles)})`) : "";
+    return `  ${style.green("\u2713")} ${(0, import_core26.titledTaskRef)(task)}${repaired}`;
   });
   const actions = handoffActions(handoff).map((action, index) => {
     const active = index === overlay.index;
@@ -5363,10 +5063,10 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core33 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
 
 // src/tui/reducers/overlays.ts
-var import_core31 = require("@ordewell/core");
+var import_core32 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -5415,10 +5115,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core30 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core26 = require("@ordewell/core");
+var import_core27 = require("@ordewell/core");
 var import_plan_utils2 = require("@ordewell/core/plan-utils");
 var DEFAULT_EFFORT = "__runner_default__";
 function picker(title, items, action, extra = {}) {
@@ -5437,11 +5137,11 @@ function modelDetail(m) {
 function providerErrorHint(state) {
   const failed = Object.keys(state.providerErrors ?? {});
   if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core26.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => import_core27.ALL_PROVIDERS[p]?.label ?? p);
   return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
 }
 function plannerModelItems(state) {
-  const runner = (0, import_core26.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core27.runnerForProvider)(state.plannerProvider);
   if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
   const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
     id: m.id,
@@ -5455,7 +5155,7 @@ function plannerModelItems(state) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerEffortItems(state) {
-  const runner = (0, import_core26.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core27.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -5519,10 +5219,21 @@ function pickerItemsFor(state, action) {
   if (action.kind === "set-task-deps") {
     return (0, import_plan_utils2.dependencyCandidates)(state.tasks, action.taskId).map((candidate) => ({
       id: candidate.id,
-      label: (0, import_core26.titledTaskRef)(candidate),
+      label: (0, import_core27.titledTaskRef)(candidate),
       detail: candidate.status === "completed" ? "already completed" : void 0
     }));
   }
+  if (action.kind === "set-task-skills") {
+    const task = findTask(state.tasks, action.taskId);
+    if (!task) return [];
+    const known = new Set(state.taskSkills.map((s) => s.name));
+    return [
+      ...state.taskSkills.map((s) => ({ id: s.name, label: s.name, detail: s.description || void 0 })),
+      // Attached but not in the catalog (created by an earlier task's worktree): keep it
+      // selectable so confirming the picker does not silently detach it.
+      ...(task.skills ?? []).filter((name) => !known.has(name)).map((name) => ({ id: name, label: `${name} (not found)`, detail: "not found in the catalog" }))
+    ];
+  }
   if (action.kind === "set-task-mode") {
     const task = findTask(state.tasks, action.taskId);
     if (!task) return [];
@@ -5564,28 +5275,24 @@ function pickerItemsFor(state, action) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core26.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core26.runnerForProvider)(id);
-    const ready = installed.has(runner);
-    return {
-      id,
-      label: import_core26.ALL_PROVIDERS[id].label,
-      detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
-      selected: state.plannerProvider === id,
-      disabled: !ready
-    };
-  });
-  const vendors = import_core26.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
-    id,
-    label: import_core26.ALL_PROVIDERS[id].label,
-    detail: import_core26.ALL_PROVIDERS[id].apiKeyEnvVar,
-    selected: state.plannerProvider === id
+  const usability = {};
+  for (const id of import_core27.CLI_PROVIDERS) {
+    const runner = (0, import_core27.runnerForProvider)(id);
+    usability[runner] = installed.has(runner) ? { usable: true } : { usable: false, reason: "CLI not installed or not on PATH" };
+  }
+  const entries = (0, import_core27.plannerBackendEntries)(usability, state.configuredProviders);
+  const items = entries.map((entry) => ({
+    id: entry.id,
+    label: entry.label,
+    detail: entry.reason,
+    selected: state.plannerProvider === entry.id,
+    disabled: !entry.usable
   }));
-  return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
+  return entries.some((entry) => entry.kind === "vendor") ? items : [...items, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
 }
 
 // src/tui/reducers/planPane.ts
-var import_core28 = require("@ordewell/core");
+var import_core29 = require("@ordewell/core");
 
 // src/tui/reducers/pointer.ts
 var WHEEL_NOTCH = 3;
@@ -5663,13 +5370,13 @@ function handleMouseSelect(state, key) {
 }
 
 // src/tui/reducers/taskView.ts
-var import_core27 = require("@ordewell/core");
+var import_core28 = require("@ordewell/core");
 function openTaskView(state, sessionId, taskId) {
   const task = findTask(state.tasks, taskId);
   if (!task) return step(say(state, "system", `No task ${taskId} in this plan.`));
   const taskView = {
     taskId,
-    view: import_core27.EMPTY_TASK_LOG,
+    view: import_core28.EMPTY_TASK_LOG,
     attempts: [],
     attempt: 0,
     pending: [],
@@ -5679,11 +5386,6 @@ function openTaskView(state, sessionId, taskId) {
   };
   return step({ ...state, taskView, focus: "chat", scroll: 0 }, [{ type: "openTaskLog", sessionId, taskId }]);
 }
-function openTaskTerminalOrView(state, sessionId, taskId) {
-  const task = findTask(state.tasks, taskId);
-  if (task?.transport?.kind === "structured") return openTaskView(state, sessionId, taskId);
-  return step(state, [{ type: "openTaskTerminal", sessionId, taskId }]);
-}
 function continueTaskStep(state, sessionId, taskId, text) {
   const opened = state.taskView?.taskId === taskId ? step({ ...state, taskView: { ...state.taskView, followLatest: true } }) : openTaskView(state, sessionId, taskId);
   const watch = state.status !== "executing";
@@ -5702,13 +5404,13 @@ function applyLive(tv, attempt, events) {
     }
     next = {
       ...next,
-      view: import_core27.EMPTY_TASK_LOG,
+      view: import_core28.EMPTY_TASK_LOG,
       attempt,
       attempts: next.attempts.includes(attempt) ? next.attempts : [...next.attempts, attempt]
     };
   }
   if (attempt < next.attempt) return next;
-  return clampQueueIndex({ ...next, view: events.reduce(import_core27.reduceTaskLog, next.view) });
+  return clampQueueIndex({ ...next, view: events.reduce(import_core28.reduceTaskLog, next.view) });
 }
 function taskLogAbandoned(state) {
   const tv = state.taskView;
@@ -5728,14 +5430,14 @@ function taskLogArrived(state, action) {
 function announceApprovals(state, action) {
   if (state.taskView?.taskId === action.taskId) return state;
   const task = findTask(state.tasks, action.taskId);
-  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" ? say(s, "system", `\xB7 Task ${task?.order ?? "?"} waits for approval: ${(0, import_core27.runnerToolSubject)(event.tool, event.args)} \u2014 t on it, then ctrl-y to allow or ctrl-g to deny`) : s, state);
+  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" ? say(s, "system", `\xB7 Task ${task?.order ?? "?"} waits for approval: ${(0, import_core28.runnerToolSubject)(event.tool, event.args)} \u2014 enter on it, then ctrl-y to allow or ctrl-g to deny`) : s, state);
   return spoken !== state ? { ...spoken, scroll: state.scroll } : spoken;
 }
 function announceCheckpoint(state, action) {
   const task = findTask(state.tasks, action.taskId) ?? state.tasks.find((t) => t.title === action.title);
   const label = task ? `Task ${task.order}` : action.title;
-  const where = task?.transport?.kind === "structured" ? "t on it to answer" : `/checkpoint ${task?.order ?? "<id>"} approve|reject to answer`;
-  const spoken = say(state, "system", `\xB7 ${label} asks: ${(0, import_core27.truncateCheckpointSummary)(action.summary)} \u2014 ${where}`);
+  const where = "enter on it to answer";
+  const spoken = say(state, "system", `\xB7 ${label} asks: ${(0, import_core28.truncateCheckpointSummary)(action.summary)} \u2014 ${where}`);
   return { ...spoken, scroll: state.scroll };
 }
 function taskLogLoaded(state, action) {
@@ -5743,7 +5445,7 @@ function taskLogLoaded(state, action) {
   if (!tv || tv.taskId !== action.taskId) return state;
   const loaded = action.attempt >= 1 ? {
     ...tv,
-    view: (0, import_core27.replayTaskLog)(action.events),
+    view: (0, import_core28.replayTaskLog)(action.events),
     attempts: action.attempts ?? tv.attempts,
     attempt: action.attempt
   } : { ...tv, attempts: action.attempts ?? tv.attempts };
@@ -5895,6 +5597,34 @@ function openTaskDepsPicker(state, task) {
     }
   });
 }
+function openTaskSkillsPicker(state, task) {
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not run an executor, so they take no skills.");
+  const action = { kind: "set-task-skills", taskId: task.id };
+  const items = pickerItemsFor(state, action);
+  if (items.length === 0) {
+    return fail3(state, "No task skills found. A skill with applies-to: task in .ordewell/skills/ or ~/.ordewell/skills/ shows up here.");
+  }
+  return step({
+    ...state,
+    overlay: {
+      kind: "picker",
+      picker: picker(`Skills \xB7 ${(0, import_plan_utils3.titledTaskRef)(task)}`, items, action, {
+        hint: "Attached skills go into this task's prompt when it starts.",
+        multi: true,
+        chosen: task.skills ?? []
+      })
+    }
+  });
+}
+function assignTaskSkills(state, sessionId, task, skills) {
+  return step(state, [{
+    type: "updateTask",
+    sessionId,
+    taskId: task.id,
+    changes: { skills },
+    message: skills.length > 0 ? `Task ${(0, import_plan_utils3.taskRef)(task)} skills set to ${skills.join(", ")}.` : `Task ${(0, import_plan_utils3.taskRef)(task)} has no skills attached.`
+  }]);
+}
 function openTaskModePicker(state, task) {
   if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor mode.");
   const modes = modesForTask(state.modesByRunner, task);
@@ -6035,6 +5765,20 @@ function taskEffortCommand(state, args) {
     return assignTaskEffort(state, sessionId, task, value);
   });
 }
+function taskSkillsCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = findTask(state.tasks, taskId);
+    if (args.length < 2) return openTaskSkillsPicker(state, task);
+    if (task.type !== "ai") return fail3(state, "Manual tasks do not run an executor, so they take no skills.");
+    const value = args.slice(1).join(" ");
+    const names = value.toLowerCase() === "none" ? [] : [...new Set(value.toLowerCase().split(/[,\s]+/).filter(Boolean))];
+    const unknown = names.filter((name) => !state.taskSkills.some((s) => s.name === name));
+    if (unknown.length > 0) {
+      return fail3(state, `No task skill named ${unknown.map((n) => `"${n}"`).join(", ")}. Task skills: ${state.taskSkills.map((s) => s.name).join(", ") || "none"}.`);
+    }
+    return assignTaskSkills(state, sessionId, task, names);
+  });
+}
 function taskOpsCommand(state, args) {
   return taskCommand(state, args[0], (_sessionId, taskId) => {
     const task = findTask(state.tasks, taskId);
@@ -6105,7 +5849,8 @@ function handlePlanKey(state, key) {
   const row = selectedPlanRow(state);
   if (!row) return step(state);
   const task = row.task;
-  if (key.name === "enter" || key.name === "right") {
+  if (key.name === "enter" && state.sessionId) return openTaskView(state, state.sessionId, task.id);
+  if (key.name === "right") {
     const hasSubtasks = (task.subtasks?.length ?? 0) > 0;
     if (hasSubtasks && state.expandedTaskId !== task.id) {
       return step(settlePlan({ ...state, expandedTaskId: task.id, taskEditor: null }));
@@ -6120,14 +5865,13 @@ function handlePlanKey(state, key) {
   if (!state.sessionId || key.name !== "char") return step(state);
   if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
   if (key.char === "S") return step(state, [{ type: "stopExecution", sessionId: state.sessionId }]);
-  const action = key.char === "m" ? (0, import_core28.markAction)(task) : PLAN_SHORTCUTS[key.char ?? ""];
+  const action = key.char === "m" ? (0, import_core29.markAction)(task) : PLAN_SHORTCUTS[key.char ?? ""];
   if (action === "force-start" && task.mergeGate?.length) return confirmForceStartPastGate(state, task);
   if (action) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
   }
   if (key.char === "O") return toggleTaskOps(state, task, row.parent !== null);
   if (key.char === "d") return confirmRemoveTask(state, task);
-  if (key.char === "t") return openTaskTerminalOrView(state, state.sessionId, task.id);
   if (key.char === "x" && task.isolation?.state === "conflict") {
     return step(state, [{ type: "resolveConflict", sessionId: state.sessionId, taskId: task.id }]);
   }
@@ -6136,6 +5880,7 @@ function handlePlanKey(state, key) {
   if (key.char === "e") return openTaskEffortPicker(state, task);
   if (key.char === "M") return openTaskModePicker(state, task);
   if (key.char === "D") return openTaskDepsPicker(state, task);
+  if (key.char === "K") return openTaskSkillsPicker(state, task);
   return step(state);
 }
 function handleTaskEditKey(state, task, editor, key) {
@@ -6155,14 +5900,14 @@ function commitTaskEdit(state, task, editor) {
     sessionId: state.sessionId,
     taskId: task.id,
     changes: { prompt },
-    message: `Task ${(0, import_core28.taskRef)(task)} prompt updated.`
+    message: `Task ${(0, import_core29.taskRef)(task)} prompt updated.`
   }]);
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core29 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core29.drainNext)(state.queuedPrompts);
+  const next = (0, import_core30.drainNext)(state.queuedPrompts);
   const ended = disarmStop({ ...settled, stopRequested: false });
   if (!next) return step(ended);
   const spoken = say(ended, "user", next.text);
@@ -6181,14 +5926,14 @@ function stopPlanning(state, sessionId) {
   return step(queueToEditor(cutTurn({ ...dismissed, stopArmed: false, stopRequested: true })), [{ type: "cancelPlanning", sessionId }]);
 }
 function queueToEditor(state) {
-  const all = (0, import_core29.unsendAll)(state.queuedPrompts);
+  const all = (0, import_core30.unsendAll)(state.queuedPrompts);
   if (!all) return state;
   return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text: all.text, cursor: all.text.length } };
 }
 function unsendLatest(state) {
-  const latest = (0, import_core29.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core30.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core29.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core30.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -6205,14 +5950,11 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/commands.ts
-var KNOWN_PROVIDERS2 = Object.keys(import_core30.ALL_PROVIDERS);
+var KNOWN_PROVIDERS = Object.keys(import_core31.ALL_PROVIDERS);
+var unknownCommand = (state, name) => fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
+var skillInTaskView = (state, name) => fail3(state, `/${name} is a skill, and skills aren't loaded in a task's chat. To give a task a skill, use /task-skills <id> <name>.`);
 function runCommand(state, { name, args }) {
-  if (!findCommand(name)) {
-    return fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
-  }
-  if (SKILL_IDS.includes(name)) {
-    return toggleSkill(state, name, args[0]);
-  }
+  if (!findCommand(name)) return unknownCommand(state, name);
   switch (name) {
     case "help":
       return step({ ...state, overlay: { kind: "help", scroll: 0 } });
@@ -6246,8 +5988,6 @@ function runCommand(state, { name, args }) {
       return runners(state, args);
     case "auto":
       return setAutonomous(state, args[0]);
-    case "transport":
-      return setTransport(state, args[0]);
     case "parallel":
       return setMaxParallel(state, args[0]);
     case "mouse":
@@ -6284,8 +6024,6 @@ function runCommand(state, { name, args }) {
         args[0],
         (sessionId, taskId) => step(state, [{ type: "removeTask", sessionId, taskId }])
       );
-    case "terminal":
-      return taskCommand(state, args[0], (sessionId, taskId) => openTaskTerminalOrView(state, sessionId, taskId));
     case "continue":
       return taskCommand(state, args[0], (sessionId, taskId) => {
         const text = args.slice(1).join(" ").trim();
@@ -6310,6 +6048,8 @@ function runCommand(state, { name, args }) {
       return taskModeCommand(state, args);
     case "task-ops":
       return taskOpsCommand(state, args);
+    case "task-skills":
+      return taskSkillsCommand(state, args);
     case "task-deps":
       return taskCommand(
         state,
@@ -6343,11 +6083,6 @@ function resolveToggle(arg, current) {
   if (value === void 0) return !current;
   return null;
 }
-function toggleSkill(state, skill, arg) {
-  const enabled = resolveToggle(arg, state.skills[skill]);
-  if (enabled === null) return fail3(state, `Usage: /${skill} [on|off]`);
-  return step(state, [{ type: "command", name: skill, action: enabled ? "on" : "off" }]);
-}
 function requestNewSession(state) {
   const hasContent = state.tasks.length > 0 || state.conversation.blocks.length > 0 || state.goal !== "" || state.status !== "idle";
   if (!state.sessionId || !hasContent) return newSession(state);
@@ -6371,8 +6106,8 @@ function newSession(state) {
     taskView: null,
     tasks: [],
     planApproved: false,
-    conversation: import_core30.EMPTY_CONVERSATION,
-    turnGate: import_core30.NO_TURN,
+    conversation: import_core31.EMPTY_CONVERSATION,
+    turnGate: import_core31.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -6383,14 +6118,14 @@ function newSession(state) {
     // Prompts belong to the session that raised them; the old planner is gone
     // and its pending requests deny on their own timeout.
     pendingApprovals: [],
-    queuedPrompts: import_core30.EMPTY_HOLD,
+    queuedPrompts: import_core31.EMPTY_HOLD,
     stopArmed: false,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
   }, closeEffects);
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core30.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core31.runnerForProvider)(state.plannerProvider);
     const known = runner ? modelsForRunner(state.models, runner) : [];
     if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
       return fail3(state, `${args[1]} was not discovered for ${runner}.`);
@@ -6413,7 +6148,7 @@ function setModel(state, args) {
 function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
-    if (!KNOWN_PROVIDERS2.includes(id)) {
+    if (!KNOWN_PROVIDERS.includes(id)) {
       return fail3(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
     }
     return step(state, [{ type: "setPlanner", provider: id }]);
@@ -6452,7 +6187,7 @@ function setPlannerEffort(state, args) {
 function setKey(state, args) {
   if (args[0] === "set" && args[1]) {
     const provider = args[1].toLowerCase();
-    if (!KNOWN_PROVIDERS2.includes(provider)) {
+    if (!KNOWN_PROVIDERS.includes(provider)) {
       return fail3(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
     }
     if (!args[2]) {
@@ -6463,16 +6198,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core30.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core31.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core30.ALL_PROVIDERS[id].label,
-    detail: import_core30.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core31.ALL_PROVIDERS[id].label,
+    detail: import_core31.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.configuredProviders.includes(id)
   }));
   return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
 function keyPrompt(provider) {
-  const meta = import_core30.ALL_PROVIDERS[provider];
+  const meta = import_core31.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -6549,21 +6284,16 @@ function runners(state, args) {
 }
 function setMaxParallel(state, arg) {
   if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once \u2014 /parallel <n> changes it.`));
-  const limit = (0, import_core30.parseMaxParallel)(arg);
+  const limit = (0, import_core31.parseMaxParallel)(arg);
   if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
   return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
 }
 function setAutonomous(state, arg) {
-  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core30.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
-  const enabled = (0, import_core30.parseAutonomyLevel)(arg);
+  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core31.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
+  const enabled = (0, import_core31.parseAutonomyLevel)(arg);
   if (enabled === null) return fail3(state, "Usage: /auto [full|guarded]");
   return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
-function setTransport(state, arg) {
-  const value = arg?.toLowerCase() ?? (state.runnerTransport === "structured" ? "terminal" : "structured");
-  if (!(0, import_core30.isRunnerTransport)(value)) return fail3(state, "Usage: /transport [terminal|structured]");
-  return step(state, [{ type: "setTransport", transport: value }]);
-}
 function setMouseCapture(state, arg) {
   const enabled = resolveToggle(arg, state.mouseCapture);
   if (enabled === null) return fail3(state, "Usage: /mouse [on|off]");
@@ -6738,9 +6468,14 @@ function choose(state, picker2, item) {
       sessionId: state.sessionId,
       taskId: task.id,
       changes: { dependencies: picker2.chosen },
-      message: picker2.chosen.length > 0 ? `Task ${(0, import_core31.taskRef)(task)} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task ${(0, import_core31.taskRef)(task)} no longer depends on anything.`
+      message: picker2.chosen.length > 0 ? `Task ${(0, import_core32.taskRef)(task)} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task ${(0, import_core32.taskRef)(task)} no longer depends on anything.`
     }]);
   }
+  if (picker2.action.kind === "set-task-skills") {
+    const task = findTask(state.tasks, picker2.action.taskId);
+    if (!task || !state.sessionId) return step(closed);
+    return assignTaskSkills(closed, state.sessionId, task, picker2.chosen);
+  }
   if (!item) return step(state);
   if (item.disabled) {
     return step(say(state, "error", item.detail ? `${item.label} \u2014 ${item.detail}` : `${item.label} is not available.`));
@@ -6815,7 +6550,7 @@ function choose(state, picker2, item) {
 }
 
 // src/tui/reducers/incoming.ts
-var import_core32 = require("@ordewell/core");
+var import_core33 = require("@ordewell/core");
 var planText = (value, fallback = "") => sanitize(String(value ?? fallback));
 var planLabel = (value, fallback = "") => planText(value, fallback).replace(/\n+/g, " ");
 var asRecord = (value) => typeof value === "object" && value !== null ? value : {};
@@ -6846,7 +6581,7 @@ function toTaskView2(t, index) {
     prompt: typeof t.prompt === "string" ? sanitize(t.prompt) : void 0,
     type: t.type === "user" ? "user" : "ai",
     status: planLabel(t.status, "pending"),
-    awaitingReason: t.status === "awaiting_user" && (0, import_core32.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
+    awaitingReason: t.status === "awaiting_user" && (0, import_core33.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
     dependencies: Array.isArray(t.dependencies) ? t.dependencies.map((id) => planLabel(id)) : [],
     assignedRunner: typeof t.assignedRunner === "string" ? planLabel(t.assignedRunner) : void 0,
     taskMode: typeof t.taskMode === "string" ? planLabel(t.taskMode) : void 0,
@@ -6858,33 +6593,22 @@ function toTaskView2(t, index) {
     } : void 0,
     subtasks: Array.isArray(t.subtasks) ? [...t.subtasks].sort((a, b) => wireOrder(a) - wireOrder(b)).map((s, i) => toTaskView2(asRecord(s), i)) : void 0,
     ...t.ops === true ? { ops: true } : {},
+    ...Array.isArray(t.skills) && t.skills.length > 0 ? { skills: t.skills.map((name) => planLabel(name)) } : {},
     ...Array.isArray(t.forcedPastGate) && t.forcedPastGate.length > 0 ? { forcedPastGate: t.forcedPastGate.map((title) => planLabel(title)) } : {}
   };
 }
-var enabledFlag = (value) => typeof value?.enabled === "boolean" ? value.enabled : void 0;
 function applySettings(state, settings) {
-  const sources = {
-    tdd: settings.tdd,
-    verify: settings.verification
-  };
-  const skills = { ...state.skills };
-  for (const id of SKILL_IDS) {
-    const flag2 = enabledFlag(sources[id]);
-    if (flag2 !== void 0) skills[id] = flag2;
-  }
   return {
     ...state,
-    skills,
     orchestratorModel: typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : state.orchestratorModel,
     plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
     plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
     maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
-    runnerTransport: (0, import_core32.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
   };
 }
 function runLabel(tasks, gate = null) {
-  const running = tasks.filter(import_core23.isTaskRunning);
+  const running = tasks.filter(import_core24.isTaskRunning);
   if (running.length > 0) {
     const [first] = running;
     const name = first.assignedRunner ? `${first.title} \xB7 ${first.assignedRunner}` : first.title;
@@ -6950,13 +6674,13 @@ function reduceAction(state, action) {
         goal: "",
         taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core33.EMPTY_HOLD,
+        queuedPrompts: import_core34.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
     case "chatRestored":
       if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, conversation: (0, import_core33.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
+      return step({ ...state, conversation: (0, import_core34.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
     case "planUpdated": {
       if (stale(state, action.sessionId)) return step(state);
       const isolation = isolationOfPlan(action.plan);
@@ -7003,9 +6727,9 @@ function reduceAction(state, action) {
     case "taskStarted": {
       if (stale(state, action.sessionId)) return step(state);
       const existing = findTask(state.tasks, action.taskId);
-      if (existing && (0, import_core23.isTaskRunning)(existing)) return step(state);
-      const tasks = state.tasks.map((t) => t.id === action.taskId && !(0, import_core23.isTaskRunning)(t) ? { ...t, status: "in_progress" } : t);
-      const spoken = say(state, "system", (0, import_core33.taskStartedNotice)(action.title, action.runner));
+      if (existing && (0, import_core24.isTaskRunning)(existing)) return step(state);
+      const tasks = state.tasks.map((t) => t.id === action.taskId && !(0, import_core24.isTaskRunning)(t) ? { ...t, status: "in_progress" } : t);
+      const spoken = say(state, "system", (0, import_core34.taskStartedNotice)(action.title, action.runner));
       return step({ ...spoken, tasks, status: "executing", busyLabel: runLabel(tasks) });
     }
     case "taskCheckpoint":
@@ -7026,16 +6750,15 @@ function reduceAction(state, action) {
         if (update === void 0) return t;
         const idleSince = update.idleSince ?? null;
         const isolation = update.isolation ?? t.isolation;
-        const transport = update.transport;
         const awaitingReason = update.awaitingReason;
         const checkpoint = update.checkpoint;
         const continuable = update.continuable === true;
         const awaitingApproval = update.awaitingApproval;
         const mergeGate = update.mergeGate;
         const forcedPastGate = update.forcedPastGate;
-        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation) || !sameTransport(transport, t.transport) || awaitingReason !== t.awaitingReason || checkpoint !== t.checkpoint || continuable !== (t.continuable ?? false) || awaitingApproval !== t.awaitingApproval || !sameList(mergeGate, t.mergeGate) || !sameList(forcedPastGate, t.forcedPastGate)) {
+        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation) || awaitingReason !== t.awaitingReason || checkpoint !== t.checkpoint || continuable !== (t.continuable ?? false) || awaitingApproval !== t.awaitingApproval || !sameList(mergeGate, t.mergeGate) || !sameList(forcedPastGate, t.forcedPastGate)) {
           changed = true;
-          return { ...t, status: update.status, idleSince, isolation, transport, awaitingReason, checkpoint, continuable, awaitingApproval, mergeGate, forcedPastGate };
+          return { ...t, status: update.status, idleSince, isolation, awaitingReason, checkpoint, continuable, awaitingApproval, mergeGate, forcedPastGate };
         }
         return t;
       });
@@ -7046,12 +6769,6 @@ function reduceAction(state, action) {
       const status = runStatus(next, tasks);
       return step({ ...next, status, busyLabel: status === "executing" ? runLabel(tasks, gate) : state.busyLabel });
     }
-    case "queueReady": {
-      if (stale(state, action.sessionId)) return step(state);
-      const sessionId = action.sessionId ?? state.sessionId;
-      if (sessionId === null) return step(state);
-      return step(state, [{ type: "processQueued", sessionId }]);
-    }
     case "isolationBlocked": {
       if (stale(state, action.sessionId)) return step(state);
       return step(blockedPicker(state, action.message, action.repos));
@@ -7084,6 +6801,14 @@ function reduceAction(state, action) {
         busyLabel: ""
       });
     }
+    case "executionLost": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step({
+        ...say(state, "error", "Lost the connection to the daemon \u2014 this view is no longer following the run, but the daemon may still be running it. /load this session again to see where it stands."),
+        status: "idle",
+        busyLabel: ""
+      });
+    }
     case "settingsLoaded":
       return step(applySettings(state, action.settings));
     case "modelsLoaded":
@@ -7118,7 +6843,7 @@ function reduceAction(state, action) {
         busyLabel: "",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core33.EMPTY_HOLD,
+        queuedPrompts: import_core34.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
@@ -7174,9 +6899,6 @@ function reduceAction(state, action) {
       return step(disarmStop(state));
   }
 }
-function sameTransport(a, b) {
-  return a?.kind === b?.kind && a?.fallback === b?.fallback;
-}
 function sameList(a, b) {
   return (a ?? []).join("\0") === (b ?? []).join("\0");
 }
@@ -7185,7 +6907,7 @@ function sameGate(a, b) {
   return a.paused === b.paused && JSON.stringify(a.handoff) === JSON.stringify(b.handoff);
 }
 function runStatus(state, tasks) {
-  if (tasks.some(import_core23.isTaskRunning)) return "executing";
+  if (tasks.some(import_core24.isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user") || state.gate?.paused) return "executing";
   return plannerInFlight(state) ? state.status : "idle";
 }
@@ -7246,7 +6968,11 @@ function submit(state) {
   if (!text) return step(state);
   const cleared = { ...state, editor: commit(state.editor) };
   const command = parseSlash(text);
-  if (command && findCommand(command.name)?.source !== "skill") return runCommand(cleared, command);
+  if (command) {
+    const known = findCommand(command.name);
+    if (known && known.source !== "skill") return runCommand(cleared, command);
+    if (state.taskView) return known ? skillInTaskView(cleared, command.name) : unknownCommand(cleared, command.name);
+  }
   if (state.taskView) {
     if (!state.sessionId) return step(state);
     const taskId = state.taskView.taskId;
@@ -7254,7 +6980,7 @@ function submit(state) {
     return step(cleared, [{ type: "sendTaskMessage", sessionId: state.sessionId, taskId, text }]);
   }
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core33.holdPrompt)(state.queuedPrompts, text) });
+    return step({ ...cleared, queuedPrompts: (0, import_core34.holdPrompt)(state.queuedPrompts, text) });
   }
   const spoken = say(cleared, "user", text);
   const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: text } : { type: "startConversation", goal: text };
@@ -7313,17 +7039,18 @@ function createApp(deps) {
 }
 
 // src/tui/effects.ts
-var import_child_process4 = require("child_process");
-var import_core35 = require("@ordewell/core");
+var import_child_process3 = require("child_process");
+var import_core36 = require("@ordewell/core");
 
 // src/tui/inbound.ts
-var import_core34 = require("@ordewell/core");
+var import_core35 = require("@ordewell/core");
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
   "planner_message",
   "planner_turn_started",
   "planner_turn_ended",
   "planner_text_delta",
   "planner_thinking_delta",
+  "planner_skill_loaded",
   "planner_text_retracted",
   "plan_token",
   "plan_generated",
@@ -7531,8 +7258,7 @@ function dispatchLifecycle(dispatch, event, sessionId) {
           status: String(task.status),
           idleSince: task.idleSince ?? null,
           isolation: task.isolation,
-          transport: task.transport,
-          awaitingReason: (0, import_core34.isAwaitingReason)(task.awaitingReason) ? task.awaitingReason : void 0,
+          awaitingReason: (0, import_core35.isAwaitingReason)(task.awaitingReason) ? task.awaitingReason : void 0,
           ...typeof task.checkpoint === "string" && task.checkpoint ? { checkpoint: sanitize(task.checkpoint) } : {},
           ...task.continuable ? { continuable: true } : {},
           awaitingApproval: typeof task.awaitingApproval === "number" && task.awaitingApproval > 0 ? task.awaitingApproval : void 0,
@@ -7558,13 +7284,6 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     case "review_approved":
       dispatch({ type: "notice", message: "Plan approved." });
       return;
-    // The orchestrator paused fan-out because a structural edit is queued; drain
-    // it so the planner reconciles the plan and dependents resume spawning.
-    // Dropped on the floor, the queue suppresses every later tick() — which is
-    // exactly "tasks did not fan out when the dependent ones finished."
-    case "queue_ready":
-      dispatch({ type: "queueReady", sessionId });
-      return;
     case "execution_complete":
       dispatch({ type: "executionComplete", summary: event.summary, sessionId });
       return;
@@ -7614,8 +7333,7 @@ async function runEffect(effect, deps) {
     await perform(effect, deps);
   } catch (err) {
     if (!isConnectionRefused(err)) {
-      const message = err instanceof Error ? err.message : String(err);
-      deps.dispatch({ type: "failed", message: explain(message) });
+      deps.dispatch({ type: "failed", message: explain(err) });
       return;
     }
     let revived = false;
@@ -7632,21 +7350,20 @@ async function runEffect(effect, deps) {
     try {
       await perform(effect, deps);
     } catch (retryErr) {
-      const message = retryErr instanceof Error ? retryErr.message : String(retryErr);
       deps.dispatch({
         type: "failed",
         // A fresh daemon holds no sessions, so the retry of anything
         // session-scoped legitimately 404s. Say which of the two happened.
-        message: isConnectionRefused(retryErr) ? describeConnectionRefused(deps.port) : explain(message)
+        message: isConnectionRefused(retryErr) ? describeConnectionRefused(deps.port) : explain(retryErr)
       });
     }
   }
 }
-function explain(message) {
-  if (message === "Session not found") {
+function explain(err) {
+  if (err instanceof DaemonError && err.code === "session_not_found") {
     return "This server is no longer holding that session \u2014 it was probably restarted. Reload it with /sessions.";
   }
-  return message;
+  return err instanceof Error ? err.message : String(err);
 }
 function persistAfterDaemon(deps, env) {
   for (const [key, value] of Object.entries(env)) deps.setEnvVar(key, value);
@@ -7702,19 +7419,15 @@ async function perform(effect, deps) {
       timer.unref?.();
       return;
     }
-    case "processQueued":
-      await api.processQueued(effect.sessionId);
-      await refreshPlan(deps, effect.sessionId);
-      return;
     case "taskAction": {
       const { sessionId, taskId, action } = effect;
-      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : (0, import_core35.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
+      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : (0, import_core36.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
       await (effect.watch ? withExecutionStream(deps, sessionId, request) : request());
       await refreshPlan(deps, sessionId);
       return;
     }
     case "addTask": {
-      const fields = (0, import_core35.newTaskFields)(effect.title);
+      const fields = (0, import_core36.newTaskFields)(effect.title);
       if (!fields) return;
       await api.addTask(effect.sessionId, { ...fields });
       await refreshPlan(deps, effect.sessionId);
@@ -7753,18 +7466,6 @@ async function perform(effect, deps) {
       if (effect.answer === "approve") await api.approveTaskCheckpoint(effect.sessionId, effect.taskId);
       else await api.rejectTaskCheckpoint(effect.sessionId, effect.taskId, effect.reason);
       return;
-    // A task with a saved log ran structured, whatever its `transport` says
-    // after a reload; it has no tmux window, so open the log rather than fail.
-    case "openTaskTerminal": {
-      const saved = await api.getTaskLogAttempts(effect.sessionId, effect.taskId, workspace).catch(() => []);
-      if (saved.length > 0) {
-        dispatch({ type: "taskViewRequested", sessionId: effect.sessionId, taskId: effect.taskId });
-        return;
-      }
-      const result = await deps.openTerminal(effect.sessionId, effect.taskId);
-      dispatch(result.ok ? { type: "notice", message: result.message } : { type: "failed", message: result.message });
-      return;
-    }
     // The saved log is read off disk (ADR-0018, P1) so the view opens with the
     // task's history; the live `task_log` stream then catches it up in place.
     case "openTaskLog": {
@@ -7816,18 +7517,6 @@ async function perform(effect, deps) {
       await api.interruptTask(effect.sessionId, effect.taskId);
       dispatch({ type: "notice", message: "Interrupting the task\u2026" });
       return;
-    case "command": {
-      const result = await api.sendCommand(effect.name, { action: effect.action });
-      if (result.settings) dispatch({ type: "settingsLoaded", settings: result.settings });
-      dispatch({ type: "notice", message: `${effect.name} is ${effect.action}.` });
-      return;
-    }
-    case "setTransport": {
-      const result = await api.sendCommand("transport", { action: effect.transport });
-      if (result.settings) dispatch({ type: "settingsLoaded", settings: result.settings });
-      dispatch({ type: "notice", message: `Runner transport is ${effect.transport} \u2014 it applies from the next run.` });
-      return;
-    }
     case "setModel":
       await api.updateSettings({ orchestratorModel: effect.modelId });
       deps.setEnvVar("ORCHESTRATOR_MODEL", effect.modelId);
@@ -7835,11 +7524,11 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core35.ALL_PROVIDERS[effect.provider];
+      const meta = import_core36.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
-      const recall2 = describePlannerSwitch(settings, effect.provider);
+      const recall2 = plannerSwitchRecall(settings);
       persistAfterDaemon(deps, { ...env, ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
       dispatch({
         type: "settingsLoaded",
@@ -7847,7 +7536,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core35.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core36.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -7859,7 +7548,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core35.ALL_PROVIDERS[effect.provider];
+      const meta = import_core36.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -7897,7 +7586,7 @@ async function perform(effect, deps) {
       return;
     case "setAutonomous":
       deps.setEnvVar("ORDEWELL_AUTONOMOUS_MODE", String(effect.enabled));
-      dispatch({ type: "notice", message: `Autonomy level: ${(0, import_core35.autonomyLevelLabel)(effect.enabled)} for new plans.` });
+      dispatch({ type: "notice", message: `Autonomy level: ${(0, import_core36.autonomyLevelLabel)(effect.enabled)} for new plans.` });
       return;
     case "setMouseCapture":
       deps.setMouseCapture(effect.enabled);
@@ -8023,7 +7712,7 @@ async function perform(effect, deps) {
   }
 }
 var pipeToClipboardDefault = (command, text) => {
-  (0, import_child_process4.execSync)(command, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+  (0, import_child_process3.execSync)(command, { input: text, stdio: ["pipe", "ignore", "ignore"] });
 };
 function osc52(text) {
   return `\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`;
@@ -8031,7 +7720,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core35.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core36.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -8049,15 +7738,20 @@ function copySelection(deps, text) {
 async function withExecutionStream(deps, sessionId, request) {
   let settleReady = () => {
   };
-  const streamReady = new Promise((resolve3, reject) => {
-    settleReady = (error) => error ? reject(error) : resolve3();
+  const streamReady = new Promise((resolve4, reject) => {
+    settleReady = (error) => error ? reject(error) : resolve4();
   });
   const inbound = inboundFor(deps.api, deps.dispatch, sessionId);
   const stream = deps.api.streamExecution(sessionId, inbound.execution(), settleReady);
   void stream.catch(settleReady);
-  await streamReady;
-  await request();
-  await stream;
+  try {
+    await streamReady;
+    await request();
+  } catch (err) {
+    deps.api.closeExecutionStream(stream);
+    throw err;
+  }
+  if (await stream === "lost") deps.dispatch({ type: "executionLost", sessionId });
 }
 async function converse(deps, sessionId, call) {
   const inbound = inboundFor(deps.api, deps.dispatch, sessionId);
@@ -8087,7 +7781,7 @@ function restoredChat(plan, sessionId) {
 function lastAssistantMessage(plan) {
   const history = plan?.conversationHistory ?? [];
   for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i].role === "assistant") {
+    if (history[i].role === "assistant" && history[i].kind !== "skill_load") {
       const { content, timestamp } = history[i];
       return { content, ...timestamp ? { timestamp } : {} };
     }
@@ -8422,7 +8116,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core36.assertWorkspaceExists)(workspace);
+    (0, import_core37.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -8431,7 +8125,9 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core36.createSkillsService)(workspace).listSkills());
+  const discoveredSkills = (0, import_core37.createSkillsService)(workspace, new import_core37.EnvConfig().workspaceRepos).listSkills();
+  registerSkillCommands(discoveredSkills);
+  const taskSkills = discoveredSkills.filter((s) => s.appliesTo === "task").map((s) => ({ name: s.name, description: s.description }));
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
   const targetPort = explicitPort ? resolvePort(subArgs) : await findFreePort();
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(targetPort, { detached: false });
@@ -8441,19 +8137,18 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
   const autoMode = process.env.ORDEWELL_AUTONOMOUS_MODE;
   const mouseCapture = process.env.ORDEWELL_TUI_MOUSE !== "false" && process.env.ORDEWELL_TUI_MOUSE !== "0";
   const app = createApp({
-    initial: { workspace, autonomous: autoMode !== "false" && autoMode !== "0", mouseCapture },
+    initial: { workspace, autonomous: autoMode !== "false" && autoMode !== "0", mouseCapture, taskSkills },
     draw: (frame2) => terminal?.draw(frame2),
     perform: (effect) => runEffect(effect, {
       api,
       workspace,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core36.mintSessionId)(),
+      newSessionId: () => (0, import_core37.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
       },
-      openTerminal: (sessionId, taskId) => openTaskTerminal(port, sessionId, taskId),
       setMouseCapture: (enabled) => terminal?.setMouse(enabled),
       // The alt screen is up with the cursor hidden, so an OSC 52 write shows
       // nothing — the terminal reads it and answers by taking the clipboard.
@@ -8467,7 +8162,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     }),
     onExit: () => shutdown(0),
     // The same pointer `ordewell plan` leaves, so `ordewell handoff`,
-    // `terminal <n>` and the other one-shot commands act on the session this
+    // The one-shot commands act on the session this
     // TUI is showing instead of saying there is none.
     onSessionChange: (sessionId, state) => {
       try {
@@ -8499,6 +8194,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     app.dispatch({ type: "resize", rows: r, cols: c });
   });
   process.on("uncaughtException", (err) => {
+    terminal?.close();
     console.error(`Fatal: ${err.message}`);
     shutdown(1);
   });
@@ -8524,12 +8220,9 @@ var COMMANDS = {
   key: handleKey,
   runners: handleRunners,
   auto: handleAuto,
-  transport: handleTransport,
   refresh: handleRefresh,
   setup: handleSetup,
-  plugins: handlePlugins,
-  "tdd": handleTdd,
-  "verify": handleVerify,
+  skills: handleSkills,
   "mark-complete": handleMarkComplete,
   complete: handleMarkComplete,
   uncomplete: handleUncomplete,
@@ -8547,8 +8240,8 @@ var COMMANDS = {
   "task-effort": handleTaskEffort,
   "task-mode": handleTaskMode,
   "task-deps": handleTaskDeps,
+  "task-skills": handleTaskSkills,
   "task-ops": handleTaskOps,
-  terminal: handleTerminal,
   "sessions": handleSessions,
   fork: handleFork,
   compact: handleCompact,
@@ -8559,10 +8252,10 @@ var COMMANDS = {
 
 // src/version.ts
 var import_fs7 = require("fs");
-var import_path5 = require("path");
+var import_path6 = require("path");
 function cliVersion() {
   try {
-    const pkg = JSON.parse((0, import_fs7.readFileSync)((0, import_path5.join)(__dirname, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_fs7.readFileSync)((0, import_path6.join)(__dirname, "..", "package.json"), "utf8"));
     const version = pkg.version;
     return typeof version === "string" && version ? version : "unknown";
   } catch {
@@ -8573,7 +8266,7 @@ function cliVersion() {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core37.migrateOldConfigDir)();
+  (0, import_core38.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");