swarmdo 1.50.0 → 1.58.1

package/v3/@swarmdo/cli/dist/src/commands/agent.js

@@ -6,6 +6,7 @@ import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { wasmSubcommands } from './agent-wasm.js';
+import { classifyPrompt } from '../agent-bridge/bridge.js';
 import * as fs from 'fs';
 import * as path from 'path';
 /**
@@ -854,11 +855,142 @@ function formatLogLevel(level) {
             return `[${level.toUpperCase()}]`;
     }
 }
+// Bridge subcommand — link Claude Code Agent-tool agents into Swarmdo's registry
+const bridgeCommand = {
+    name: 'bridge',
+    description: "Link Claude Code Agent-tool agents into Swarmdo's registry so `swarmdo agent list` reflects the agents actually running (register/list/sync/advise). Registering auto-spins-up a swarm from config and enrolls the agent.",
+    options: [
+        { name: 'name', short: 'n', description: 'Claude Code agent name (register)', type: 'string' },
+        { name: 'session', short: 's', description: 'Claude Code session id (register)', type: 'string' },
+        { name: 'type', short: 't', description: 'agent type (register; default general-purpose)', type: 'string' },
+        { name: 'task', description: 'one-line task summary (register)', type: 'string' },
+        { name: 'live', description: 'comma-separated live Claude Code agent names (sync)', type: 'string' },
+        { name: 'prune', description: 'with sync: reap orphaned bound records (their Claude agent is gone)', type: 'boolean' },
+        { name: 'format', description: 'output format: text|json', type: 'string' },
+    ],
+    examples: [
+        { command: 'swarmdo agent bridge register -n research-ccgap -s cec69c3c -t general-purpose', description: 'Bind a running Claude Code agent into Swarmdo (auto-creates a swarm)' },
+        { command: 'swarmdo agent bridge list', description: 'Show Claude-Code-bound vs native Swarmdo agents' },
+        { command: 'swarmdo agent bridge sync --live research-ccgap,research-mcp', description: 'Reconcile the live roster against the store' },
+        { command: 'swarmdo agent bridge advise "Refactor the auth module across files"', description: 'Should this prompt spin up a swarm? Which roles?' },
+    ],
+    action: async (ctx) => {
+        const sub = (ctx.args[0] || 'list').toLowerCase();
+        const asJson = ctx.flags.format === 'json';
+        try {
+            switch (sub) {
+                case 'register': {
+                    const name = ctx.flags.name;
+                    if (!name) {
+                        output.printError('bridge register needs --name <claude-agent-name> (the running Claude Code agent)');
+                        return { success: false, exitCode: 1 };
+                    }
+                    const res = await callMCPTool('agent_bridge_register', {
+                        name,
+                        sessionId: ctx.flags.session,
+                        agentType: ctx.flags.type || 'general-purpose',
+                        task: ctx.flags.task,
+                    });
+                    if (asJson) {
+                        output.printJson(res);
+                        return { success: true, data: res };
+                    }
+                    output.printSuccess(`Bound Claude Code agent '${name}' → Swarmdo agent ${String(res.agentId)}`);
+                    const swarm = res.swarm;
+                    if (swarm) {
+                        output.writeln(`  swarm: ${swarm.swarmId} [${swarm.topology}] ${swarm.created ? '(created)' : '(joined existing)'}`);
+                    }
+                    return { success: true, data: res };
+                }
+                case 'list': {
+                    const res = await callMCPTool('agent_bridge_list', {});
+                    if (asJson) {
+                        output.printJson(res);
+                        return { success: true, data: res };
+                    }
+                    const bound = res.bound || [];
+                    const native = res.native || [];
+                    output.writeln();
+                    output.writeln(output.bold(`Swarmdo agents: ${res.total} (${res.boundCount} Claude-Code-bound, ${res.nativeCount} native)`));
+                    if (bound.length) {
+                        output.writeln();
+                        output.writeln(output.bold('Claude-Code-bound:'));
+                        for (const a of bound) {
+                            const b = a.binding || {};
+                            output.writeln(`  ${a.agentId}  [${a.agentType}]  ⇠ ${b.claudeName}${b.sessionId ? '@' + b.sessionId : ''}`);
+                        }
+                    }
+                    if (native.length) {
+                        output.writeln();
+                        output.writeln(output.bold('Native Swarmdo:'));
+                        for (const a of native)
+                            output.writeln(`  ${a.agentId}  [${a.agentType}]  ${a.status ?? ''}`);
+                    }
+                    if (Number(res.total) === 0) {
+                        output.printInfo('No agents registered. Spawn a Claude Code agent, then `swarmdo agent bridge register -n <name>`.');
+                    }
+                    return { success: true, data: res };
+                }
+                case 'sync': {
+                    const live = typeof ctx.flags.live === 'string'
+                        ? ctx.flags.live.split(',').map((s) => s.trim()).filter(Boolean)
+                        : [];
+                    const res = await callMCPTool('agent_bridge_list', { live });
+                    if (asJson) {
+                        output.printJson(res);
+                        return { success: true, data: res };
+                    }
+                    const rec = res.reconciliation || { mirrored: [], unmirrored: [], orphaned: [] };
+                    output.writeln();
+                    output.writeln(output.bold('Bridge reconciliation'));
+                    output.writeln(`  mirrored:   ${rec.mirrored.join(', ') || '(none)'}`);
+                    output.writeln(`  unmirrored: ${rec.unmirrored.join(', ') || '(none)'}${rec.unmirrored.length ? '  → run `agent bridge register -n <name>` for each' : ''}`);
+                    output.writeln(`  orphaned:   ${rec.orphaned.join(', ') || '(none)'}${rec.orphaned.length ? (ctx.flags.prune ? '' : '  → their Claude agent is gone (pass --prune to reap)') : ''}`);
+                    if (ctx.flags.prune) {
+                        const pruneRes = await callMCPTool('agent_bridge_prune', { live });
+                        const pruned = pruneRes.pruned || [];
+                        output.writeln();
+                        output.printSuccess(`Pruned ${pruned.length} orphaned bound record${pruned.length === 1 ? '' : 's'}${pruned.length ? ': ' + pruned.join(', ') : ''}`);
+                        return { success: true, data: { ...res, prune: pruneRes } };
+                    }
+                    return { success: true, data: res };
+                }
+                case 'advise': {
+                    const prompt = ctx.args.slice(1).join(' ').trim();
+                    const intent = classifyPrompt(prompt);
+                    if (asJson) {
+                        output.printJson(intent);
+                        return { success: true, data: intent };
+                    }
+                    if (!intent.requiresAgents) {
+                        output.printInfo(`No swarm needed: ${intent.reason}`);
+                    }
+                    else {
+                        output.writeln(output.bold(`Swarm recommended — ${intent.reason}`));
+                        output.writeln(`  roles: ${intent.suggestedRoles.join(', ')}`);
+                        output.writeln('  After spawning each Claude Code agent, bind it:');
+                        for (const role of intent.suggestedRoles) {
+                            output.writeln(`    swarmdo agent bridge register -n <name> -t ${role} -s <session>`);
+                        }
+                    }
+                    return { success: true, data: intent };
+                }
+                default:
+                    output.printError(`unknown bridge subcommand '${sub}' (use register|list|sync|advise)`);
+                    return { success: false, exitCode: 1 };
+            }
+        }
+        catch (e) {
+            output.printError(`bridge ${sub} failed: ${e instanceof MCPClientError ? e.message : String(e)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
 // Main agent command
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand, ...wasmSubcommands],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand, bridgeCommand, ...wasmSubcommands],
     options: [],
     examples: [
         { command: 'swarmdo agent spawn -t coder', description: 'Spawn a coder agent' },

package/v3/@swarmdo/cli/dist/src/commands/commands.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `swarmdo commands` (alias `slash`) — a hot/cold/orphan USAGE report for the
+ * project's authored `.claude/` slash-commands + subagents. `config lint` says
+ * "are these valid?"; this says "are these used?" by joining defined files
+ * against invocation counts mined from the local transcripts. #101.
+ *
+ *   swarmdo commands                # this project's authored surface
+ *   swarmdo commands --all          # count invocations across every project
+ *   swarmdo commands --unused       # only the cold (never-invoked) items
+ *   swarmdo commands --unused --strict   # exit 1 if anything is unused (CI gate)
+ *   swarmdo commands --json         # machine-readable
+ *
+ * Engine (../command-usage/usage.ts) is pure + fixture-tested; this thin layer
+ * renders and applies the --unused/--strict policy.
+ */
+import type { Command } from '../types.js';
+export declare const commandsCommand: Command;
+export default commandsCommand;
+//# sourceMappingURL=commands.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/commands.js

@@ -0,0 +1,107 @@
+/**
+ * `swarmdo commands` (alias `slash`) — a hot/cold/orphan USAGE report for the
+ * project's authored `.claude/` slash-commands + subagents. `config lint` says
+ * "are these valid?"; this says "are these used?" by joining defined files
+ * against invocation counts mined from the local transcripts. #101.
+ *
+ *   swarmdo commands                # this project's authored surface
+ *   swarmdo commands --all          # count invocations across every project
+ *   swarmdo commands --unused       # only the cold (never-invoked) items
+ *   swarmdo commands --unused --strict   # exit 1 if anything is unused (CI gate)
+ *   swarmdo commands --json         # machine-readable
+ *
+ * Engine (../command-usage/usage.ts) is pure + fixture-tested; this thin layer
+ * renders and applies the --unused/--strict policy.
+ */
+import { output } from '../output.js';
+import { collectCommandUsage } from '../command-usage/usage.js';
+/** Render one domain's hot/cold/orphan buckets. `slash` prefixes command names. */
+function renderBuckets(label, defined, b, slash) {
+    const nm = (n) => (slash ? `/${n}` : n);
+    output.writeln('');
+    output.writeln(output.bold(`${label}`) + output.dim(`  (${defined} defined · ${b.hot.length} hot · ${b.cold.length} cold · ${b.orphan.length} orphan)`));
+    if (b.hot.length > 0) {
+        output.printTable({
+            columns: [
+                { key: 'name', header: 'Hot (used)', width: 34 },
+                { key: 'count', header: 'Invocations', width: 12, align: 'right' },
+            ],
+            data: b.hot.map((h) => ({ name: nm(h.name), count: h.count.toLocaleString('en-US') })),
+        });
+    }
+    if (b.cold.length > 0) {
+        output.writeln(output.warning(`  cold (never invoked — prune candidates): `) + b.cold.map(nm).join('  '));
+    }
+    if (b.orphan.length > 0) {
+        output.writeln(output.dim(`  orphan (invoked, not defined — builtin or typo): `) + b.orphan.map(nm).join('  '));
+    }
+    if (b.hot.length === 0 && b.cold.length === 0 && b.orphan.length === 0) {
+        output.writeln(output.dim('  (none)'));
+    }
+}
+/** Print only the cold (unused) items — the prune list. Returns the cold count. */
+function renderUnused(report) {
+    const coldCmds = report.commands.cold;
+    const coldAgents = report.agents.cold;
+    const total = coldCmds.length + coldAgents.length;
+    output.writeln(output.bold('Unused (cold) authored items') + output.dim(`  (${report.scope} scope · ${report.filesScanned} transcript files)`));
+    if (total === 0) {
+        output.writeln(output.info('  none — every authored command and agent has been invoked 🎉'));
+        return 0;
+    }
+    if (coldCmds.length > 0)
+        output.writeln(`  commands: ${coldCmds.map((c) => `/${c}`).join('  ')}`);
+    if (coldAgents.length > 0)
+        output.writeln(`  agents:   ${coldAgents.join('  ')}`);
+    return total;
+}
+async function run(ctx) {
+    const cwd = ctx.cwd || process.cwd();
+    const all = ctx.flags.all === true;
+    const report = collectCommandUsage({ cwd, all });
+    if (ctx.flags.json === true) {
+        output.writeln(JSON.stringify(report, null, 2));
+        return { success: true, exitCode: 0 };
+    }
+    if (report.definedCommands === 0 && report.definedAgents === 0) {
+        output.writeln(output.info('nothing authored — no .claude/commands or .claude/agents in this project'));
+        return { success: true, exitCode: 0 };
+    }
+    if (ctx.flags.unused === true) {
+        const coldCount = renderUnused(report);
+        const strict = ctx.flags.strict === true;
+        const exitCode = strict && coldCount > 0 ? 1 : 0;
+        if (exitCode === 1)
+            output.writeln(output.dim(`exit 1 (--strict + ${coldCount} unused)`));
+        return { success: exitCode === 0, exitCode };
+    }
+    output.writeln(output.bold('Authored .claude/ surface — usage') + output.dim(`  (${report.scope} scope · ${report.filesScanned} transcript files)`));
+    renderBuckets('Commands', report.definedCommands, report.commands, true);
+    renderBuckets('Agents', report.definedAgents, report.agents, false);
+    const totalCold = report.commands.cold.length + report.agents.cold.length;
+    if (totalCold > 0) {
+        output.writeln('');
+        output.writeln(output.dim(`${totalCold} unused — see \`swarmdo commands --unused\` (add --strict for a CI gate)`));
+    }
+    return { success: true, exitCode: 0 };
+}
+export const commandsCommand = {
+    name: 'commands',
+    aliases: ['slash'],
+    description: "Usage report (hot/cold/orphan) for the project's authored .claude/ slash-commands & subagents",
+    options: [
+        { name: 'all', description: 'count invocations across every project (default: current project only)', type: 'boolean', default: false },
+        { name: 'unused', description: 'print only the cold (never-invoked) items — the prune list', type: 'boolean', default: false },
+        { name: 'strict', description: 'with --unused, exit 1 if anything is unused (CI gate)', type: 'boolean', default: false },
+        { name: 'json', description: 'machine-readable output', type: 'boolean', default: false },
+    ],
+    examples: [
+        { command: 'swarmdo commands', description: 'Hot/cold/orphan report for your authored .claude/ surface' },
+        { command: 'swarmdo commands --unused', description: 'List slash-commands & agents you defined but never invoke' },
+        { command: 'swarmdo commands --unused --strict', description: 'CI gate: fail if any authored command/agent is unused' },
+        { command: 'swarmdo slash --all --json', description: 'Cross-project invocation counts as JSON (alias)' },
+    ],
+    action: run,
+};
+export default commandsCommand;
+//# sourceMappingURL=commands.js.map

package/v3/@swarmdo/cli/dist/src/commands/index.js

@@ -60,6 +60,14 @@ const commandLoaders = {
     // Hidden coupling — co-change pairs with NO import edge (logical minus
     // structural coupling); joins `coupling`'s git capture with codegraph's graph.
     'hidden-coupling': () => import('./hidden-coupling.js'),
+    // Weekend-aware "what did I do?" recall from git history (git-standup demand)
+    // — commits since your last working day, grouped by day with a diffstat.
+    standup: () => import('./standup.js'),
+    mine: () => import('./standup.js'), // alias via loader key
+    // Hot/cold/orphan USAGE report for authored .claude/ slash-commands + subagents
+    // — the "dead-code report" for the authoring surface (config lint validates it).
+    commands: () => import('./commands.js'),
+    slash: () => import('./commands.js'), // alias via loader key
     // JUnit/TAP test-result parser (dorny/test-reporter demand) — raw results →
     // failing test + file:line + message; the front-half of the test→fix loop.
     testreport: () => import('./testreport.js'),
@@ -302,7 +310,7 @@ export async function getCommandsByCategory() {
     // three slots from 'statusline' onward (completionsCmd received the
     // statusline module, analyzeCmd received completions, …), scrambling the
     // categorized help. Every load now has a named slot.
-    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, couplingCmd, ownershipCmd, hiddenCouplingCmd, testreportCmd, compactSnapshotCmd,] = await Promise.all([
+    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, couplingCmd, ownershipCmd, hiddenCouplingCmd, testreportCmd, compactSnapshotCmd, standupCmd, commandsUsageCmd,] = await Promise.all([
         loadCommand('daemon'), loadCommand('doctor'), loadCommand('embeddings'), loadCommand('neural'),
         loadCommand('performance'), loadCommand('security'), loadCommand('swarmvector'), loadCommand('hive-mind'),
         loadCommand('config'), loadCommand('statusline'), loadCommand('compress'), loadCommand('efficiency'),
@@ -310,7 +318,7 @@ export async function getCommandsByCategory() {
         loadCommand('analyze'), loadCommand('route'), loadCommand('progress'), loadCommand('providers'),
         loadCommand('plugins'), loadCommand('deployment'), loadCommand('claims'), loadCommand('issues'),
         loadCommand('update'), loadCommand('process'), loadCommand('guidance'), loadCommand('appliance'),
-        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'), loadCommand('coupling'), loadCommand('ownership'), loadCommand('hidden-coupling'), loadCommand('testreport'), loadCommand('compact-snapshot'),
+        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'), loadCommand('coupling'), loadCommand('ownership'), loadCommand('hidden-coupling'), loadCommand('testreport'), loadCommand('compact-snapshot'), loadCommand('standup'), loadCommand('commands'),
     ]);
     return {
         primary: [
@@ -329,7 +337,7 @@ export async function getCommandsByCategory() {
             statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, couplingCmd, ownershipCmd, hiddenCouplingCmd, testreportCmd, compactSnapshotCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
-            analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd,
+            analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd, standupCmd, commandsUsageCmd,
         ].filter(Boolean),
         management: [
             providersCmd, pluginsCmd, deploymentCmd, claimsCmd,

package/v3/@swarmdo/cli/dist/src/commands/standup.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `swarmdo standup` — recall what you committed since your last working day.
+ *
+ *   swarmdo standup                   # your commits since the last working day
+ *   swarmdo standup --all             # everyone's commits
+ *   swarmdo standup --author "Ada"    # a specific author (or: swarmdo standup Ada)
+ *   swarmdo standup --days 7          # explicit N-day window
+ *   swarmdo standup --since 2w        # explicit window (git approxidate)
+ *   swarmdo standup --format json     # machine-readable
+ *
+ * Weekend-aware (git-standup parity): on Monday it reaches back to Friday, on
+ * Sunday to Friday, otherwise to yesterday. Engine (../standup/standup.ts) is
+ * pure + tested; this thin layer captures the git log and renders.
+ */
+import type { Command } from '../types.js';
+export declare const standupCommand: Command;
+export default standupCommand;
+//# sourceMappingURL=standup.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/standup.js

@@ -0,0 +1,116 @@
+/**
+ * `swarmdo standup` — recall what you committed since your last working day.
+ *
+ *   swarmdo standup                   # your commits since the last working day
+ *   swarmdo standup --all             # everyone's commits
+ *   swarmdo standup --author "Ada"    # a specific author (or: swarmdo standup Ada)
+ *   swarmdo standup --days 7          # explicit N-day window
+ *   swarmdo standup --since 2w        # explicit window (git approxidate)
+ *   swarmdo standup --format json     # machine-readable
+ *
+ * Weekend-aware (git-standup parity): on Monday it reaches back to Friday, on
+ * Sunday to Friday, otherwise to yesterday. Engine (../standup/standup.ts) is
+ * pure + tested; this thin layer captures the git log and renders.
+ */
+import { execFileSync } from 'node:child_process';
+import { output } from '../output.js';
+import { parseStandupLog, groupByDay, sinceLastWorkingDay, formatStandup } from '../standup/standup.js';
+import { normalizeSince } from '../util/since.js';
+/** Read a non-negative numeric flag the parser may deliver as number OR string. */
+function numFlag(v) {
+    const n = typeof v === 'number' ? v : typeof v === 'string' ? parseInt(v, 10) : NaN;
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+/** Resolve the default author (git config user.name); '' if unset/unavailable. */
+function gitUserName(root) {
+    try {
+        return execFileSync('git', ['config', 'user.name'], {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+async function run(ctx) {
+    const root = ctx.cwd || process.cwd();
+    const asJson = ctx.flags.format === 'json';
+    const all = ctx.flags.all === true;
+    // Author: explicit --author, else positional arg, else current git user
+    // (unless --all, which clears the filter to show everyone).
+    const authorFlag = typeof ctx.flags.author === 'string' ? ctx.flags.author : ctx.args[0];
+    let author = '';
+    if (!all)
+        author = ((authorFlag && authorFlag.trim()) || gitUserName(root)).trim();
+    // Window resolution (priority): --since (approxidate passthrough) >
+    // --days N > the weekend-aware default.
+    const now = new Date();
+    const sinceExpr = typeof ctx.flags.since === 'string' ? ctx.flags.since.trim() : '';
+    const daysFlag = numFlag(ctx.flags.days);
+    let sinceArg;
+    let windowLabel;
+    if (sinceExpr) {
+        sinceArg = normalizeSince(sinceExpr);
+        windowLabel = sinceExpr;
+    }
+    else {
+        const days = daysFlag ?? sinceLastWorkingDay(now).sinceDays;
+        // Cutoff = LOCAL midnight `days` ago, so the WHOLE last working day is
+        // included (a plain "3 days ago" would start mid-morning and miss commits).
+        const cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate() - days);
+        sinceArg = cutoff.toISOString();
+        windowLabel = days === 1 ? 'since yesterday' : `since ${days} days ago`;
+    }
+    const args = ['log', '--numstat', `--since=${sinceArg}`, '--format=format:%x01%H%x1f%aN%x1f%aI%x1f%s'];
+    if (author)
+        args.push(`--author=${author}`);
+    let raw;
+    try {
+        raw = execFileSync('git', args, {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            maxBuffer: 128 * 1024 * 1024,
+        });
+    }
+    catch {
+        output.printError('git log failed — is this a git repository?');
+        return { success: false, exitCode: 1 };
+    }
+    const buckets = groupByDay(parseStandupLog(raw));
+    if (asJson) {
+        const count = buckets.reduce((n, b) => n + b.commits.length, 0);
+        process.stdout.write(JSON.stringify({ generated: now.toISOString(), author: all ? null : author || null, since: sinceArg, count, buckets }, null, 2) + '\n');
+    }
+    else {
+        const who = all ? 'everyone' : author || 'you';
+        if (buckets.length === 0) {
+            output.writeln(output.dim(`no commits for ${who} ${windowLabel} — nothing to report`));
+        }
+        else {
+            output.writeln(output.bold(`Standup for ${who} (${windowLabel})`));
+            output.writeln(formatStandup(buckets));
+        }
+    }
+    return { success: true, exitCode: 0 };
+}
+export const standupCommand = {
+    name: 'standup',
+    description: 'Recall what you committed since your last working day (weekend-aware: Monday reaches back to Friday) — git-standup parity',
+    options: [
+        { name: 'all', description: 'show commits from all authors (not just you)', type: 'boolean' },
+        { name: 'author', description: 'filter to a specific author (default: git config user.name)', type: 'string' },
+        { name: 'days', description: 'explicit N-day window (overrides the weekend-aware default)', type: 'string' },
+        { name: 'since', description: 'explicit window, e.g. 2w or "last monday" (git approxidate)', type: 'string' },
+    ],
+    examples: [
+        { command: 'swarmdo standup', description: 'Your commits since the last working day' },
+        { command: 'swarmdo standup --all --since 1w', description: "Everyone's commits in the last week" },
+        { command: 'swarmdo standup --format json', description: 'Machine-readable per-day buckets' },
+    ],
+    action: run,
+};
+export default standupCommand;
+//# sourceMappingURL=standup.js.map

package/v3/@swarmdo/cli/dist/src/commands/swarm.js

@@ -103,6 +103,35 @@ function getSwarmStatus(swarmId) {
             // Ignore
         }
     }
+    // Canonical-store fallback: the `.swarm/*` paths above are the pre-#2085
+    // layout. The real swarm store written by swarm_init / agent_spawn / the
+    // agent bridge lives at `.swarmdo/swarm/swarm-state.json`. When the legacy
+    // paths are empty, read the canonical store so `swarm status` reflects a
+    // bridge-created (or MCP-created) swarm instead of falsely reporting "none".
+    if (!swarmState) {
+        try {
+            const swFile = path.join(process.cwd(), '.swarmdo', 'swarm', 'swarm-state.json');
+            if (fs.existsSync(swFile)) {
+                const swStore = JSON.parse(fs.readFileSync(swFile, 'utf-8'));
+                const running = Object.values(swStore.swarms || {})
+                    .filter((s) => s.status === 'running')
+                    .sort((a, b) => new Date(String(b.createdAt)).getTime() - new Date(String(a.createdAt)).getTime())[0];
+                if (running) {
+                    const cfg = running.config || {};
+                    swarmState = {
+                        id: running.swarmId,
+                        topology: running.topology,
+                        strategy: cfg.strategy || 'specialized',
+                    };
+                    const enrolled = Array.isArray(running.agents) ? running.agents.length : 0;
+                    totalAgents = Math.max(totalAgents, enrolled);
+                }
+            }
+        }
+        catch {
+            // Canonical store unavailable — keep the legacy view.
+        }
+    }
     // Calculate dynamic progress based on actual state
     // If no swarm state, show 0%. Otherwise calculate from completed tasks
     const totalTasks = completedTasks + inProgressTasks + pendingTasks;

package/v3/@swarmdo/cli/dist/src/commands/usage.js

@@ -15,6 +15,7 @@
 import { output } from '../output.js';
 import { aggregateBlocks, aggregateUsage, collectUsage, totalUsage, localDateKey, } from '../usage/transcript-usage.js';
 import { collectToolErrors, delegationFromReport } from '../usage/transcript-errors.js';
+import { collectFriction } from '../usage/transcript-friction.js';
 import { computeCacheStats } from '../usage/cache-stats.js';
 import { evaluateGuard } from '../usage/spend-guard.js';
 import { resolvePeriodPair, parseRange, diffPeriods, modelMovers } from '../usage/diff.js';
@@ -201,6 +202,53 @@ function runErrorsView(ctx, report) {
     }
     return { success: true, exitCode: 0 };
 }
+/** Friction view — how often you interrupt Claude (ESC mid-turn), which tool was
+ * running when you did, and what KIND of errors dominate. The sniffly axes that
+ * `usage errors` (error rate) left on the table (#102). */
+function runFrictionView(ctx, report) {
+    if (ctx.flags.json === true) {
+        output.writeln(JSON.stringify(report, null, 2));
+        return { success: true, exitCode: 0 };
+    }
+    const pct = (v) => `${(v * 100).toFixed(1)}%`;
+    if (ctx.flags.csv === true) {
+        // Category table export (parity with `usage --csv`).
+        const headers = ['category', 'count', 'share'];
+        const rows = report.categories.map((c) => [c.category, c.count, c.share.toFixed(4)]);
+        output.writeln(toCsv(headers, rows));
+        return { success: true, exitCode: 0 };
+    }
+    output.writeln(output.bold('Claude Code usage — friction'));
+    if (report.interruptions === 0 && report.totalErrors === 0) {
+        output.writeln(output.info(`no friction detected in ${report.filesScanned} transcript files`));
+        return { success: true, exitCode: 0 };
+    }
+    output.writeln(output.dim(`${report.filesScanned} files · ${fmtInt(report.interruptions)} interruption${report.interruptions === 1 ? '' : 's'} across ${fmtInt(report.assistantTurns)} assistant turns (${pct(report.interruptionRate)})`));
+    if (report.byTool.length > 0) {
+        output.writeln('');
+        output.writeln(output.bold('Interrupted while running'));
+        output.printTable({
+            columns: [
+                { key: 'tool', header: 'Tool / context', width: 22 },
+                { key: 'count', header: 'Interrupts', width: 12, align: 'right' },
+            ],
+            data: report.byTool.slice(0, 15).map((t) => ({ tool: t.tool, count: fmtInt(t.interruptions) })),
+        });
+    }
+    if (report.categories.length > 0) {
+        output.writeln('');
+        output.writeln(output.bold('Error categories') + output.dim(`  (${fmtInt(report.totalErrors)} tool errors)`));
+        output.printTable({
+            columns: [
+                { key: 'category', header: 'Category', width: 14 },
+                { key: 'count', header: 'Count', width: 10, align: 'right' },
+                { key: 'share', header: 'Share', width: 8, align: 'right' },
+            ],
+            data: report.categories.map((c) => ({ category: c.category, count: fmtInt(c.count), share: pct(c.share) })),
+        });
+    }
+    return { success: true, exitCode: 0 };
+}
 /** Cache view — prompt-cache efficiency + $ saved by caching (the #1 cost lever). */
 function runCacheView(ctx, collection) {
     const stats = computeCacheStats(aggregateUsage(collection.events, 'model'));
@@ -547,6 +595,13 @@ async function run(ctx) {
         const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
         return runErrorsView(ctx, collectToolErrors({ dirs, since, until }));
     }
+    if (viewName === 'friction') {
+        const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
+        const until = typeof ctx.flags.until === 'string' ? ctx.flags.until : undefined;
+        const dirFlag = ctx.flags.dir;
+        const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
+        return runFrictionView(ctx, collectFriction({ dirs, since, until }));
+    }
     if (viewName === 'cache') {
         const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
         const until = typeof ctx.flags.until === 'string' ? ctx.flags.until : undefined;
@@ -574,7 +629,7 @@ async function run(ctx) {
     }
     const view = VIEWS[viewName];
     if (!view) {
-        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|cache|guard|diff|reflect|limits)`));
+        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|friction|cache|guard|diff|reflect|limits)`));
         return { success: false, exitCode: 1 };
     }
     const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
@@ -667,6 +722,7 @@ export const usageCommand = {
         { command: 'swarmdo usage projects --json', description: 'Per-project totals as JSON' },
         { command: 'swarmdo usage monthly --csv > usage.csv', description: 'Export monthly spend to CSV' },
         { command: 'swarmdo cost sessions --limit 10', description: 'Ten most expensive sessions (alias)' },
+        { command: 'swarmdo usage friction', description: 'How often you interrupt Claude + which error kinds dominate' },
     ],
     action: run,
 };

package/v3/@swarmdo/cli/dist/src/comms/store.d.ts

@@ -14,7 +14,17 @@ export declare const RETENTION: {
 export declare function storePath(cwd: string): string;
 export declare function loadMailbox(cwd: string): Mailbox;
 export declare function saveMailbox(cwd: string, box: Mailbox): void;
-/** This session's name: explicit override → SWARMDO_SESSION → hostname → "me". */
+/**
+ * This session's name, in precedence order:
+ *   explicit override (flag/param)
+ *   → $SWARMDO_SESSION   (set by Claude Code)
+ *   → $SWARMDO_AGENT     (harness-neutral — Codex/Copilot/pi agents export this)
+ *   → hostname → "me".
+ *
+ * The $SWARMDO_AGENT fallback lets a non-Claude agent declare a stable identity
+ * once (instead of passing `from`/`--self` on every call); without it, every
+ * agent on a host collapses to the shared hostname and direct addressing breaks.
+ */
 export declare function resolveSelf(flag?: unknown): string;
 /** Crypto-strong message id. */
 export declare function newMessageId(): string;

package/v3/@swarmdo/cli/dist/src/comms/store.js

@@ -32,10 +32,24 @@ export function saveMailbox(cwd, box) {
     mkdirSync(dirname(p), { recursive: true });
     writeFileSync(p, JSON.stringify(box, null, 2) + '\n', 'utf-8');
 }
-/** This session's name: explicit override → SWARMDO_SESSION → hostname → "me". */
+/**
+ * This session's name, in precedence order:
+ *   explicit override (flag/param)
+ *   → $SWARMDO_SESSION   (set by Claude Code)
+ *   → $SWARMDO_AGENT     (harness-neutral — Codex/Copilot/pi agents export this)
+ *   → hostname → "me".
+ *
+ * The $SWARMDO_AGENT fallback lets a non-Claude agent declare a stable identity
+ * once (instead of passing `from`/`--self` on every call); without it, every
+ * agent on a host collapses to the shared hostname and direct addressing breaks.
+ */
 export function resolveSelf(flag) {
     const f = typeof flag === 'string' ? flag.trim() : '';
-    return f || (process.env.SWARMDO_SESSION || '').trim() || hostname() || 'me';
+    return (f ||
+        (process.env.SWARMDO_SESSION || '').trim() ||
+        (process.env.SWARMDO_AGENT || '').trim() ||
+        hostname() ||
+        'me');
 }
 /** Crypto-strong message id. */
 export function newMessageId() {