quoxcli 0.4.0 → 0.6.0

package/lib/commands/mon.js

@@ -25,6 +25,7 @@
  *     None of the three are org-scoped (single shared config/cache).
  */
 
+import { attachWazuhVerbs } from './wazuh.js';
 import { formatOutput, formatDetail, printSuccess, printWarning, printInfo } from '../core/output.js';
 import { parseJSON } from './helpers.js';
 import { resolveEndpoint } from '../api/endpoints.js';
@@ -77,6 +78,17 @@ function reportDockerReadFailures(data) {
   return false;
 }
 
+/**
+ * AGH-chain reads answer 202 { status: 'computing' } while the collector builds them in the
+ * background; an empty body then is not data. Says so and returns true (caller stops).
+ */
+function reportComputing(program, data, message) {
+  if (!data || data.status !== 'computing') return false;
+  if (program.opts().output === 'json') { console.log(JSON.stringify(data, null, 2)); return true; }
+  printWarning(message);
+  return true;
+}
+
 export function registerMonCommands(program, ctx) {
   const { client, auth } = ctx;
 
@@ -262,147 +274,48 @@ export function registerMonCommands(program, ctx) {
     .command('wazuh')
     .description('Wazuh security monitoring: manager status, agents, alerts, vulnerabilities');
 
-  wazuh
-    .command('status')
-    .description('Show Wazuh manager status')
-    .action(async () => {
-      auth.requireAuth();
-      const ep = resolveEndpoint('mon.wazuh.manager-status.get');
-      const data = await client.get(ep.path, { service: ep.service });
-      formatDetail(data.data || data, { format: program.opts().output, title: 'Wazuh Manager Status' });
-    });
-
-  wazuh
-    .command('agents')
-    .description('List Wazuh agents')
-    .option('--status <status>', 'filter by agent status')
-    .option('--limit <n>', 'max results')
-    .option('--offset <n>', 'result offset')
-    .option('--q <query>', 'query string passed through to the Wazuh API')
-    .action(async (options) => {
-      auth.requireAuth();
-      const ep = resolveEndpoint('mon.wazuh.agents.list');
-      const query = {};
-      if (options.status) query.status = options.status;
-      if (options.limit) query.limit = options.limit;
-      if (options.offset) query.offset = options.offset;
-      if (options.q) query.q = options.q;
-      const data = await client.get(ep.path, { service: ep.service, query });
-      const agents = data.data?.data?.affected_items || data.data?.affected_items || data.data || [];
-      formatOutput({
-        columns: ['id', 'name', 'ip', 'status', 'version'],
-        headers: ['ID', 'Name', 'IP', 'Status', 'Version'],
-        rows: Array.isArray(agents) ? agents : [],
-      }, { format: program.opts().output, emptyMessage: 'No Wazuh agents found.' });
-    });
-
-  wazuh
-    .command('alerts')
-    .description('Query recent Wazuh alerts')
-    .option('--q <query>', 'search text (rule description / agent name / rule groups)')
-    .option('--limit <n>', 'max results (default 50, capped at 500)')
-    .action(async (options) => {
-      auth.requireAuth();
-      const ep = resolveEndpoint('mon.wazuh.alerts.list');
-      const query = {};
-      if (options.q) query.q = options.q;
-      if (options.limit) query.limit = options.limit;
-      const data = await client.get(ep.path, { service: ep.service, query });
-      formatOutput({
-        columns: ['timestamp', 'rule', 'agent', 'level'],
-        headers: ['Time', 'Rule', 'Agent', 'Level'],
-        rows: (data.data || []).map(a => ({
-          timestamp: a.timestamp,
-          rule: a.rule?.description || '',
-          agent: a.agent?.name || '',
-          level: a.rule?.level ?? '',
-        })),
-      }, { format: program.opts().output, emptyMessage: 'No alerts found.' });
-    });
-
-  wazuh
-    .command('vulns')
-    .description('Query current vulnerability states')
-    .option('--agent-id <id>', 'filter by agent ID')
-    .option('--agent-name <name>', 'filter by agent name')
-    .option('--severity <severity>', 'filter by severity')
-    .option('--limit <n>', 'max results (default 100, capped at 1000)')
-    .action(async (options) => {
-      auth.requireAuth();
-      const ep = resolveEndpoint('mon.wazuh.vulnerabilities.list');
-      const query = {};
-      if (options.agentId) query.agent_id = options.agentId;
-      if (options.agentName) query.agent_name = options.agentName;
-      if (options.severity) query.severity = options.severity;
-      if (options.limit) query.limit = options.limit;
-      const data = await client.get(ep.path, { service: ep.service, query });
-      formatOutput({
-        columns: ['agent', 'cve', 'severity', 'score'],
-        headers: ['Agent', 'CVE', 'Severity', 'Score'],
-        rows: (data.data || []).map(v => ({
-          agent: v.agent?.name || '',
-          cve: v.vulnerability?.id || '',
-          severity: v.vulnerability?.severity || '',
-          score: v.vulnerability?.score?.base ?? '',
-        })),
-      }, { format: program.opts().output, emptyMessage: 'No vulnerabilities found.' });
-    });
-
-  wazuh
-    .command('deploy-history')
-    .description('Show Wazuh agent deploy history')
-    .option('--mode <mode>', 'latest|all', 'latest')
-    .option('--limit <n>', 'max results (mode=all only)', '200')
-    .action(async (options) => {
-      auth.requireAuth();
-      const ep = resolveEndpoint('mon.wazuh.deploy-history.list');
-      const data = await client.get(ep.path, { service: ep.service, query: { mode: options.mode, limit: options.limit } });
-      formatOutput({
-        // fleet #385 class sweep: the route returns
-        // { hostname, ip, ssh_user, success, message, deployed_at }, but this
-        // declared hostIp/status/deployedAt — three of four columns rendered
-        // as dashes with no error. `success` is a boolean, so it's mapped to
-        // a readable status rather than printed raw.
-        columns: ['hostname', 'ip', 'status', 'deployed_at'],
-        headers: ['Host', 'IP', 'Status', 'Deployed'],
-        rows: (data.deploys || []).map(d => ({
-          ...d,
-          status: d.success ? 'ok' : (d.message ? `failed: ${String(d.message).slice(0, 40)}` : 'failed'),
-        })),
-      }, { format: program.opts().output, emptyMessage: 'No deploy history found.' });
-    });
+  // Read verbs (status, agents, alerts, vulns, deploy-history) are the top-level `quox wazuh` implementation: one code path.
+  // WAZ-10: the three legacy write verbs keep their flags but run through the SAME governed helpers as
+  // `quox wazuh deploy|deploy-bulk|active-response` (wazuh_* tools, held for a human approval). The old
+  // /api/v1/wazuh write routes are retired (410).
+  const { guard, writeTool, deployOne, WazFail } = attachWazuhVerbs(wazuh, program, { client, auth }, { writes: false });
+  const padId = (i) => (/^\d+$/.test(i) ? i.padStart(3, '0') : i);
+  const refuseTargetOverride = (verb, options) => {
+    if (options.wazuhServer || options.bastionHost) {
+      throw new WazFail(`quox mon wazuh ${verb}: --wazuh-server and --bastion-host are not accepted on the governed path, which always uses the org's configured Wazuh manager and bastion. Drop them, or change the Wazuh plugin configuration. Governed verb: quox wazuh ${verb === 'deploy-agent' ? 'deploy' : verb}`);
+    }
+  };
 
   wazuh
     .command('deploy-agent')
-    .description('Queue a Wazuh agent deploy for one host (HITL-gated — requires HITL Inbox approval)')
+    .description('Install the Wazuh agent on one host (governed wazuh_deploy_agent, held for human approval; same as `quox wazuh deploy`)')
     .requiredOption('--hostname <hostname>', 'target hostname')
     .requiredOption('--host-ip <ip>', 'target host IP')
-    .option('--wazuh-server <ip>', 'Wazuh manager IP (defaults to server config)')
-    .option('--bastion-host <ip>', 'bastion host for the SSH hop')
+    .option('--wazuh-server <ip>', 'not accepted: the governed path uses the org\'s configured Wazuh manager')
+    .option('--bastion-host <ip>', 'not accepted: the governed path uses the org\'s configured bastion')
     .option('--ssh-user <user>', 'SSH user', 'control')
     .option('--ssh-port <n>', 'SSH port', '22')
     .option('--force', 'skip confirmation')
-    .action(async (options) => {
+    .action(guard(async (options) => {
       auth.requireAuth();
-      const confirmed = await confirmOrSkip(program, options, `Queue Wazuh agent deploy to ${options.hostname} (${options.hostIp})? This will require HITL Inbox approval before it runs.`);
+      refuseTargetOverride('deploy-agent', options);
+      const confirmed = await confirmOrSkip(program, options, `Request a Wazuh agent deploy to ${options.hostname} (${options.hostIp})? It is held for human approval before it runs.`);
       if (!confirmed) {
         printInfo('Cancelled.');
         return;
       }
-      const body = { hostname: options.hostname, hostIp: options.hostIp, sshUser: options.sshUser, sshPort: options.sshPort };
-      if (options.wazuhServer) body.wazuhServer = options.wazuhServer;
-      if (options.bastionHost) body.bastionHost = options.bastionHost;
-      const ep = resolveEndpoint('mon.wazuh.deploy-agent');
-      const data = await client.post(ep.path, { service: ep.service, body });
-      printSuccess(`Deploy queued — inbox item ${data.inbox_item_id} (awaiting approval).`);
-    });
+      await deployOne(options.hostname, options.hostIp, {
+        sshUser: options.sshUser && options.sshUser !== 'control' ? options.sshUser : undefined,
+        sshPort: options.sshPort && String(options.sshPort) !== '22' ? options.sshPort : undefined,
+      });
+    }));
 
   wazuh
     .command('deploy-bulk')
-    .description('Queue a Wazuh agent deploy for multiple hosts (HITL-gated — requires HITL Inbox approval)')
-    .requiredOption('--hosts <json>', 'JSON array of {hostname, ip} objects')
-    .option('--wazuh-server <ip>', 'Wazuh manager IP (defaults to server config)')
-    .option('--bastion-host <ip>', 'bastion host for the SSH hop')
+    .description('Install the Wazuh agent on several hosts: one governed wazuh_deploy_agent call and one approval per host (same as `quox wazuh deploy-bulk`)')
+    .requiredOption('--hosts <json>', 'JSON array of {hostname, ip[, sshUser, sshPort]} objects')
+    .option('--wazuh-server <ip>', 'not accepted: the governed path uses the org\'s configured Wazuh manager')
+    .option('--bastion-host <ip>', 'not accepted: the governed path uses the org\'s configured bastion')
     .option('--force', 'skip confirmation')
     .action(async (options) => {
       auth.requireAuth();
@@ -410,40 +323,49 @@ export function registerMonCommands(program, ctx) {
       if (!Array.isArray(hosts) || hosts.length === 0) {
         throw new Error('--hosts must be a non-empty JSON array of {hostname, ip} objects.');
       }
-      const confirmed = await confirmOrSkip(program, options, `Queue Wazuh agent deploy to ${hosts.length} host(s)? This will require HITL Inbox approval before it runs.`);
-      if (!confirmed) {
-        printInfo('Cancelled.');
-        return;
-      }
-      const body = { hosts };
-      if (options.wazuhServer) body.wazuhServer = options.wazuhServer;
-      if (options.bastionHost) body.bastionHost = options.bastionHost;
-      const ep = resolveEndpoint('mon.wazuh.deploy-bulk');
-      const data = await client.post(ep.path, { service: ep.service, body });
-      printSuccess(`Bulk deploy queued for ${data.host_count ?? hosts.length} host(s) — inbox item ${data.inbox_item_id} (awaiting approval).`);
+      await guard(async () => {
+        refuseTargetOverride('deploy-bulk', options);
+        const missing = hosts.filter((h) => !h || !h.hostname || !h.ip).map((h) => (h && h.hostname) || '?');
+        if (missing.length) throw new WazFail(`quox mon wazuh deploy-bulk: every host needs hostname and ip; missing for ${missing.join(', ')}`);
+        const confirmed = await confirmOrSkip(program, options, `Request a Wazuh agent deploy to ${hosts.length} host(s)? Each is held for human approval before it runs.`);
+        if (!confirmed) {
+          printInfo('Cancelled.');
+          return;
+        }
+        let failed = 0;
+        for (const h of hosts) {
+          try { await deployOne(String(h.hostname), String(h.ip), { sshUser: h.sshUser, sshPort: h.sshPort }); } catch (err) {
+            if (!(err instanceof WazFail)) throw err;
+            console.error(err.message); failed++;
+          }
+        }
+        if (failed) process.exitCode = 1;
+      })();
     });
 
   wazuh
     .command('active-response')
-    .description('Trigger a Wazuh active response (HITL-gated — requires HITL Inbox approval)')
+    .description('Run a Wazuh active response (governed wazuh_active_response, held for human approval; same as `quox wazuh active-response`)')
     .requiredOption('--command <command>', 'firewall-block|host-isolate|restart-wazuh-agent')
     .requiredOption('--agents <ids>', 'comma-separated Wazuh agent IDs')
     .requiredOption('--reason <text>', 'justification (min 10 characters)')
     .option('--args <args>', 'comma-separated command arguments')
     .option('--force', 'skip confirmation')
-    .action(async (options) => {
+    .action(guard(async (options) => {
       auth.requireAuth();
-      const agentList = options.agents.split(',').map(a => a.trim()).filter(Boolean);
+      const agentList = options.agents.split(',').map(a => a.trim()).filter(Boolean).map(padId);
       const args = options.args ? options.args.split(',').map(a => a.trim()).filter(Boolean) : [];
-      const confirmed = await confirmOrSkip(program, options, `Trigger active response "${options.command}" on ${agentList.length} agent(s)? This will require HITL Inbox approval before it executes.`);
+      if (!agentList.length) throw new WazFail('quox mon wazuh active-response: --agents needs at least one agent id');
+      if (!options.reason || options.reason.trim().length < 10) throw new WazFail('quox mon wazuh active-response: --reason "<why>" is required, at least 10 characters (the approver sees it)');
+      const confirmed = await confirmOrSkip(program, options, `Request active response "${options.command}" on ${agentList.length} agent(s)? It is held for human approval before it runs.`);
       if (!confirmed) {
         printInfo('Cancelled.');
         return;
       }
-      const ep = resolveEndpoint('mon.wazuh.active-response');
-      const data = await client.post(ep.path, { service: ep.service, body: { command: options.command, agentList, args, reason: options.reason } });
-      printSuccess(`Active response queued — inbox item ${data.inbox_item_id} (awaiting approval).`);
-    });
+      const input = { command: options.command, agent_ids: agentList, reason: options.reason.trim() };
+      if (args.length) input.args = args;
+      await writeTool(`active-response ${agentList.join(',')}`, 'wazuh_active_response', input, `${options.command} ran on ${agentList.length} agent(s)`);
+    }));
 
   // ══════════════════════════════════════════════════════════════════════
   // agh-chain
@@ -461,6 +383,7 @@ export function registerMonCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('mon.agh-chain.leaderboard.list');
       const data = await client.get(ep.path, { service: ep.service, query: { window: options.window } });
+      if (reportComputing(program, data, 'The leaderboard is computing, try again shortly.')) return;
       formatOutput({
         columns: ['agent_id', 'claims_made', 'claims_verified', 'claims_stripped', 'unfulfilled_promises', 'honesty_rate'],
         headers: ['Agent', 'Claims Made', 'Verified', 'Stripped', 'Unfulfilled', 'Honesty Rate'],
@@ -477,6 +400,7 @@ export function registerMonCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('mon.agh-chain.leaderboard.get', { agentId });
       const data = await client.get(ep.path, { service: ep.service, query: { window: options.window } });
+      if (reportComputing(program, data, 'These honesty metrics are computing, try again shortly.')) return;
       formatDetail(data, { format: program.opts().output, title: `Honesty metrics: ${agentId}` });
     });
 
@@ -490,6 +414,7 @@ export function registerMonCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('mon.agh-chain.leaderboard.events.list', { agentId });
       const data = await client.get(ep.path, { service: ep.service, query: { window: options.window, guard: options.guard } });
+      if (reportComputing(program, data, 'These drill-through events are computing, try again shortly.')) return;
       formatOutput({
         columns: ['event_id', 'run_id', 'ts', 'payload_preview'],
         headers: ['Event', 'Run', 'Time', 'Preview'],

package/lib/commands/monitoring.js

@@ -10,10 +10,46 @@
  *   GET /api/v1/health/aggregate     — same endpoint `quox status` uses
  *   GET /governance/incidents        — list
  *   GET /governance/incidents/:id    — detail + linked AEE envelopes
+ *   POST /governance/incidents/:id/transition — claim (self only) / move status, witnessed
+ *                                       (quox.governance.incident.updated; lib/governanceIncidentLifecycle.js)
+ *
+ * `incidents list --json` prints a bare array of incidents, the CLI-wide
+ * formatOutput convention for list verbs; proof cases read it by index
+ * (docs/matrix/suites/monitoring.json mon-incidents-open, mon-incident-detail),
+ * so the shape stays as is. `get --json` prints the incident object.
  */
 
 import { formatOutput, formatDetail } from '../core/output.js';
 import { resolveEndpoint } from '../api/endpoints.js';
+import { QuoxError } from '../core/errors.js';
+
+// WAZ P11 slice 1b: statuses a person can move an incident to from the CLI. The collector
+// validates against INCIDENT_STATUSES and enforces the resolution rule too; this only saves a call.
+export const MOVE_STATUSES = ['investigating', 'resolved', 'closed', 'false_positive'];
+const NEEDS_RESOLUTION = new Set(['resolved', 'closed', 'false_positive']);
+const RESOLUTION_MAX = 500;
+
+function printTransition(verb, id, data) {
+  const inc = data.incident || {};
+  const t = data.transition || {};
+  const w = data.witnessed || {};
+  const who = inc.assigned_to ? ` · assigned to ${inc.assigned_to}` : '';
+  const move = t.from && t.to ? `${t.from} -> ${t.to}` : (inc.status || '-');
+  const wit = w.stored ? `witnessed${w.id ? ` (${w.id})` : ''}` : `NOT witnessed (${w.reason || 'no envelope stored'})`;
+  console.log(`${w.stored ? '✔' : '⚠'} incidents ${verb} │ ${inc.id || id} · ${move}${who} │ ${wit}`);
+  if (inc.resolution && NEEDS_RESOLUTION.has(inc.status)) console.log(`  resolution: ${inc.resolution}`);
+}
+
+// Module level (not a closure) so cli/scripts/export-leaf-methods.mjs sees the POST as evidence for both leaves.
+async function postTransition(client, program, verb, id, body) {
+  const ep = resolveEndpoint('governance.incidents.transition', { id });
+  const data = await client.post(ep.path, { service: ep.service, body });
+  if (!data || data.error || !data.incident) {
+    throw new QuoxError(`quox monitoring incidents ${verb}: ${ep.method} ${ep.path} returned an error body: ${(data && (data.error || data.message)) || 'response had no incident'}`, 1);
+  }
+  if (program.opts().output === 'json') { console.log(JSON.stringify(data, null, 2)); return; }
+  printTransition(verb, id, data);
+}
 
 export function registerMonitoringCommands(program, ctx) {
   const { client, auth } = ctx;
@@ -83,4 +119,36 @@ export function registerMonitoringCommands(program, ctx) {
       const data = await client.get(resolveEndpoint('governance.incidents.get', { id }).path, { service: resolveEndpoint('governance.incidents.get', { id }).service });
       formatDetail(data.incident || data, { format: program.opts().output, title: `Incident: ${id}` });
     });
+
+  incidents
+    .command('claim')
+    .description('Claim a governance incident: assigns it to you and moves open to investigating (witnessed)')
+    .argument('<id>', 'incident ID from `quox monitoring incidents list`')
+    .action(async (id) => {
+      auth.requireAuth();
+      await postTransition(client, program, 'claim', id, { assigned_to: 'me' });
+    });
+
+  incidents
+    .command('status')
+    .description(`Move a governance incident to ${MOVE_STATUSES.join('|')}; resolved, closed and false_positive need --resolution (witnessed)`)
+    .argument('<id>', 'incident ID from `quox monitoring incidents list`')
+    .argument('<status>', MOVE_STATUSES.join('|'))
+    .option('--resolution <text>', `what was done or why it is closing (required for resolved, closed, false_positive; max ${RESOLUTION_MAX} chars)`)
+    .action(async (id, status, options) => {
+      if (!MOVE_STATUSES.includes(status)) {
+        throw new QuoxError(`quox monitoring incidents status: status must be one of: ${MOVE_STATUSES.join(', ')} (got "${status}").`, 1);
+      }
+      const resolution = typeof options.resolution === 'string' ? options.resolution.trim() : '';
+      if (NEEDS_RESOLUTION.has(status) && !resolution) {
+        throw new QuoxError(`quox monitoring incidents status: moving to ${status} needs --resolution "<what was done>".`, 1);
+      }
+      if (resolution.length > RESOLUTION_MAX) {
+        throw new QuoxError(`quox monitoring incidents status: --resolution is at most ${RESOLUTION_MAX} characters (got ${resolution.length}).`, 1);
+      }
+      auth.requireAuth();
+      const body = { status };
+      if (resolution) body.resolution = resolution;
+      await postTransition(client, program, 'status', id, body);
+    });
 }

package/lib/commands/notes.js

@@ -10,6 +10,7 @@ import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { basename, dirname, join, resolve } from 'path';
 import { Option } from 'commander';
+import { resolveProfileFlagFromArgv } from '../core/config.js';
 import { formatOutput, formatDetail, printSuccess } from '../core/output.js';
 import { QuoxApiError, QuoxError } from '../core/errors.js';
 import { line as glyphLine, printEvent } from '../core/quoxglyph.js';
@@ -18,6 +19,7 @@ import { resolveOrgId } from './helpers.js';
 import { buildBatchArchive, splitMarkdown, indexMarkdown, MAX_BATCH_NOTES } from './notesBatch.js';
 import { emailToNote, extractTasks, promoteBody } from './notesBridges.js';
 import { linkMention } from './notesLinks.js';
+import { registerNotesSeal } from './notesSeal.js';
 
 const SCOPES = ['org', 'user'];
 const ARCHIVED = ['exclude', 'only', 'include'];
@@ -156,6 +158,8 @@ export function registerNotesCommands(program, ctx) {
     .command('notes')
     .description('NotesQ: governed markdown notes (list, read, write, history, restore)');
 
+  registerNotesSeal(notes, { program, client, auth, call, getNote, putNote, readContent, isJson, printJson, announce, loadEnqrypt: ctx.loadEnqrypt });
+
   const list = async (options, textQuery) => {
     auth.requireAuth();
     checkEnum(options.scope, [...SCOPES, 'all'], '--scope');
@@ -188,10 +192,18 @@ export function registerNotesCommands(program, ctx) {
       updated: when(n),
     }));
     formatOutput({
-      columns: ['id', 'title', 'scope', 'collection', 'tags', 'updated', ...propKeys.map((_, i) => `prop${i}`)],
-      headers: ['ID', 'Title', 'Scope', 'Collection', 'Tags', 'Updated', ...propKeys],
+      columns: ['title', 'scope', 'collection', 'tags', 'updated', ...propKeys.map((_, i) => `prop${i}`), 'id'],
+      headers: ['Title', 'Scope', 'Collection', 'Tags', 'Updated', ...propKeys, 'ID'],
       rows,
-    }, { format: program.opts().output });
+    }, {
+      format: program.opts().output,
+      quietColumn: 'id',
+      emptyMessage: 'No notes found. Widen the filters (--scope all, drop --tag/--q), or create one with `quox notes new`.',
+    });
+    const total = data.total ?? rows.length;
+    if (program.opts().output !== 'json' && rows.length > 0 && rows.length < total) {
+      console.log(`showing ${rows.length} of ${total} · --limit to see more`);
+    }
     announce('notes ls', `${rows.length} of ${data.total ?? rows.length}`);
   };
 
@@ -1116,8 +1128,15 @@ export function registerNotesCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('notesq.notes.proposeSkill', { id });
       const body = { ...(options.name ? { name: options.name } : {}), ...(options.category ? { category: options.category } : {}) };
+      // The route refuses a note under its minimum length with 400 {error:'too_short', min_words}: say so, not a bare 400.
+      const propose = (b, opts = {}) => call(() => client.post(ep.path, { service: ep.service, body: b, ...opts })).catch((e) => {
+        if (e instanceof QuoxApiError && e.status === 400 && e.body && e.body.error === 'too_short') {
+          throw new QuoxError(`Note ${id} is too short to become a skill: it needs at least ${e.body.min_words || 'more'} words of procedure. Add the steps (quox notes edit ${id}) and run again.`, 1);
+        }
+        throw e;
+      });
       if (!options.yes) {
-        const r = await call(() => client.post(ep.path, { service: ep.service, body: { ...body, dry_run: true } }));
+        const r = await propose({ ...body, dry_run: true });
         if (isJson(program)) return printJson(r);
         const p = r.payload || {};
         console.log(`name: ${p.name}`);
@@ -1126,7 +1145,7 @@ export function registerNotesCommands(program, ctx) {
         console.log(String(p.bodyMd || '').split('\n').slice(0, 8).join('\n'));
         return console.log('Re-run with --yes to propose it. It lands as an experimental skill, outside the stable library; an automated safety check reviews it and anything flagged goes to the human review queue (quox skills review).');
       }
-      const r = await call(() => client.post(ep.path, { service: ep.service, body, retries: 0 }));
+      const r = await propose(body, { retries: 0 });
       if (isJson(program)) return printJson(r);
       announce('propose-skill', `${r.skill.name} (${r.skill.id}) experimental`);
       if (!r.note_updated) console.log('Note: the skill was created but the note could not be updated with the link (it changed meanwhile).');
@@ -1225,7 +1244,7 @@ export function registerNotesCommands(program, ctx) {
 
   notes
     .command('scorecard')
-    .description('Run the NotesQ scorecard (scripts/notesq-scorecard.mjs in the dashboard repo), streaming its output')
+    .description('Run the NotesQ scorecard (scripts/notesq-scorecard.mjs in the dashboard repo), streaming its output. WRITE: creates notes through chat (raising approval cards) and deletes them afterwards; the child runs as the same -p profile')
     .option('--keep', 'keep the scorecard\'s test data')
     .action(async (options) => {
       if (!existsSync(scorecardPath)) {
@@ -1235,7 +1254,10 @@ export function registerNotesCommands(program, ctx) {
       const args = [scorecardPath];
       if (options.keep) args.push('--keep');
       const code = await new Promise((done, fail) => {
-        const child = spawn(process.execPath, args, { cwd: resolve(dirname(scorecardPath), '..'), stdio: ['inherit', 'pipe', 'pipe'] });
+        // The child must act as the profile the caller chose, never the resident/attached agent identity.
+        const profile = ctx.profile || resolveProfileFlagFromArgv(process.argv.slice(2)) || process.env.QUOX_PROFILE;
+        const env = profile ? { ...process.env, QUOX_PROFILE: profile } : process.env;
+        const child = spawn(process.execPath, args, { cwd: resolve(dirname(scorecardPath), '..'), env, stdio: ['inherit', 'pipe', 'pipe'] });
         child.stdout.on('data', (c) => process.stdout.write(c));
         child.stderr.on('data', (c) => process.stderr.write(c));
         child.on('error', fail);