@jabworks/condux 0.2.0 → 0.3.0

package/skills/discovery/references/choice-server.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+// Local option-picker surface for /discovery visual mockups. Serves an
+// agent-authored, self-contained HTML mockup, injects click-to-select wiring,
+// and delivers the user's pick back to the agent over a long-poll. No npm deps.
+// Binds 127.0.0.1 only. One-shot: the server exits once a choice is delivered.
+//
+// Usage:
+//   node choice-server.js <mockup.html> [--multi] [--port 7788]
+//
+//   The agent tags each option element in the mockup with data-choice="<label>",
+//   launches this server in the background, then BLOCKS on
+//   GET /api/choice (a long-poll) which resolves when the user picks:
+//     {"choices":["Option B"],"note":"<free text>","submittedAt":"<iso>"}
+//
+//   Single mode (default): clicking an option submits it immediately.
+//   Multi mode (--multi):   clicking toggles; a bottom bar sends the set + note.
+//
+//   Default port 7788 (distinct from plan-review's 7777) so a discovery picker
+//   and a plan-review steer server can run at once. Diagnostics go to stderr.
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+
+const log = console.error; // stdout stays clean; the agent talks to us over HTTP
+
+const MULTI = process.argv.includes('--multi');
+const portArg = (function () { const i = process.argv.indexOf('--port'); return i >= 0 ? parseInt(process.argv[i + 1], 10) : NaN; })();
+const PORT = !isNaN(portArg) ? portArg : 7788;
+
+let choiceWaiter = null;   // pending GET /api/choice response
+let pendingChoice = null;  // choice that arrived before the agent polled
+let delivered = false;     // one-shot guard
+
+let mockupFile;
+
+function fail(msg) { console.error('  choice-picker: ' + msg); process.exit(1); }
+
+function readMockup() {
+  try { return fs.readFileSync(mockupFile, 'utf8'); } catch (e) { return ''; }
+}
+
+// Injected client: wires [data-choice] elements to POST /api/choice. Kept
+// dependency-free and defensive so it works inside whatever HTML the agent wrote.
+function injectedScript() {
+  return `
+<style>
+  #__vc_banner{position:fixed;top:0;left:0;right:0;z-index:99998;font:600 13px/1.4 system-ui,sans-serif;
+    background:#1f2937;color:#fff;padding:10px 16px;text-align:center;box-shadow:0 1px 6px rgba(0,0,0,.25)}
+  body{padding-top:44px}
+  [data-choice]{cursor:pointer;transition:outline-color .12s,box-shadow .12s;outline:2px solid transparent;outline-offset:2px}
+  [data-choice]:hover{outline-color:#93c5fd}
+  [data-choice].__vc_sel{outline-color:#2563eb;box-shadow:0 0 0 4px rgba(37,99,235,.18)}
+  #__vc_bar{position:fixed;bottom:0;left:0;right:0;z-index:99998;display:none;gap:10px;align-items:center;
+    background:#111827;color:#fff;padding:12px 16px;box-shadow:0 -1px 8px rgba(0,0,0,.3);font:14px system-ui,sans-serif}
+  #__vc_bar.__vc_show{display:flex}
+  #__vc_note{flex:1;padding:8px 10px;border-radius:6px;border:1px solid #374151;background:#1f2937;color:#fff;font:14px system-ui,sans-serif}
+  #__vc_send{padding:8px 16px;border:0;border-radius:6px;background:#2563eb;color:#fff;font:600 14px system-ui,sans-serif;cursor:pointer}
+  #__vc_send:disabled{background:#374151;cursor:default}
+  #__vc_done{position:fixed;inset:0;z-index:99999;display:none;align-items:center;justify-content:center;
+    background:rgba(17,24,39,.92);color:#fff;font:600 18px system-ui,sans-serif;text-align:center;padding:24px}
+  #__vc_done.__vc_show{display:flex}
+</style>
+<div id="__vc_banner"></div>
+<div id="__vc_bar"><span id="__vc_count">0 selected</span>
+  <input id="__vc_note" placeholder="Optional note (e.g. B, but with A's header)…" />
+  <button id="__vc_send" disabled>Send selection →</button></div>
+<div id="__vc_done">✓ Sent to the agent — you can close this tab.</div>
+<script>
+(function(){
+  var MULTI = ${MULTI ? 'true' : 'false'};
+  var opts = [].slice.call(document.querySelectorAll('[data-choice]'));
+  var banner = document.getElementById('__vc_banner');
+  var done = document.getElementById('__vc_done');
+  if(!opts.length){ banner.textContent = 'No options found — tag each option element with data-choice="…".'; return; }
+  banner.textContent = MULTI
+    ? 'Click options to select, add an optional note, then Send. Your pick goes back to the agent.'
+    : 'Click an option to send your choice to the agent.';
+  var locked = false;
+  function post(payload){
+    if(locked) return; locked = true;
+    fetch('/api/choice',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(payload)})
+      .then(function(){ done.classList.add('__vc_show'); })
+      .catch(function(){ locked = false; alert('Could not reach the picker server.'); });
+  }
+  if(!MULTI){
+    opts.forEach(function(el){
+      el.addEventListener('click', function(){ post({choices:[el.getAttribute('data-choice')]}); });
+    });
+    return;
+  }
+  var bar = document.getElementById('__vc_bar');
+  var count = document.getElementById('__vc_count');
+  var note = document.getElementById('__vc_note');
+  var send = document.getElementById('__vc_send');
+  var sel = [];
+  function refresh(){
+    count.textContent = sel.length + ' selected';
+    send.disabled = sel.length === 0;
+    bar.classList.toggle('__vc_show', true);
+  }
+  opts.forEach(function(el){
+    el.addEventListener('click', function(){
+      var label = el.getAttribute('data-choice');
+      var i = sel.indexOf(label);
+      if(i >= 0){ sel.splice(i,1); el.classList.remove('__vc_sel'); }
+      else { sel.push(label); el.classList.add('__vc_sel'); }
+      refresh();
+    });
+  });
+  send.addEventListener('click', function(){ if(sel.length) post({choices:sel, note:note.value.trim()}); });
+})();
+</script>`;
+}
+
+function serveMockup(res) {
+  let html = readMockup();
+  const inject = injectedScript();
+  if (/<\/body>/i.test(html)) html = html.replace(/<\/body>/i, inject + '\n</body>');
+  else html += inject;
+  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+  res.end(html);
+}
+
+function sendJson(res, code, obj) {
+  res.writeHead(code, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(obj));
+}
+
+// Deliver a choice to the agent's long-poll, then shut down (one-shot).
+function deliver(payload) {
+  if (delivered) return;
+  delivered = true;
+  if (choiceWaiter) {
+    try { choiceWaiter.writeHead(200, { 'Content-Type': 'application/json' }); choiceWaiter.end(JSON.stringify(payload)); } catch (e) { /* client gone */ }
+    choiceWaiter = null;
+  } else {
+    pendingChoice = payload; // agent hasn't polled yet — the next GET picks it up
+    delivered = false;       // not truly delivered until a GET drains it
+    return;
+  }
+  log('\n  Choice: ' + JSON.stringify(payload.choices) + (payload.note ? '  note: ' + payload.note : '') + ' — delivered to agent. Stopping.\n');
+  setTimeout(function () { process.exit(0); }, 300);
+}
+
+function handler(req, res) {
+  const url = new URL(req.url, 'http://127.0.0.1');
+  const p = url.pathname;
+
+  if (req.method === 'GET' && p === '/') return serveMockup(res);
+
+  if (req.method === 'GET' && p === '/api/choice') {
+    if (pendingChoice) { const c = pendingChoice; pendingChoice = null; delivered = true; sendJson(res, 200, c); log('\n  Choice delivered to agent. Stopping.\n'); return setTimeout(function () { process.exit(0); }, 300); }
+    res.setTimeout(0); // a human may take minutes — don't close the idle socket
+    choiceWaiter = res;
+    req.on('close', function () { if (choiceWaiter === res) choiceWaiter = null; });
+    return;
+  }
+
+  if (req.method === 'POST' && p === '/api/choice') {
+    let body = '';
+    req.on('data', function (c) { body += c; if (body.length > 1e6) req.destroy(); });
+    req.on('end', function () {
+      try {
+        const data = JSON.parse(body);
+        const choices = Array.isArray(data.choices) ? data.choices : (data.choice ? [data.choice] : []);
+        if (!choices.length) return sendJson(res, 400, { error: 'no choices' });
+        sendJson(res, 200, { status: 'received' });
+        deliver({ choices: choices, note: (data.note || '').trim(), submittedAt: new Date().toISOString() });
+      } catch (e) {
+        sendJson(res, 400, { error: 'invalid JSON' });
+      }
+    });
+    return;
+  }
+
+  res.writeHead(404);
+  res.end();
+}
+
+let server;
+function listen() {
+  server = http.createServer(handler);
+  server.on('error', function (e) {
+    if (e && e.code === 'EADDRINUSE') fail('port ' + PORT + ' is in use — pass a free --port <n>.');
+    fail(String((e && e.message) || e));
+  });
+  server.listen(PORT, '127.0.0.1', function () {
+    const url = 'http://127.0.0.1:' + server.address().port;
+    log('\n  Option picker  →  ' + url + (MULTI ? '   (multi-select)' : ''));
+    log('  Mockup         →  ' + mockupFile);
+    log('  Choice         →  GET ' + url + '/api/choice (long-poll)');
+    log('\n  Pick in the browser; the choice returns to the agent. Ctrl+C to stop.\n');
+    const opener = process.platform === 'darwin' ? 'open' :
+                   process.platform === 'win32' ? 'start ""' : 'xdg-open';
+    exec(opener + ' ' + url, function () {});
+  });
+}
+
+process.on('SIGINT', function () {
+  log('\n  Option picker stopped.\n');
+  if (server) server.close(function () { process.exit(0); }); else process.exit(0);
+});
+
+// First non-flag arg is the mockup file (skip --port's value).
+const args = process.argv.slice(2);
+let file = null;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--port') { i++; continue; }
+  if (args[i][0] !== '-') { file = args[i]; break; }
+}
+if (!file || !fs.existsSync(file)) fail('mockup file not found — pass a self-contained HTML file path.');
+mockupFile = path.resolve(file);
+listen();

package/skills/discovery/references/mockup-picker.md

@@ -0,0 +1,90 @@
+# Mockup Picker
+
+Reference for `/discovery`. Use when spatial or visual content communicates better
+than text alone — HTML option mockups, plus the click-to-pick server that returns
+the user's choice straight to the agent.
+
+## When to Go Visual
+
+**Use a browser visual** when:
+- Comparing 2–4 UI layout options side-by-side
+- Architecture diagrams where spatial relationships matter
+- Component hierarchy that's easier to parse visually
+- Design polish decisions where aesthetic is the question
+
+**Stay in terminal** when:
+- Clarifying requirements (A/B/C prose is fine)
+- Tradeoff analysis (a markdown table works)
+- The question has a clear right answer
+- The user would answer in one word
+
+## How to Generate
+
+Write a **self-contained HTML file** — inline all CSS, no external dependencies:
+
+```bash
+# Write the file, then open:
+xdg-open /tmp/discovery-<topic>-$(date +%Y%m).html   # Linux
+open /tmp/discovery-<topic>-$(date +%Y%m).html        # macOS
+```
+
+Use semantic filenames: `discovery-checkout-flow-202601.html`
+
+Tag each option's container element with `data-choice="<label>"` (e.g.
+`<div data-choice="Option A">`). This is inert for a plain open-in-browser
+glance, but it's what the interactive picker below wires up — so add it by
+default.
+
+## HTML Guidelines
+
+- Max 2–4 options per page — more causes decision paralysis
+- Show real content, not lorem ipsum
+- Label each option clearly: **Option A**, **Option B**
+- Tag each option container with `data-choice="Option A"` for click-to-select
+- One-line rationale under each option
+- Keep it light — mockup fidelity, not production polish
+
+## Interactive Pick (Optional)
+
+For a plain glance, opening the file is enough — the user tells you their pick
+in chat. When you want the choice to come **straight back to you** without the
+user re-typing it, serve the mockup through the picker server. The agent
+launches it; the user never starts anything.
+
+Locate the script from the installed `discovery` skill and launch it in the
+background, pointing at the mockup file:
+
+```bash
+CHOICE=$(find ~/.claude ~/.agents ~/.codex -name "choice-server.js" -path "*/discovery/*" 2>/dev/null | head -1)
+node "$CHOICE" /tmp/discovery-checkout-flow-202601.html          # single-select
+node "$CHOICE" /tmp/discovery-checkout-flow-202601.html --multi  # multi-select
+```
+
+It opens the browser automatically. In single mode a click submits instantly;
+in `--multi` mode clicks toggle a selection and a bottom bar sends the set plus
+an optional note. Then **block on the long-poll** and continue once it resolves:
+
+```bash
+curl -s http://127.0.0.1:7788/api/choice
+# → {"choices":["Option B"],"note":"B, but with A's header","submittedAt":"…"}
+```
+
+The server is one-shot: it delivers the pick and exits — no HTML is written to
+disk, nothing for the user to clean up. Port defaults to `7788` (distinct from
+`plan-review`'s `7777`, so both can run at once); pass `--port <n>` to override.
+
+## What NOT to Do
+
+```
+✗ Building a multi-file app just for a mockup
+✗ Making the user start or manage a server (the agent launches the picker itself)
+✗ Showing more than 4 options at once
+✗ Lorem ipsum placeholders when real content is possible
+```
+
+## Return to Terminal
+
+After the user reviews the visual, return to the discovery sign-off flow. If
+you used the picker, the chosen option(s) and any note arrive over the
+long-poll; otherwise capture the decision from chat. Note which option was
+chosen, then continue with `/draft-plan` or the next step.

package/skills/discovery/references/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/skills/draft-plan/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: draft-plan
+description: "Turns a signed-off design into an executable plan of lean task cards (what, why, gotchas, dependencies). Writes Markdown; review in the browser via plan-review. Run for LARGE tasks after /discovery sign-off. Never writes a plan without a signed-off design — if discovery hasn't run, apply the soft gate first."
+argument-hint: "<feature name or design summary>"
+effort: high
+---
+
+# /draft-plan
+
+Turn a signed-off design into a clear, executable plan. Lean task cards, not micro-step novels.
+
+## Usage
+
+```
+/draft-plan $ARGUMENTS
+```
+
+## Before Writing
+
+1. Confirm discovery has run and design is signed off. First glob
+   `.condux/designs/*<slug>*.md` and `specs/<slug>/` (slug = kebab-case
+   of the feature name) for an existing signed-off design — if found,
+   treat this check as satisfied without asking. Otherwise ask: "We
+   haven't aligned on the design yet — run /discovery first, or confirm
+   you want to skip it."
+
+The plan is written as Markdown — optimized for AI agent consumption during
+execution. To read it in the browser, use `plan-review` (see After Saving);
+no separate HTML file is produced.
+
+## How It Works
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                        DRAFT-PLAN                               │
+├──────────────────────────────────────────────────────────────────┤
+│  Step 1: MAP FILES                                              │
+│  List every file to be created or modified.                     │
+│  Assign one clear responsibility per file.                      │
+│  Decomposition decisions get locked in here.                    │
+│                                                                  │
+│  Step 2: WRITE TASK CARDS                                       │
+│  Each card = one meaningful unit of work.                       │
+│  See Task Card Format below.                                    │
+│                                                                  │
+│  Step 3: INLINE SELF-REVIEW                                     │
+│  Check against design:                                          │
+│    ✓ Every requirement maps to a task                           │
+│    ✓ No TBDs, TODOs, or "implement later"                       │
+│    ✓ No undefined references (types, functions, methods)        │
+│    ✓ No "similar to Task N" shortcuts                           │
+│    ✓ Dependencies between tasks are explicit                    │
+│                                                                  │
+│  Step 4: PRESENT TO USER                                        │
+│  Show plan in sections, get sign-off before saving.             │
+│                                                                  │
+│  Step 5: SAVE                                                   │
+│  Write to .condux/plans/ per AGENTS.md or default path.        │
+│  Do NOT modify the plan file after saving.                      │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+## Task Card Format
+
+Each task card is a **top-level `##` heading** — this makes every task a
+first-class entry in the plan-review navigation menu (the TOC is generated
+from headings, and `###` renders as a greyed sub-entry).
+
+```markdown
+## Task N: <Short Name>
+
+**What:** One paragraph — what this task builds or changes.
+
+**Why:** One sentence — why this is needed / what it enables.
+
+**Files:**
+
+- Create: `exact/path/to/file.ts`
+- Modify: `exact/path/to/existing.ts:123-145`
+
+**Interfaces:**
+
+- Consumes: what this task uses from earlier tasks — exact names / signatures
+- Produces: what later tasks rely on — exact function names, parameter and
+  return types (or "None" for a leaf task)
+
+**Sketch:** _(optional)_
+
+```ts
+// only the code worth annotating before it's written
+```
+
+**Gotchas:**
+
+- Use `dayjs` for date handling, not native JS Date
+- This touches the auth middleware — don't change its signature
+- [Any project conventions or known quirks relevant to this task]
+
+**Dependencies:** Task 2, Task 3 (or "None")
+```
+
+The `Interfaces` block carries the typed contract between tasks: a task's
+implementer (especially a subagent) sees only their own card, so `Consumes`
+/ `Produces` is how neighbouring tasks agree on exact names and types. This
+is what prevents drift like `clearLayers()` in Task 3 vs `clearFullLayers()`
+in Task 7.
+
+## Code Sketches
+
+Plans are reviewed by annotation before any code is written, so the cheapest
+place to catch a bad approach is the plan. Include a **Sketch** whenever
+seeing the code changes whether you'd approve the task:
+
+- ✓ The non-obvious algorithm or the tricky transform
+- ✓ A key data shape, schema, or type/interface definition
+- ✓ A function signature whose contract other tasks depend on
+
+Keep sketches to the code that carries a decision. They are illustrative
+intent for the reviewer to tweak — not the final implementation, and not a
+substitute for the implementer's judgement. Do **not** sketch:
+
+- ✗ Boilerplate the implementer will obviously write (CRUD, wiring, imports)
+- ✗ Full file bodies — show the part worth reviewing, elide the rest with `…`
+- ✗ Test code (that belongs to `/test-first-development`)
+- ✗ The TDD micro-step cycle (write test → run → implement → run → commit)
+
+## Plan Document Structure
+
+Fill in `references/plan-template.md` — it is the canonical skeleton, kept
+consistent so the plan-review nav renders the same predictable TOC every
+time (`Overview · Global Constraints · Files Affected · Task Checklist ·
+Task 1…N`). Do not reinvent the section set or reorder it.
+
+```markdown
+# Plan: <Feature Name>
+
+> Date: YYYY-MM-DD
+
+## Overview
+
+**Goal:** one sentence. **Approach:** 2-3 sentences. **Tech / conventions:** key libs and rules.
+
+## Global Constraints
+
+- Project-wide rules copied verbatim from the design/spec (delete if none).
+
+## Files Affected
+
+- `path/to/file.ts` — what it does / what changes
+
+## Task Checklist
+
+- [ ] Task 1: ...
+- [ ] Task 2: ...
+
+---
+
+[Task cards follow — each a top-level ## heading]
+```
+
+## Save Path
+
+Write the plan to `.condux/plans/YYYY-MM-DD-<feature>.md`.
+
+`.condux/` is gitignored working state, created on demand at the git root
+(see `/workflow` → Artifacts). Before the first write, make sure it's
+ignored — see the bootstrap step there.
+
+Check `AGENTS.md` for project-specific overrides.
+
+## After Saving
+
+Once the plan file is saved, always ask — regardless of whether this
+skill was invoked via `/workflow` or standalone:
+
+> "Plan saved to `<path>`. Want to review it in the browser before
+> implementing, or go straight to implementation?"
+
+Accept either answer, same as any other soft gate in this skill.
+
+**If review chosen:** locate `annotate-server.js` from the installed
+`plan-review` skill (`find ~/.claude ~/.codex ~/.agents -name
+annotate-server.js -path '*plan-review*' 2>/dev/null | head -1`) and
+launch it in `--steer` mode against the saved plan file:
+```bash
+node /path/to/plan-review/references/annotate-server.js .condux/plans/<file>.md --steer
+```
+Poll `GET http://127.0.0.1:7777/api/decision` (long-poll — blocks until a
+decision is submitted) and branch on the result:
+- **Approve** → proceed to implementation, using any feedback as notes.
+- **Request Revisions** → revise the plan file in place per the feedback
+  (the open browser tab live-reloads over SSE), then poll again.
+- **Deny** → stop; report the feedback and rework the approach before
+  re-planning.
+
+**If straight to implementation chosen:** proceed directly, no server
+launch.
+
+This applies to the plan doc this skill produces (LARGE tier).
+`/workflow`'s MEDIUM-tier quick-plan uses the same section shape and card
+fields (Overview · Files · Interfaces · Sketch · Gotchas) inline and lean —
+it is not written via this skill, but stays consistent with this structure.
+
+## Plan Failures — Never Write These
+
+```
+✗ "TBD", "TODO", "implement later", "fill in details"
+✗ "Add appropriate error handling" (be specific)
+✗ "Similar to Task N" (repeat the content)
+✗ Steps that describe what to do without saying what changes
+✗ References to types or functions not defined anywhere in the plan
+✗ Micro-steps (write test → run test → write code → run test → commit)
+```
+
+## Task Granularity
+
+Tasks should be **meaningful units of work**, not micro-steps. A task is something a developer would recognize as a coherent piece of work — not "write one function" and not "implement the whole feature."
+
+Ask yourself: could this task be reviewed as a standalone PR? If yes, it's the right size.
+
+## What Does NOT Happen
+
+```
+✗ Full implementations or boilerplate (sketch decision-carrying code only — see Code Sketches)
+✗ Exact commands with expected output
+✗ Test code in the plan (tests are written during /test-first-development)
+✗ Modifying the plan file after it's saved
+✗ Writing a plan without design sign-off
+```

package/skills/draft-plan/evals/trigger_eval.json

@@ -0,0 +1,22 @@
+[
+  { "query": "write the implementation plan", "should_trigger": true, "expected_skill": "draft-plan", "accept": ["workflow"] },
+  { "query": "turn the design into task cards", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "plan out the epic we signed off yesterday", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "create the .condux/plans file for this feature", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "break this down into tasks with dependencies", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "write-plan for checkout v2", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "we havent designed this yet but write a plan anyway", "should_trigger": true, "expected_skill": "draft-plan", "accept": ["discovery"] },
+  { "query": "sketch the code for task 3 in the plan", "should_trigger": true, "expected_skill": "draft-plan", "kind": "in-context" },
+  { "query": "the plan needs revision per the review feedback", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "whats the task card format again", "should_trigger": true, "expected_skill": "draft-plan", "kind": "in-context" },
+  { "query": "plan for migrating to app router, design is signed off", "should_trigger": true, "expected_skill": "draft-plan" },
+  { "query": "how big should a task be, one function or the whole feature", "should_trigger": true, "expected_skill": "draft-plan", "kind": "in-context" },
+  { "query": "can I edit the plan file after saving it", "should_trigger": true, "expected_skill": "draft-plan", "kind": "in-context" },
+  { "query": "quick inline plan for a medium sized task", "should_trigger": true, "expected_skill": "workflow" },
+  { "query": "review the plan in the browser before implementing", "should_trigger": true, "expected_skill": "plan-review" },
+  { "query": "execute the plan with agents", "should_trigger": true, "expected_skill": "subagent-execution" },
+  { "query": "design isnt agreed yet, help me align first", "should_trigger": true, "expected_skill": "discovery" },
+  { "query": "add a task to my todo list", "should_trigger": false, "expected_skill": null },
+  { "query": "plan my sprint for next week", "should_trigger": false, "expected_skill": null },
+  { "query": "make a project timeline gantt chart", "should_trigger": false, "expected_skill": null }
+]

package/skills/draft-plan/references/plan-template.md

@@ -0,0 +1,96 @@
+# Plan: <Feature Name>
+
+> Date: YYYY-MM-DD
+
+## Overview
+
+**Goal:** One sentence — what this builds.
+
+**Approach:** 2–3 sentences on the chosen direction.
+
+**Tech / conventions:** Key libraries, patterns, and rules in play for this work.
+
+## Global Constraints
+
+Project-wide rules that every task must honour — copy exact values verbatim
+from the design/spec, one line each. Delete this section only if there are
+genuinely none.
+
+- <version floor / dependency limit>
+- <naming or copy rule>
+- <platform / runtime requirement>
+
+## Files Affected
+
+- `path/to/file.ts` — what it does / what changes
+- `path/to/other.ts:120-160` — the specific region touched
+
+## Task Checklist
+
+- [ ] Task 1: <Short Name>
+- [ ] Task 2: <Short Name>
+- [ ] Task 3: <Short Name>
+
+---
+
+## Task 1: <Short Name>
+
+**What:** One paragraph — what this task builds or changes.
+
+**Why:** One sentence — why this is needed / what it enables.
+
+**Files:**
+
+- Create: `exact/path/to/file.ts`
+- Modify: `exact/path/to/existing.ts:123-145`
+
+**Interfaces:**
+
+- Consumes: what this task uses from earlier tasks — exact names / signatures
+- Produces: what later tasks rely on — exact function names, parameter and
+  return types. A task's implementer sees only their own card; this block is
+  how neighbouring tasks learn the names and types they share. Use "None" for
+  a leaf task.
+
+**Sketch:** _(optional — include only where seeing the code changes whether
+you'd approve: the non-obvious algorithm, a tricky transform, a key data
+shape or type definition. Skip boilerplate the implementer will obviously
+write.)_
+
+```ts
+type Layer = { id: string; visible: boolean };
+
+// core logic worth reviewing before it's written
+function mergeLayers(base: Layer[], incoming: Layer[]): Layer[] {
+  // …the actual approach, concrete enough to annotate and tweak
+}
+```
+
+**Gotchas:**
+
+- Use `dayjs` for date handling, not native JS `Date`
+- This touches the auth middleware — don't change its signature
+- <any project convention or known quirk relevant to this task>
+
+**Dependencies:** Task 2, Task 3 (or "None")
+
+## Task 2: <Short Name>
+
+**What:** …
+
+**Why:** …
+
+**Files:**
+
+- Create: `…`
+
+**Interfaces:**
+
+- Consumes: …
+- Produces: …
+
+**Gotchas:**
+
+- …
+
+**Dependencies:** …