quoxcli 0.3.1 → 0.5.0

package/lib/commands/memory.js

@@ -27,12 +27,18 @@ import { QuoxError } from '../core/errors.js';
 import { resolveOrgId } from './helpers.js';
 import { resolveMyAttach } from './agentAttach.js';
 import { hasExplicitProfile } from '../core/actingAs.js';
+import { line as glyphLine, printEvent } from '../core/quoxglyph.js';
+import { syncMemoryFiles, expandPaths, defaultMemoryDir } from './memorySync.js';
+import { announce, announceFailure } from '../core/announce.js';
 
 // QUOXIDENTITY P9: which agent this session acts as is resolved session-scoped
 // (QUOX_T subtree / QUOX_ATTACH_AGENT override / single-attach fallback), so
 // two sessions on one box no longer collide. See agentAttach.js resolveMyAttach.
 const detectSoleAttachLease = resolveMyAttach;
 
+// Short, single-line form of a memory's text for the announce line.
+const clip = (t) => { const x = String(t || '').replace(/\s+/g, ' ').trim(); return x.length > 28 ? x.slice(0, 27) + '…' : x; };
+
 /**
  * Call a governed collector memory tool (POST /api/v1/tools/execute).
  * Lease-aware: when exactly one attach lease is active, the call is made
@@ -161,6 +167,7 @@ export function registerMemoryCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('memory.reinstate', { id });
       const data = await client.post(ep.path, { service: ep.service, body: {} });
+      announce('memory', `reinstated ${data.reinstated?.id || id}`);
       if (program.opts().output === 'json') { console.log(JSON.stringify(data, null, 2)); return; }
       printSuccess(`Reinstated ${data.reinstated?.id}; retired ${data.retired?.id} (marked disputed, Dream will not re-apply it)`);
     });
@@ -180,10 +187,56 @@ export function registerMemoryCommands(program, ctx) {
       };
       if (options.tags) body.tags = options.tags.split(',').map(t => t.trim());
       if (options.agent) body.agent_id = options.agent;
-      await client.post(resolveEndpoint('memory.create').path, { service: resolveEndpoint('memory.create').service, body });
+      const label = `${options.type} "${clip(options.content)}"`;
+      let data;
+      try {
+        data = await client.post(resolveEndpoint('memory.create').path, { service: resolveEndpoint('memory.create').service, body });
+      } catch (err) { announceFailure('memory', `save ${label}`, err); throw err; }
+      announce('memory', `saved ${label}`, { result: data?.id || data?.memory?.id });
       printSuccess('Memory saved.');
     });
 
+  // Owner order 2026-10-29: do not replace Claude's file memory, ALSO save it to Quox memory.
+  // Additive and idempotent (see memorySync.js). One QuoxGlyph line per file saved or updated.
+  memory
+    .command('sync')
+    .description("Also save Claude Code's file memory (default: this project's memory dir) into Quox memory. Idempotent, additive, secrets refused")
+    .argument('[paths...]', 'memory files or directories (default: ~/.claude/projects/<this cwd>/memory)')
+    .option('--dry-run', 'show what would be saved without writing')
+    .action(async (paths, options) => {
+      auth.requireAuth();
+      const json = program.opts().output === 'json';
+      const targets = paths && paths.length ? paths : [defaultMemoryDir()];
+      const files = expandPaths(targets);
+      const ep = resolveEndpoint('memory.create');
+      const orgId = auth.getOrgId?.(program.opts().org) || 'default';
+      const results = await syncMemoryFiles({ client, orgId, files, dryRun: !!options.dryRun, memoryEp: ep });
+      const count = (a) => results.filter((r) => r.action === a).length;
+      const summary = {
+        created: count('created'), updated: count('updated'), unchanged: count('unchanged'),
+        refused: count('refused'), errors: count('error') + count('missing'),
+        would_create: count('would-create'), would_update: count('would-update'),
+      };
+      if (json) {
+        console.log(JSON.stringify({ dry_run: !!options.dryRun, summary, results }, null, 2));
+      } else {
+        const q = (r) => `"${r.name}"`;
+        for (const r of results) {
+          if (r.action === 'created') printEvent(glyphLine('memory', `also saved to Quox ${q(r)}`, { status: 'ok' }));
+          else if (r.action === 'updated') printEvent(glyphLine('memory', `updated in Quox ${q(r)}`, { status: 'ok' }));
+          else if (r.action === 'would-create') printEvent(glyphLine('memory', `would save to Quox ${q(r)}`, { status: 'busy' }));
+          else if (r.action === 'would-update') printEvent(glyphLine('memory', `would update in Quox ${q(r)}`, { status: 'busy' }));
+          else if (r.action === 'refused') printEvent(glyphLine('memory', `refused ${r.file.split('/').pop()}`, { result: `secret shape: ${r.kinds.join(', ')}`, status: 'warn' }));
+          else if (r.action === 'error' || r.action === 'missing') printEvent(glyphLine('memory', `sync ${r.file.split('/').pop()}`, { result: r.action === 'missing' ? 'file not found' : (r.error || 'failed').slice(0, 40), status: 'fail' }));
+        }
+        const bits = options.dryRun
+          ? `${summary.would_create} to save, ${summary.would_update} to update, ${summary.unchanged} unchanged`
+          : `${summary.created} saved, ${summary.updated} updated, ${summary.unchanged} unchanged`;
+        console.log(`Memory sync: ${bits}${summary.refused ? `, ${summary.refused} refused (secret shapes)` : ''}${summary.errors ? `, ${summary.errors} failed` : ''}.`);
+      }
+      if (summary.errors) process.exitCode = 1;
+    });
+
   memory
     .command('update')
     .description('Update a memory')
@@ -195,7 +248,10 @@ export function registerMemoryCommands(program, ctx) {
       const body = {};
       if (options.content) body.content = options.content;
       if (options.tags) body.tags = options.tags.split(',').map(t => t.trim());
-      await client.patch(resolveEndpoint('memory.update', { id }).path, { service: resolveEndpoint('memory.update', { id }).service, body });
+      try {
+        await client.patch(resolveEndpoint('memory.update', { id }).path, { service: resolveEndpoint('memory.update', { id }).service, body });
+      } catch (err) { announceFailure('memory', `update ${id}`, err); throw err; }
+      announce('memory', `updated ${id}`, { result: options.content ? `"${clip(options.content)}"` : undefined });
       printSuccess('Memory updated.');
     });
 
@@ -208,7 +264,10 @@ export function registerMemoryCommands(program, ctx) {
       auth.requireAuth();
       const query = {};
       if (options.hard) query.hard = 'true';
-      await client.delete(resolveEndpoint('memory.delete', { id }).path, { service: resolveEndpoint('memory.delete', { id }).service, query });
+      try {
+        await client.delete(resolveEndpoint('memory.delete', { id }).path, { service: resolveEndpoint('memory.delete', { id }).service, query });
+      } catch (err) { announceFailure('memory', `delete ${id}`, err); throw err; }
+      announce('memory', `deleted ${id}`, { result: options.hard ? 'permanent' : 'soft delete' });
       printSuccess('Memory deleted.');
     });
 
@@ -226,7 +285,10 @@ export function registerMemoryCommands(program, ctx) {
       const ep = resolveEndpoint('memory.delete', { id });
       const query = {};
       if (options.permanent) query.hard = 'true';
-      await client.delete(ep.path, { service: ep.service, query });
+      try {
+        await client.delete(ep.path, { service: ep.service, query });
+      } catch (err) { announceFailure('memory', `forget ${id}`, err); throw err; }
+      announce('memory', `forgot ${id}`, { result: options.permanent ? 'erased for good' : 'soft delete' });
       printSuccess(options.permanent ? `Permanently erased memory ${id}.` : `Forgot memory ${id}.`);
     });
 
@@ -333,6 +395,7 @@ export function registerMemoryCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('memory.pin', { id });
       const data = await client.post(ep.path, { service: ep.service, body: {} });
+      announce('memory', `pinned ${id}`, { result: 'core set' });
       if (program.opts().output === 'json') { console.log(JSON.stringify(data, null, 2)); return; }
       printSuccess(`Pinned ${id} into the core set.`);
     });
@@ -345,6 +408,7 @@ export function registerMemoryCommands(program, ctx) {
       auth.requireAuth();
       const ep = resolveEndpoint('memory.unpin', { id });
       const data = await client.delete(ep.path, { service: ep.service });
+      announce('memory', `unpinned ${id}`, { result: 'out of core set' });
       if (program.opts().output === 'json') { console.log(JSON.stringify(data, null, 2)); return; }
       printSuccess(`Unpinned ${id}: it stays a memory, but is no longer in the core set.`);
     });

package/lib/commands/memorySync.js

@@ -0,0 +1,158 @@
+/**
+ * `quox memory sync`: also save agent file memory (Claude Code's
+ * ~/.claude/projects/<slug>/memory/*.md) into Quox memory. ADDITIVE: the Claude
+ * files are only read, never written, and a removed file never deletes a Quox
+ * memory. Idempotent: each file has a stable source key
+ * (claude-memory:<slug>/<file>) and a content hash; unchanged files are skipped,
+ * changed files PATCH the same Quox memory. Files containing secret shapes are
+ * refused (named, never echoed).
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, renameSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { secretKinds } from '../quoxon/secretShape.js';
+
+const MAX_CONTENT = 20000;
+
+/** Claude memory type -> closest Quox memory type (the API accepts fact, preference, decision, observation, entity). */
+export function quoxTypeFor(claudeType) {
+  switch (String(claudeType || '').toLowerCase()) {
+    case 'user': return 'preference';
+    case 'feedback': return 'decision';
+    case 'project': return 'fact';
+    case 'reference': return 'fact';
+    default: return 'observation';
+  }
+}
+
+const unquote = (v) => String(v ?? '').trim().replace(/^(["'])(.*)\1$/, '$2');
+
+/** -> { name, description, type, body } from a Claude memory file (frontmatter optional). */
+export function parseMemoryFile(text, fallbackName = '') {
+  const src = String(text ?? '').replace(/\r\n/g, '\n');
+  let front = '';
+  let body = src;
+  const m = src.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (m) { front = m[1]; body = src.slice(m[0].length); }
+  const out = { name: '', description: '', type: '' };
+  let inMeta = false;
+  for (const raw of front.split('\n')) {
+    const top = raw.match(/^([A-Za-z_]+):\s*(.*)$/);
+    if (top) {
+      inMeta = top[1] === 'metadata';
+      if (top[1] === 'name') out.name = unquote(top[2]);
+      else if (top[1] === 'description') out.description = unquote(top[2]);
+      else if (top[1] === 'type') out.type = unquote(top[2]);
+      continue;
+    }
+    const nested = raw.match(/^\s+type:\s*(.*)$/);
+    if (inMeta && nested) out.type = unquote(nested[1]);
+  }
+  return { name: out.name || fallbackName, description: out.description, type: out.type, body: body.trim() };
+}
+
+/** Stable key: claude-memory:<project slug>/<file>. */
+export function sourceKeyFor(file) {
+  const abs = resolve(file);
+  const parts = abs.split('/');
+  const mi = parts.lastIndexOf('memory');
+  const slug = mi > 0 ? parts[mi - 1] : createHash('sha256').update(dirname(abs)).digest('hex').slice(0, 8);
+  const rel = mi >= 0 ? parts.slice(mi + 1).join('/') : basename(abs);
+  return `claude-memory:${slug}/${rel}`;
+}
+
+/** Default memory dir for a cwd: ~/.claude/projects/<cwd with non-alnum -> '-'>/memory. */
+export function defaultMemoryDir(cwd = process.cwd()) {
+  return join(homedir(), '.claude', 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'), 'memory');
+}
+
+/** Expand dirs to their *.md files; MEMORY.md (the index) is skipped. */
+export function expandPaths(paths) {
+  const files = [];
+  for (const p of paths) {
+    const abs = resolve(p);
+    if (!existsSync(abs)) { files.push({ file: abs, missing: true }); continue; }
+    if (statSync(abs).isDirectory()) {
+      for (const f of readdirSync(abs).sort()) if (f.endsWith('.md')) files.push({ file: join(abs, f) });
+    } else files.push({ file: abs });
+  }
+  return files.filter((f) => f.missing || basename(f.file) !== 'MEMORY.md');
+}
+
+const statePathDefault = () => join(homedir(), '.quox', 'memory-sync-state.json');
+function loadState(p) { try { return JSON.parse(readFileSync(p, 'utf8')) || {}; } catch { return {}; } }
+function saveState(p, state) {
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state, null, 2));
+  renameSync(tmp, p);
+}
+
+/**
+ * Sync files into Quox memory. client = the CLI http client; post/patch/get go to
+ * the memory service paths. Returns [{ file, key, name, action, id?, kinds?, error? }]
+ * where action is created | updated | unchanged | refused | missing | error | would-create | would-update.
+ */
+export async function syncMemoryFiles({ client, orgId = 'default', files, dryRun = false, statePath = statePathDefault(), memoryEp }) {
+  const state = loadState(statePath);
+  const mine = (state[orgId] ||= {});
+  let remote; // lazily loaded recovery index: source_key -> {id, hash}
+  const recover = async (key) => {
+    if (!remote) {
+      remote = {};
+      try {
+        const data = await client.get(memoryEp.path, { service: memoryEp.service, query: { limit: 1000 } });
+        for (const m of (data?.memories || [])) {
+          const sk = m?.metadata?.source_key;
+          if (sk) remote[sk] = { id: m.id, hash: m.metadata.content_hash };
+        }
+      } catch { /* recovery is best effort; worst case a first-time key creates */ }
+    }
+    return remote[key];
+  };
+
+  const results = [];
+  for (const entry of files) {
+    const { file } = entry;
+    const key = sourceKeyFor(file);
+    if (entry.missing) { results.push({ file, key, name: basename(file), action: 'missing' }); continue; }
+    let text;
+    try { text = readFileSync(file, 'utf8'); } catch (e) { results.push({ file, key, name: basename(file), action: 'error', error: e.message }); continue; }
+    const parsed = parseMemoryFile(text, basename(file, '.md'));
+    const kinds = secretKinds(text, { precise: true });
+    if (kinds.length) { results.push({ file, key, name: parsed.name, action: 'refused', rule: kinds[0], kinds }); continue; }
+    let content = [parsed.name, parsed.description].filter(Boolean).join(': ');
+    content = (content ? content + '\n\n' : '') + parsed.body;
+    content = content.slice(0, MAX_CONTENT);
+    const hash = createHash('sha256').update(content + '\0' + parsed.type).digest('hex');
+    const known = mine[key] || await recover(key);
+    if (known && known.hash === hash) { mine[key] = { id: known.id, hash }; results.push({ file, key, name: parsed.name, action: 'unchanged', id: known.id }); continue; }
+    const metadata = { source: 'claude-memory', source_key: key, content_hash: hash, source_file: basename(file), claude_type: parsed.type || null };
+    const tags = ['claude-memory', ...(parsed.type ? [`claude-memory:${parsed.type}`] : [])];
+    if (dryRun) { results.push({ file, key, name: parsed.name, action: known ? 'would-update' : 'would-create', id: known?.id }); continue; }
+    try {
+      let id = known?.id;
+      let action = 'created';
+      if (id) {
+        try {
+          await client.patch(`${memoryEp.path}/${id}`, { service: memoryEp.service, body: { content, tags, metadata } });
+          action = 'updated';
+        } catch (e) {
+          if (e?.status !== 404) throw e;
+          id = null; // the Quox memory was removed; make a fresh one
+        }
+      }
+      if (!id) {
+        const created = await client.post(memoryEp.path, { service: memoryEp.service, body: { type: quoxTypeFor(parsed.type), content, tags, metadata } });
+        id = created?.id || created?.memory?.id || null;
+      }
+      if (id) mine[key] = { id, hash };
+      results.push({ file, key, name: parsed.name, action, id });
+    } catch (e) {
+      results.push({ file, key, name: parsed.name, action: 'error', error: e?.message || String(e) });
+    }
+  }
+  if (!dryRun) { try { saveState(statePath, state); } catch { /* state is a cache; recovery covers it */ } }
+  return results;
+}

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';
@@ -262,147 +263,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 +312,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

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);