@ordewell/cli 0.7.2 → 0.8.1

package/dist/main.js

@@ -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 parallel [<n>]         How many AI tasks run at once (default 5; 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)
@@ -224,7 +223,7 @@ Environment:
   ORDEWELL_PORT              Daemon port CLI commands target (default: 3742)
   ORDEWELL_DIRENV            false: agents skip the project's direnv .envrc
   ORDEWELL_RESEARCH_ENABLED  true (default) or false
-  ORDEWELL_MAX_PARALLEL      Default: 3 \u2014 set with "ordewell parallel"
+  ORDEWELL_MAX_PARALLEL      Default: 5, set with "ordewell parallel"
 `);
 }
 
@@ -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", () => {
@@ -473,7 +472,7 @@ var ApiClient = class _ApiClient {
     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();
@@ -498,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 });
           }
         });
       });
@@ -514,17 +513,17 @@ var ApiClient = class _ApiClient {
     });
   }
   async generatePlan(goal, runners2, workspace, sessionId = (0, import_core3.mintSessionId)()) {
-    const { plan, models, modelsByRunner } = await this.call("POST", `/api/plans/${sessionId}/generate`, "Plan generation failed", {
+    const { plan, models, modelsByRunner, notes } = await this.call("POST", `/api/plans/${sessionId}/generate`, "Plan generation failed", {
       goal,
       runners: runners2 || void 0,
       workspace
     });
-    return { sessionId, plan, models, 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.call("POST", `/api/plans/${sessionId}/converse/start`, "Planning failed", {
@@ -754,7 +753,7 @@ var ApiClient = class _ApiClient {
   streamExecution(sessionId, onEvent, onReady) {
     let endStream = () => {
     };
-    const stream = new Promise((resolve3, reject) => {
+    const stream = new Promise((resolve4, reject) => {
       this.executionStreams.get(sessionId)?.();
       const socket = this.openSessionSocket(sessionId);
       let resolved = false;
@@ -767,7 +766,7 @@ var ApiClient = class _ApiClient {
         if (resolved) return;
         resolved = true;
         socket.close();
-        resolve3();
+        resolve4();
       };
       this.executionStreams.set(sessionId, end);
       endStream = end;
@@ -791,7 +790,7 @@ var ApiClient = class _ApiClient {
         resolved = true;
         if (opened) {
           socket.close();
-          resolve3("lost");
+          resolve4("lost");
         } else {
           reject(err);
         }
@@ -801,7 +800,7 @@ var ApiClient = class _ApiClient {
         if (!opened) onReady?.(new Error("Execution stream closed before connecting"));
         if (!resolved) {
           resolved = true;
-          resolve3("lost");
+          resolve4("lost");
         }
       });
     });
@@ -829,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 {
@@ -844,12 +843,6 @@ var ApiClient = class _ApiClient {
     });
     return { ready, close: () => socket.close() };
   }
-  getCommands() {
-    return this.call("GET", "/api/commands", "Failed to fetch commands");
-  }
-  sendCommand(name, args = {}) {
-    return this.call("POST", `/api/commands/${name}`, `Command ${name} failed`, { args });
-  }
   getSettings() {
     return this.call("GET", "/api/settings", "Failed to fetch settings");
   }
@@ -1111,10 +1104,15 @@ function hasCommittedPlan(plan) {
 function lastPlannerMessage(plan) {
   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 = [];
@@ -1122,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) => {
@@ -1140,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() {
@@ -1275,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",
@@ -1282,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",
@@ -1313,11 +1313,14 @@ ${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);
+    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.`);
@@ -1520,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();
@@ -1552,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) {
@@ -1602,13 +1606,13 @@ 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") {
@@ -2031,100 +2035,60 @@ function handleSetup(subArgs) {
   console.log("Review and edit the file, then run: ordewell tui");
 }
 
-// src/commands/plugins.ts
+// src/commands/skills.ts
 var import_core15 = require("@ordewell/core");
-function handlePlugins(subArgs) {
-  const registry = new import_core15.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_core15.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);
-    }
+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);
   }
 }
 
@@ -2214,39 +2178,6 @@ 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_core16 = require("@ordewell/core");
 var PAST_TENSE = {
@@ -3267,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_core22 = 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_core22.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_core22.tmuxSessionName)(port);
-  const socket = (0, import_core22.tmuxSocketName)(port);
-  const base = (0, import_core22.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
@@ -3430,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);
   });
 }
@@ -3591,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) => {
@@ -3761,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" },
@@ -3776,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" },
@@ -3802,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"
     });
@@ -4001,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")})`;
@@ -4047,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) {
@@ -4201,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 [];
@@ -4216,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;
 }
@@ -4249,10 +4106,6 @@ function tokenLine(blocks, cols) {
 
 // src/tui/state.ts
 var import_core24 = require("@ordewell/core");
-var SKILL_IDS = ["tdd", "verify"];
-function noSkills() {
-  return { tdd: false, verify: false };
-}
 function visibleItems(picker2) {
   const filter = picker2.filter.trim().toLowerCase();
   if (!filter) return picker2.items;
@@ -4313,12 +4166,12 @@ function initialState(overrides = {}) {
     taskEditor: null,
     scroll: 0,
     planScroll: null,
-    skills: noSkills(),
     runners: [],
     sessions: [],
     rewindTargets: null,
     models: [],
     modesByRunner: {},
+    taskSkills: [],
     orchestratorModels: [],
     providerErrors: {},
     orchestratorModel: "",
@@ -4328,7 +4181,6 @@ function initialState(overrides = {}) {
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
-    runnerTransport: "structured",
     mouseCapture: true,
     selection: null,
     workspace: process.cwd(),
@@ -4403,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",
@@ -4418,7 +4271,7 @@ function footerHints(state) {
       "s skip",
       "a add",
       "d remove",
-      "t terminal",
+      "enter log",
       ...resolveHint,
       "pgup/pgdn scroll",
       "tab chat"
@@ -4739,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}` : "";
@@ -4798,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 };
 }
@@ -4843,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"),
@@ -4865,7 +4718,7 @@ function render(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),
@@ -4950,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" : "";
@@ -5374,6 +5223,17 @@ function pickerItemsFor(state, action) {
       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 [];
@@ -5526,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";
@@ -5575,13 +5430,13 @@ 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_core28.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 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 };
 }
@@ -5742,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);
@@ -5882,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);
@@ -5952,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 }));
@@ -5974,7 +5872,6 @@ function handlePlanKey(state, key) {
   }
   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 }]);
   }
@@ -5983,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) {
@@ -6053,13 +5951,10 @@ function plannerEscape(state) {
 
 // src/tui/reducers/commands.ts
 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 } });
@@ -6093,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":
@@ -6131,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();
@@ -6157,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,
@@ -6190,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);
@@ -6406,11 +6294,6 @@ function setAutonomous(state, 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_core31.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]");
@@ -6588,6 +6471,11 @@ function choose(state, picker2, item) {
       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.`));
@@ -6705,28 +6593,17 @@ 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_core33.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
   };
 }
@@ -6873,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;
       });
@@ -7023,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");
 }
@@ -7095,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;
@@ -7162,7 +7039,7 @@ function createApp(deps) {
 }
 
 // src/tui/effects.ts
-var import_child_process4 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_core36 = require("@ordewell/core");
 
 // src/tui/inbound.ts
@@ -7173,6 +7050,7 @@ var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
   "planner_turn_ended",
   "planner_text_delta",
   "planner_thinking_delta",
+  "planner_skill_loaded",
   "planner_text_retracted",
   "plan_token",
   "plan_generated",
@@ -7380,7 +7258,6 @@ function dispatchLifecycle(dispatch, event, sessionId) {
           status: String(task.status),
           idleSince: task.idleSince ?? null,
           isolation: task.isolation,
-          transport: task.transport,
           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 } : {},
@@ -7589,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": {
@@ -7652,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);
@@ -7859,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`;
@@ -7885,8 +7738,8 @@ 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);
@@ -7928,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 } : {} };
     }
@@ -8272,7 +8125,9 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core37.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 });
@@ -8282,7 +8137,7 @@ 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,
@@ -8294,7 +8149,6 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
         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.
@@ -8308,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 {
@@ -8366,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,
@@ -8389,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,
@@ -8401,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 {