@jabworks/condux 0.19.0 → 0.21.0

package/index.js

@@ -13,13 +13,18 @@
 // separate `npx skills add` step for condux. This works because the config hook
 // mutates the cached config before OpenCode lazily discovers skills.
 //
-// It also pushes workflow's routing.md onto config.instructions, giving
-// OpenCode the same `/workflow`-as-entry-point enforcement Claude Code and
-// Codex get from their SessionStart hook — OpenCode has no hook system for
-// that, so `instructions` (ambient every turn, verified via `opencode debug
-// config` against a config-hook mutation) is the closest equivalent. Costs
-// ~390 tokens/turn, permanently; that trade was made deliberately, not by
-// default (docket #38).
+// It also carries workflow's routing.md — the payload Claude Code and Codex
+// get from their SessionStart hook — into the session as a `synthetic: true`
+// `<system-reminder>` text part on the first user message of every *main*
+// session (`chat.message`), re-injected after compaction. That is the shape
+// OpenCode's own plan-mode reminders use (session/reminders.ts): it reaches
+// the model in the user turn rather than mid-system-prompt, and it never
+// reaches subagent sessions. Verified live on OpenCode 1.18.25 — the part
+// persists (`chat.message` runs before the message is saved, and its parts
+// array is the one written) and the model sees it. Per main-session turn it
+// costs the same ~390 tokens as the `config.instructions` channel it replaces
+// (docket #38 ratified that trade; docket #72 relocated the payload out of
+// the system prompt and out of subagents).
 //
 // Optional plan-review listener (CONDUX_PLAN_REVIEW=1): when the primary
 // `plan` agent finishes a turn (session.idle), spawns the plan-review annotate
@@ -29,6 +34,7 @@
 
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
 import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -62,6 +68,56 @@ function loadBundledAgents() {
   return agents;
 }
 
+// The routing payload, framed the way OpenCode frames its own reminders. Null
+// when routing.md is missing or empty — then the hook is a no-op, the same
+// fail-open contract the Claude Code and Codex SessionStart scripts follow.
+function loadRoutingReminder() {
+  if (!existsSync(ROUTING_MD)) return null;
+  const payload = readFileSync(ROUTING_MD, 'utf8').trim();
+
+  return payload ? `<system-reminder>\n${payload}\n</system-reminder>` : null;
+}
+
+// What the compaction summariser is asked to keep. The full reminder is
+// re-injected on the next user message; this only stops the summary from
+// describing a session in which the router never existed.
+const COMPACTION_CONTEXT =
+  'Carry this rule into the summary: every implementation request in this session starts by loading the ' +
+  '`workflow` skill (`skill(name="workflow")`) before any other condux skill or any edit.';
+
+// A part id in OpenCode's own ascending format — `prt_` + six big-endian bytes
+// of (ms << 12 | counter) + fourteen base62 characters — so the reminder sorts
+// among the parts OpenCode minted. The counter is pinned to its maximum: a
+// part created in the same millisecond as the user's text must still order
+// after it. The reminder follows the prompt, never precedes it.
+const BASE62 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+function partId() {
+  const stamp = BigInt(Date.now()) * 0x1000n + 0xfffn;
+  const bytes = Buffer.alloc(6);
+  for (let i = 0; i < 6; i++) bytes[i] = Number((stamp >> BigInt(40 - 8 * i)) & 0xffn);
+  let suffix = '';
+  for (const byte of randomBytes(14)) suffix += BASE62[byte % 62];
+
+  return `prt_${bytes.toString('hex')}${suffix}`;
+}
+
+// True when the session's stored history still shows the reminder to the
+// model: a synthetic text part with exactly this text on a user message that
+// comes after the last compaction. Compaction narrows the model's view to the
+// summary plus a short tail, so a reminder on the far side of one counts as
+// absent — the next user message gets it again.
+export function historyIsRouted(messages, reminder) {
+  let routed = false;
+  for (const { info, parts = [] } of messages) {
+    if (parts.some((part) => part.type === 'compaction')) routed = false;
+    if (info?.role !== 'user') continue;
+    if (parts.some((part) => part.type === 'text' && part.synthetic === true && part.text === reminder)) routed = true;
+  }
+
+  return routed;
+}
+
 // The annotate server ships inside the plan-review skill; look for it in every
 // skill tree OpenCode discovers (project then global).
 function findAnnotateServer(worktree) {
@@ -82,11 +138,54 @@ function findAnnotateServer(worktree) {
   return null;
 }
 
-export const ConduxPlugin = async ({ worktree }) => {
+export const ConduxPlugin = async ({ worktree, client }) => {
   const bundled = loadBundledAgents();
+  const reminder = loadRoutingReminder();
   const activeAgent = new Map();
+  // Sessions whose live history carries the reminder, as far as this process
+  // knows. A compaction clears the entry so the next user message re-injects.
+  const routed = new Set();
+  const isChild = new Map();
   let warnedPayloadShape = false;
 
+  // Subagent sessions never get the router: their brief is the task the parent
+  // handed them, and "every request starts at workflow" contradicts coder's.
+  // The bundled agent names are the free path; the parent lookup catches every
+  // other child (OpenCode's own `general`, user-defined subagents) — `task`
+  // creates them with parentID set, and `chat.message` carries their agent
+  // name. Unknown counts as main: the instructions channel this replaces
+  // reached subagents too, so leaning toward injection is the known state.
+  async function isSubagentSession(input) {
+    if (input.agent && bundled[input.agent]?.mode === 'subagent') return true;
+    if (typeof client?.session?.get !== 'function') return false;
+    if (!isChild.has(input.sessionID)) {
+      try {
+        const { data } = await client.session.get({ path: { id: input.sessionID } });
+        isChild.set(input.sessionID, Boolean(data?.parentID));
+      } catch {
+        isChild.set(input.sessionID, false);
+      }
+    }
+
+    return isChild.get(input.sessionID);
+  }
+
+  // On first sight of a session in this process — fresh, resumed, or after a
+  // compaction cleared it — ask the server whether the reminder is already in
+  // the model's view instead of trusting process memory: a resumed session
+  // would otherwise be injected twice, a compacted one never.
+  async function alreadyRouted(sessionID) {
+    if (routed.has(sessionID)) return true;
+    if (typeof client?.session?.messages !== 'function') return false;
+    try {
+      const { data } = await client.session.messages({ path: { id: sessionID } });
+
+      return Array.isArray(data) && historyIsRouted(data, reminder);
+    } catch {
+      return false;
+    }
+  }
+
   return {
     config: async (cfg) => {
       cfg.agent ??= {};
@@ -116,13 +215,40 @@ export const ConduxPlugin = async ({ worktree }) => {
         cfg.skills.paths ??= [];
         if (!cfg.skills.paths.includes(SKILLS_DIR)) cfg.skills.paths.push(SKILLS_DIR);
       }
+      // routing.md deliberately does NOT go on cfg.instructions any more: that
+      // channel is global (every subagent session read it) and lands mid
+      // system prompt. The reminder below is the replacement (docket #72).
+    },
+
+    // Route through workflow the way Claude Code and Codex do at SessionStart:
+    // one reminder on the first user message of a main session. Runs before
+    // the message is saved, so the pushed part is persisted with the rest.
+    'chat.message': async (input, output) => {
+      if (!reminder || !input?.sessionID || !output?.message?.id || !Array.isArray(output.parts)) return;
+      if (await isSubagentSession(input)) return;
+      if (await alreadyRouted(input.sessionID)) {
+        routed.add(input.sessionID);
 
-      // Route through /workflow the same way Claude Code and Codex do —
-      // see the file-header comment for why `instructions` is the mechanism.
-      if (existsSync(ROUTING_MD)) {
-        cfg.instructions ??= [];
-        if (!cfg.instructions.includes(ROUTING_MD)) cfg.instructions.push(ROUTING_MD);
+        return;
       }
+
+      output.parts.push({
+        id: partId(),
+        messageID: output.message.id,
+        sessionID: input.sessionID,
+        type: 'text',
+        synthetic: true,
+        text: reminder,
+      });
+      routed.add(input.sessionID);
+    },
+
+    // Compaction narrows the model's view to a summary plus a short tail. Ask
+    // the summariser to keep the rule; the next user message re-injects the
+    // full reminder (the `session.compacted` event below clears the session).
+    'experimental.session.compacting': async (input, output) => {
+      if (!reminder || !Array.isArray(output?.context)) return;
+      if (input?.sessionID && routed.has(input.sessionID)) output.context.push(COMPACTION_CONTEXT);
     },
 
     'chat.params': async (input) => {
@@ -130,6 +256,11 @@ export const ConduxPlugin = async ({ worktree }) => {
     },
 
     event: async ({ event }) => {
+      if (event.type === 'session.compacted') {
+        routed.delete(event.properties?.sessionID);
+
+        return;
+      }
       if (process.env.CONDUX_PLAN_REVIEW !== '1') return;
       if (event.type !== 'session.idle') return;
       const sessionID = event.properties?.sessionID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jabworks/condux",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "OpenCode plugin for the condux workflow toolkit — bundles the condux skills and injects the specialist agents (coder, explorer, planner, researcher) plus an opt-in plan-review listener.",
   "type": "module",
   "publishConfig": {

package/skills/blueprint/SKILL.md

@@ -46,19 +46,19 @@ product family.
 │  Standalone: open in the browser (xdg-open / open). If neither   │
 │  works (headless, SSH), print the absolute paths and continue —  │
 │  never fail on delivery.                                         │
-│  Inside /discovery: open NOTHING. Cite the file's path in the    │
-│  design doc as inline code and let the running preview reload —  │
-│  see Inside the Workflow.                                        │
+│  Inside /discovery: open NOTHING. Link the file from the design  │
+│  doc (label = href = its served-root-relative path) and let the  │
+│  running preview reload — see Inside the Workflow.               │
 │  Either way, always state which mode was produced                │
 │  and offer the flip: "wireframe mode — say 'promote to render'   │
 │  for the full house look" (or the reverse). The mode is never    │
 │  chosen silently.                                                │
 │                                                                  │
-│  Step 4: CITE                                                    │
-│  Cite the files' paths (inline code, git-root-relative) in the   │
-│  design doc or task card that motivated them, so the visual      │
-│  target travels with the design. Never a clickable relative      │
-│  link — those 404 in the review preview.                         │
+│  Step 4: LINK                                                    │
+│  Link the files from the design doc or task card that motivated  │
+│  them — a markdown link whose href and label are the same        │
+│  served-root-relative path — so the visual target travels with   │
+│  the design and the click opens it in the review preview.        │
 └──────────────────────────────────────────────────────────────────┘
 ```
 
@@ -115,17 +115,18 @@ mockup into the spec directory first and cite the committed copy.
   | What states are legal and what moves between them? | state machine |
   | What goes where on a screen, and in what order does it read? | wireframe |
 
-  **Inside discovery, deliver by citing — never by opening.** The reader
+  **Inside discovery, deliver by linking — never by opening.** The reader
   already has the design preview open (discovery launches it at §1 and it
-  live-reloads on every write). Add the mockup's git-root-relative path to the
-  design doc as inline code and the citation appears there; the reader opens
-  the file from the editor or filesystem. Never a clickable relative link —
-  the annotate server serves only the review page and `/api/*`, so relative
-  links 404 in the preview. And never an inlined copy of the diagram beside
-  the artifact: one fact, two homes is how the copies drift. A tab per section
-  is the interruption this avoids; standalone invocations keep opening on
-  deliver. Side-by-side option *picking* stays with discovery's own
-  mockup-picker.
+  live-reloads on every write). Add a markdown link whose href and label are
+  the same served-root-relative path — `[mockups/flow.html](mockups/flow.html)`
+  — and the link appears in the doc; the preview serves enumerated sibling
+  `.html`/`.svg` files script-dead, so clicking opens the artifact. An older
+  preview shows the path as the label and loses nothing. Never a
+  git-root-relative href (it cannot resolve against the served root), and
+  never an inlined copy of the diagram beside the artifact: one fact, two
+  homes is how the copies drift. A tab per section is the interruption this
+  avoids; standalone invocations keep opening on deliver. Side-by-side option
+  *picking* stays with discovery's own mockup-picker.
 - **/draft-plan** task cards may cite mockup paths so an implementer sees the
   visual target for their task.
 - Standalone asks ("mock this up", "visualize the data model") run the same

package/skills/condux-doctor/SKILL.md

@@ -46,7 +46,10 @@ else on the machine competes with it. Only `broken` affects the exit code.
 - **plan-review's Codex Stop hook** — resolved, never executed. It blocks a
   turn for up to four days waiting on a human by design.
 - **OpenCode** — `@jabworks/condux` in the plugin array, and when a local
-  copy exists, that it ships its bundled `agents/` and `skills/`.
+  copy exists, that it ships its bundled `agents/` and `skills/` and that the
+  routing reminder it injects names the OpenCode verb, `skill(name="workflow")`
+  — a payload still saying `/condux:workflow` is the docket #72 under-firing
+  shape, reported broken with an upgrade as the fix.
 - **The four specialist agents** — `coder`, `explorer`, `planner`,
   `researcher`. They live in a plugin-level directory reached by its own sync
   step, which is exactly the mirror that drifted once before.

package/skills/condux-doctor/doctor.mjs

@@ -338,12 +338,29 @@ function probeOpencode(hosts) {
     return {
       host: 'opencode',
       status: 'broken',
-      detail: 'the installed package ships no workflow/hooks/routing.md — /workflow routing enforcement is missing',
+      detail: 'the installed package ships no workflow/hooks/routing.md — the plugin has no routing reminder to inject',
       fix: `reinstall ${PACKAGE}`,
     };
   }
 
-  return { host: 'opencode', status: 'done', detail: 'registered, and the installed package ships its agents, skills, and /workflow routing enforcement' };
+  // Since @jabworks/condux 0.21.0 the payload is rewritten for OpenCode:
+  // `/condux:workflow` is a Claude Code command the host cannot run, and a
+  // payload still naming it is the docket #72 under-firing shape — installed,
+  // but asking for a verb the model has to translate on its own.
+  if (!fs.readFileSync(routing, 'utf8').includes('skill(name="workflow")')) {
+    return {
+      host: 'opencode',
+      status: 'broken',
+      detail: 'the installed routing payload names /condux:workflow, which OpenCode cannot run — the reminder under-fires',
+      fix: `upgrade ${PACKAGE} to 0.21.0 or later`,
+    };
+  }
+
+  return {
+    host: 'opencode',
+    status: 'done',
+    detail: 'registered, and the installed package ships its agents, skills, and a routing reminder that names the OpenCode verb',
+  };
 }
 
 // The four specialist agents are plugin-level and reached by their own sync

package/skills/discovery/SKILL.md

@@ -59,8 +59,9 @@ Accept either answer, same as any other soft gate in this skill.
 │  §1 is approaches-and-tradeoffs; the rest follow the design.   │
 │  Full contract: The Section Card, below.                        │
 │  Does a section's decision turn on one of blueprint's five     │
-│  questions? Load `blueprint` — the artifact path is cited      │
-│  in the design doc as inline code, not opened in a new tab.    │
+│  questions? Load `blueprint` — the artifact is linked from     │
+│  the design doc (label = href = the served-root-relative       │
+│  path), not opened in a new tab.                                │
 │                                                                  │
 │  Step 4: DETAIL ROUND — feed the spec                           │
 │  With the approach chosen, ask ONE more batch, grouped by      │
@@ -180,7 +181,7 @@ before they are inside it. Then create the design file and open the preview
 ## §n of N · <name>                    ← position, always
 <one line: what this section decides>
 
-<the evidence — table, list, or a cited artifact path. Never a wall.>
+<the evidence — table, list, or a linked artifact path. Never a wall.>
 
 **Recommendation:** <X>, because <one sentence>.
 <the decision, as named options>
@@ -201,12 +202,14 @@ the design existed only as scrollback, so the thread was lost between them. The
 **Visuals.** Load `blueprint` when a section's decision turns on one of its five
 questions — what entities exist · what happens in what order · what talks to
 what · what states are legal · what goes where on a screen. Inside discovery
-the artifact's git-root-relative path is *cited in the design doc as inline
-code* (e.g. `.condux/designs/assets/checkout-flow.html`), never opened in its
-own tab and never written as a clickable relative link — the annotate server
-serves only the review page and `/api/*`, so a relative link 404s in the
-preview. The preview reloads and shows the citation; the reader opens the
-file from the editor or filesystem.
+the artifact is *linked from the design doc*, never opened in its own tab: a
+markdown link whose href and label are the same served-root-relative path —
+`[mockups/checkout-flow.html](mockups/checkout-flow.html)` — one string, no
+drift. The preview serves enumerated sibling `.html`/`.svg` files
+script-dead, so the click opens the artifact; an older preview simply shows
+the path as the label, and nothing degrades without a server. Never write a
+git-root-relative href (it cannot resolve against the served root), and
+never inline a copy of the diagram beside the artifact.
 
 ## The Design File and the Live Preview (Step 3 onward)
 
@@ -287,15 +290,16 @@ Honour an `AGENTS.md` path override if the project defines one.
 
 For full design mockups — UI wireframes and renders in the house token
 language, data-model / flow / architecture diagrams — load the `blueprint`
-skill; the design doc cites the paths of the files it produces as inline
-code, and the running preview shows the citation rather than a new tab
-opening. At sign-off, offer to promote the chosen wireframes to render mode
-(a style-block swap). If the spec references a blueprint artifact, promote
-the file too: copy it into the spec directory and cite the committed path —
-a committed spec may never point into `.condux/`, which is gone on any other
-clone (workflow's citation-direction rule). For *picking between*
-side-by-side options in the browser, see `references/mockup-picker.md` (it
-can point at blueprint's files).
+skill; the design doc links the files it produces (served-root-relative
+markdown links, label = href), and the running preview serves the artifact
+on click rather than a new tab opening on deliver. At sign-off, offer to
+promote the chosen wireframes to render mode (a style-block swap). If the
+spec references a blueprint artifact, promote the file too: copy it into
+the spec directory and link the committed path — a committed spec may never
+point into `.condux/`, which is gone on any other clone (workflow's
+citation-direction rule). For *picking between* side-by-side options in the
+browser, see `references/mockup-picker.md` (it can point at blueprint's
+files).
 
 ## Design Review Loop
 

package/skills/discovery/references/design-template.md

@@ -31,7 +31,7 @@ feature: <slug>
 |---|---|
 | <alternative> | <one line> |
 
-<evidence — table, list, or a cited blueprint artifact path. Never a wall.>
+<evidence — table, list, or a linked blueprint artifact (served-root-relative, label = href). Never a wall.>
 
 ## Constraints & out of scope                [accumulates — rows added any time]
 

package/skills/plan-review/references/annotate-server.js

@@ -131,6 +131,35 @@ function readPlan(doc) {
   } catch (e) { return ''; }
 }
 
+// Artifact serving: sibling *.html / *.svg files (blueprint mockups and
+// diagrams), enumerated with the same walk rules as listDocs(). Membership in
+// this list is the only door — the request URL is never path-resolved, so
+// traversal shapes can't reach the filesystem. Stdin-mode plans live in
+// os.tmpdir() (see main), where a sibling walk would enumerate unrelated
+// files; artifact serving is off there.
+function artifactRoot() {
+  if (tmpPlanFile) return null;
+  return DIR_MODE ? planFile : path.dirname(planFile);
+}
+
+function listArtifacts() {
+  const root = artifactRoot();
+  if (!root) return [];
+  const out = [];
+  (function walk(rel) {
+    let entries;
+    try { entries = fs.readdirSync(path.join(root, rel || '.'), { withFileTypes: true }); }
+    catch (e) { return; }
+    entries.forEach(function (e) {
+      if (e.name[0] === '.') return;
+      const r = rel ? rel + '/' + e.name : e.name;
+      if (e.isDirectory()) walk(r);
+      else if (/\.(html|svg)$/i.test(e.name) && !/\.feedback\./i.test(e.name)) out.push(r);
+    });
+  })('');
+  return out;
+}
+
 function watchPlan() {
   try {
     if (DIR_MODE) {
@@ -318,7 +347,13 @@ function handler(req, res) {
 
   if (req.method === 'GET' && p === '/') {
     res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-    return res.end(TEMPLATE.replace(/\{\{PLAN_NAME\}\}/g, escapeHtml(path.basename(planFile))));
+    return res.end(TEMPLATE
+      .replace(/\{\{PLAN_NAME\}\}/g, escapeHtml(path.basename(planFile)))
+      // Decision-bar affordance: manual mode defers the decision to a file the
+      // agent reads at its next checkpoint; every other mode (steer, hook,
+      // codex) has a live listener blocked on the decision, so only true
+      // manual may carry the deferred copy.
+      .replace(/\{\{MODE\}\}/g, CODEX_STOP_MODE ? 'codex' : HOOK_MODE ? 'hook' : STEER_MODE ? 'steer' : 'manual'));
   }
   if (req.method === 'GET' && p === '/api/plan') {
     res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
@@ -383,6 +418,23 @@ function handler(req, res) {
     });
     return;
   }
+  if (req.method === 'GET' && p !== '/' && p.indexOf('/api/') !== 0) {
+    // Enumerated artifacts only (see listArtifacts). Served script-dead:
+    // CSP sandbox gives the document an opaque origin and disables script
+    // execution, so an agent-authored artifact can never reach /api/*.
+    let rel = null;
+    try { rel = decodeURIComponent(p.slice(1)); } catch (e) { /* malformed → 404 */ }
+    if (rel && listArtifacts().indexOf(rel) >= 0) {
+      try {
+        const body = fs.readFileSync(path.join.apply(path, [artifactRoot()].concat(rel.split('/'))));
+        res.writeHead(200, {
+          'Content-Type': /\.svg$/i.test(rel) ? 'image/svg+xml' : 'text/html; charset=utf-8',
+          'Content-Security-Policy': 'sandbox',
+        });
+        return res.end(body);
+      } catch (e) { /* deleted between walk and read → 404 */ }
+    }
+  }
   res.writeHead(404);
   res.end();
 }

package/skills/plan-review/references/plan-review-template.html

@@ -1648,14 +1648,21 @@
         });
         updateBadges(); updateSummary();
       }
+      // Server mode, injected at render. 'manual' = no live listener: the
+      // decision lands in the feedback file and the agent reads it at its next
+      // checkpoint. Anything else (steer, or an unreplaced literal from an
+      // older server) keeps the live-submission copy.
+      const SERVER_MODE='{{MODE}}';
+      const MANUAL=SERVER_MODE==='manual';
       // Live summary in the decision bar — what rides along with the decision.
       function updateSummary(){
         const n=annotations.filter(function(a){return a.kind==='note';}).length;
         const m=annotations.filter(function(a){return a.kind==='chat';}).length;
         const parts=[];
         if(n)parts.push(n+' note'+(n>1?'s':'')); if(m)parts.push(m+' message'+(m>1?'s':''));
-        document.getElementById('dbar-summary').textContent=
-          parts.length?parts.join(' · ')+' will be sent with your decision':'No notes or messages yet — a decision sends on its own';
+        document.getElementById('dbar-summary').textContent=MANUAL
+          ?(parts.length?parts.join(' · ')+' will be recorded with your decision — the agent reads it at its next checkpoint':'Decisions are recorded for the agent — it reads them at its next checkpoint')
+          :(parts.length?parts.join(' · ')+' will be sent with your decision':'No notes or messages yet — a decision sends on its own');
       }
       function updateBadges(){
         const counts={}, docCounts={};
@@ -1680,18 +1687,29 @@
       }
 
       // Per-decision confirmation copy — what the agent does with each verdict.
+      // Two tables: live (steer) and deferred (manual). Manual copy never
+      // implies a listener, and never pulses a waiting dot — nothing is waiting.
       const SENT={
         'Approve':          {cls:'approve',ico:'✓',wait:false,title:'Approved',sub:'Sent to the agent — it will proceed and implement the plan.'},
         'Request Revisions':{cls:'revise', ico:'',wait:true, title:'Revisions requested',sub:'Your notes are on their way. The agent will revise the plan; the updated version reloads here when it’s ready.'},
         'Reject':           {cls:'deny',   ico:'✕',wait:false,title:'Rejected',sub:'Sent to the agent — it will not implement this. It steps back to reconsider whether the feature should be built at all.'},
       };
+      const SENT_MANUAL={
+        'Approve':          {cls:'approve',ico:'✓',wait:false,title:'Approval recorded',sub:'Saved to the feedback file — the agent reads it at its next checkpoint. Nothing is watching live.'},
+        'Request Revisions':{cls:'revise', ico:'',wait:false,title:'Revisions recorded',sub:'Saved to the feedback file — the agent picks your notes up at its next checkpoint. Nothing is watching live.'},
+        'Reject':           {cls:'deny',   ico:'✕',wait:false,title:'Rejection recorded',sub:'Saved to the feedback file — the agent reads it at its next checkpoint. Nothing is watching live.'},
+      };
       let submitting=false, decisionSent=false;
       function clearAllNotes(){
         annotations.slice().forEach(function(a){ if(a.kind==='note') unhighlight(a.id); });
         annotations.length=0; nextId=1; paint();
       }
-      function showSent(decision){
-        const cfg=SENT[decision]||SENT['Request Revisions'];
+      function showSent(decision,mode){
+        // The toast follows the mode /api/feedback reports; the injected
+        // constant is the fallback when the response carried none.
+        const manual=(mode||SERVER_MODE)==='manual';
+        const table=manual?SENT_MANUAL:SENT;
+        const cfg=table[decision]||table['Request Revisions'];
         document.getElementById('dbar-live').style.display='none';
         const ico=document.getElementById('sent-ico');
         ico.className='ico'+(cfg.wait?' dot':''); ico.textContent=cfg.wait?'':cfg.ico;
@@ -1715,11 +1733,13 @@
           // conversation would mean two different notes.
           const r=await fetch('/api/feedback',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({decision:decision,thread:threadOrder()})});
           if(!r.ok) throw new Error('status '+r.status);
+          let mode=SERVER_MODE;
+          try{ mode=(await r.json()).mode||mode; }catch(e){}
           hideApiError();
           decisionSent=true;    // a terminal decision makes the server exit —
                                  // the SSE drop that follows is expected, not a fault
           clearAllNotes();      // notes clear the moment the decision is sent
-          showSent(decision);
+          showSent(decision,mode);
         }catch(e){
           showApiError('Could not send your decision — the review server may be unreachable. Nothing was sent; try again.');
           document.querySelectorAll('.dbar button').forEach(function(b){b.disabled=false;});
@@ -1729,6 +1749,13 @@
       document.getElementById('send').onclick=sendChat;
       document.getElementById('input').addEventListener('keydown',function(e){if((e.metaKey||e.ctrlKey)&&e.key==='Enter')sendChat();});
       document.querySelectorAll('.dbar button[data-decision]').forEach(function(b){b.onclick=function(){submit(b.dataset.decision);};});
+      // Manual mode: the buttons record, they don't transmit — say so.
+      if(MANUAL){
+        const RECORD={'Approve':'Record approval','Request Revisions':'Record revisions','Reject':'Record rejection'};
+        document.querySelectorAll('.dbar button[data-decision]').forEach(function(b){
+          if(RECORD[b.dataset.decision]) b.textContent=RECORD[b.dataset.decision];
+        });
+      }
 
       // ---- Revision diff (self-contained line-level LCS, no deps) ----
       function lineDiff(a,b){

package/skills/workflow/hooks/routing.md

@@ -1,7 +1,7 @@
 <EXTREMELY_IMPORTANT>
 You have condux — this session's agentic workflow system.
 
-**Every implementation request starts at `/condux:workflow`.** Feature, bug fix,
+**Every implementation request starts at the `workflow` skill — `skill(name="workflow")`.** Feature, bug fix,
 refactor, new endpoint, UI change, "can you add…", "can you fix…" — all of it
 routes there first. The router infers the tier (Small / Medium / Large), confirms
 it with the user, then executes the matching flow, loading downstream skills only
@@ -13,7 +13,7 @@ when a step needs them.
 `root-cause-analysis`, `live-verification`, `plan-review`, `technical-spec`.
 
 If you find yourself reaching for one of those as the *first* skill of a task,
-you have skipped the router — go back to `/condux:workflow`. Debugging is the
+you have skipped the router — go back to the `workflow` skill — `skill(name="workflow")`. Debugging is the
 most common miss: a crash report, a stack trace, or "why does this fail" is
 still a dev task, so it routes through workflow, which loads
 `root-cause-analysis` at the right moment.
@@ -25,4 +25,6 @@ user instructions — "skip workflow", "just do it", "I've already planned this"
 **Not everything is a dev task.** Questions, explanations, code reading, research,
 and one-line factual answers route nowhere — answer them directly. Routing a
 conversation through a workflow is as wrong as skipping the router on a feature.
+
+**On OpenCode, a `/name` mention of any condux skill means the `skill` tool:** `/workflow` → `skill(name="workflow")`, `/finalize` → `skill(name="finalize")`, and so on. None of them is a slash command here.
 </EXTREMELY_IMPORTANT>