c8ctl-plugin-nano 1.43.1 → 1.44.0

package/README.md

@@ -900,9 +900,10 @@ c8ctl nano workforce stop                 # remove this manifest's workers (+ st
 c8ctl nano workforce remove qwen          # drop an entry ("all" clears the manifest)
 ```
 
-Every subcommand takes `--profile <name>` (default `default`) to select which
-manifest it operates on, so you can keep several — `--profile review-only`,
-`--profile full-fleet` — side by side.
+Every subcommand takes `--manifest <name>` (default `default`) to select which
+manifest it operates on, so you can keep several — `--manifest review-only`,
+`--manifest full-fleet` — side by side. (This flag was renamed from `--profile`,
+which now collides with c8ctl's global connection-profile flag.)
 
 ### The manifest
 
@@ -991,8 +992,9 @@ hired with `--capabilities ""`.
 - `start` with an empty/absent manifest → a friendly pointer at `workforce add`,
   exit 0.
 
-`--json` on `list`/`status` emits machine-readable output (through the same
-output-mode-aware logger) so the install script and CI can consume it.
+`--json` on `list`/`status` emits machine-readable output (via c8ctl's global
+`--json` flag, whose parsed value is passed through to the handler) so the
+install script and CI can consume it.
 
 ## Cleaning up disk
 

package/c8ctl-plugin.js

@@ -2588,13 +2588,64 @@ function resolveAutoRestConfig(camunda, env = process.env) {
 // dot-grammar.
 // ---------------------------------------------------------------------------
 
+// Legacy (pre-nano-workforce#203) agent-task marker: a service task carried the
+// agent's prompt in an `io.nanobpm.agentTask.*` `<zeebe:header>` rather than a
+// `linkName="prompt"` linked resource. The current package detector
+// (`scanTaskDefinitions`, whose `agentic` flag keys SOLELY off the linked-prompt
+// side-car) therefore reports `agentic:false` for such tasks. We keep a narrow,
+// self-contained fallback so `--auto` still discovers agent job types against an
+// engine still holding a pre-#203 deployment (issue #120 acceptance criterion:
+// "Legacy header-based BPMN still discovers correctly"). This is a supplement to
+// — never a replacement for — the package flag: the authoritative task-type /
+// process derivation still comes from `scanTaskDefinitions`; this only answers
+// "is this leaf an agent task?" for the legacy shape.
+//
+// True when `body` (a service task's inner XML) declares any
+// `io.nanobpm.agentTask*` `<zeebe:header>` key — the sole such header on a
+// pre-#203 agent service task. The regex is compiled once (it is called once
+// per matched `<serviceTask>` during `--auto` scans, so recompiling per call
+// would allocate needlessly across many deployed definitions).
+const AGENT_TASK_HEADER_RE = new RegExp(
+  `<(?:\\w+:)?header\\b[^>]*\\bkey\\s*=\\s*(["'])${AGENT_TASK_NS.replace(/[.]/g, '\\.')}(?:\\.[^"']*)?\\1`,
+  'i'
+);
+function serviceTaskHasAgentHeader(body) {
+  return AGENT_TASK_HEADER_RE.test(String(body || ''));
+}
+
+// The set of service-task element ids in `xml` bearing the legacy agent-task
+// header. Correlates back to `scanTaskDefinitions` leaves by `elementId`, so a
+// leaf is treated as legacy-agentic only when it ALSO has a `taskDefinition type`
+// (the package only yields leaves that do) — matching the issue rule "prompt link
+// OR legacy header, AND a non-empty task type".
+function legacyAgentHeaderElementIds(xml) {
+  const ids = new Set();
+  const src = String(xml || '');
+  // Cheap guard: a legacy agent-task header always contains the literal
+  // `io.nanobpm.agentTask` namespace, so a document lacking that substring
+  // cannot match — skip the full `<serviceTask>` walk entirely. This avoids
+  // parsing every deployed definition in `--auto` enrolment loops when none
+  // carry the legacy marker.
+  if (!src.includes(AGENT_TASK_NS)) return ids;
+  const taskRe =
+    /<(?:\w+:)?serviceTask\b[^>]*?\bid\s*=\s*(["'])(.*?)\1[^>]*?>([\s\S]*?)<\/(?:\w+:)?serviceTask>/g;
+  let m;
+  while ((m = taskRe.exec(src)) !== null) {
+    if (serviceTaskHasAgentHeader(m[3])) ids.add(m[2]);
+  }
+  return ids;
+}
+
 // Scan one deployed BPMN document for its *agent* task-definition leaves: the
 // subset of `@nanobpm/agentic` `demand.scanTaskDefinitions(xml)` leaves whose
 // canonical `agentic` flag is set (i.e. the service task declares a
-// `linkName="prompt"` linked resource). Returns `{ taskType, process }` leaves in
-// first-occurrence order. The published `scanTaskDefinitions` is INJECTED so this
-// stays a pure, synchronous function; `readDeployedAgentJobTypes` supplies the
-// real one from the lazily-imported demand surface (`agentic.mjs`).
+// `linkName="prompt"` linked resource) OR — for backward compatibility with
+// pre-#203 deployments — which carry the legacy `io.nanobpm.agentTask` header.
+// Returns `{ taskType, process }` leaves in first-occurrence order; a task
+// matched by both signals is the same leaf, so it is emitted once. The published
+// `scanTaskDefinitions` is INJECTED so this stays a pure, synchronous function;
+// `readDeployedAgentJobTypes` supplies the real one from the lazily-imported
+// demand surface (`agentic.mjs`).
 function scanAgentTaskLeaves(xml, scanTaskDefinitions) {
   if (typeof scanTaskDefinitions !== 'function') {
     throw new TypeError(
@@ -2602,8 +2653,10 @@ function scanAgentTaskLeaves(xml, scanTaskDefinitions) {
         `(got ${typeof scanTaskDefinitions}); pass demand.scanTaskDefinitions from ./agentic.mjs`
     );
   }
-  return scanTaskDefinitions(String(xml || ''))
-    .filter((leaf) => leaf.agentic)
+  const src = String(xml || '');
+  const legacyIds = legacyAgentHeaderElementIds(src);
+  return scanTaskDefinitions(src)
+    .filter((leaf) => leaf.agentic || legacyIds.has(leaf.elementId))
     .map((leaf) => ({ taskType: leaf.taskType, process: leaf.process }));
 }
 
@@ -8709,7 +8762,7 @@ function formatWorkforceStatus(report) {
   const missing = entries.filter((e) => e.running < e.desired);
   if (missing.length > 0) {
     lines.push('');
-    lines.push(`  Missing: ${missing.map((e) => `${e.profile} (${e.running}/${e.desired})`).join(', ')} — run: c8ctl nano workforce start${report.name === DEFAULT_WORKFORCE_MANIFEST ? '' : ` --profile ${report.name}`}`);
+    lines.push(`  Missing: ${missing.map((e) => `${e.profile} (${e.running}/${e.desired})`).join(', ')} — run: c8ctl nano workforce start${report.name === DEFAULT_WORKFORCE_MANIFEST ? '' : ` --manifest ${report.name}`}`);
   }
   if (Array.isArray(report.extra) && report.extra.length > 0) {
     lines.push('');
@@ -8718,16 +8771,16 @@ function formatWorkforceStatus(report) {
   return lines.join('\n');
 }
 
-/** Resolve the manifest name from `--profile` (default `default`). Pure. */
-function lastProfileValue(flags) {
-  // A repeated `--profile` flag arrives as a string[]; honor the last value.
-  let profile = flags?.profile;
-  if (Array.isArray(profile)) profile = profile.length ? profile[profile.length - 1] : '';
-  return typeof profile === 'string' ? profile.trim() : '';
+/** Resolve the manifest name from `--manifest` (default `default`). Pure. */
+function lastManifestValue(flags) {
+  // A repeated `--manifest` flag arrives as a string[]; honor the last value.
+  let manifest = flags?.manifest;
+  if (Array.isArray(manifest)) manifest = manifest.length ? manifest[manifest.length - 1] : '';
+  return typeof manifest === 'string' ? manifest.trim() : '';
 }
 
 function workforceManifestName(flags) {
-  return lastProfileValue(flags) || DEFAULT_WORKFORCE_MANIFEST;
+  return lastManifestValue(flags) || DEFAULT_WORKFORCE_MANIFEST;
 }
 
 /** Fetch the live supervisor worker set, or `[]` when no daemon is running. */
@@ -8745,7 +8798,7 @@ async function workforceAddCmd(req, flags, manifestName) {
   const logger = getLogger();
   const profile = req.positional[1];
   if (!profile) {
-    logger.error('Usage: c8ctl nano workforce add <profile> [--instances <n>] [--auto [--auto-scope <s>] | --roles a,b,c] [--arg <flag> ...] [--profile <manifest>]');
+    logger.error('Usage: c8ctl nano workforce add <profile> [--instances <n>] [--auto [--auto-scope <s>] | --roles a,b,c] [--arg <flag> ...] [--manifest <manifest>]');
     process.exit(1);
   }
   if (!isValidProfileName(profile)) {
@@ -8819,14 +8872,14 @@ async function workforceAddCmd(req, flags, manifestName) {
   manifest = upsertManifestEntry(manifest, entry);
   writeWorkforceManifest(manifest);
   logger.info(`${existed ? 'Updated' : 'Added'} "${profile}" in workforce "${manifestName}": instances ${count}, roles ${describeEntryRoles(entry)}${extraArgs.length ? `, args ${redactWorkArgs(extraArgs).join(' ')}` : ''}.`);
-  logger.info(`Bring it up with: c8ctl nano workforce start${manifestName === DEFAULT_WORKFORCE_MANIFEST ? '' : ` --profile ${manifestName}`}`);
+  logger.info(`Bring it up with: c8ctl nano workforce start${manifestName === DEFAULT_WORKFORCE_MANIFEST ? '' : ` --manifest ${manifestName}`}`);
 }
 
 async function workforceRemoveCmd(req, flags, manifestName) {
   const logger = getLogger();
   const profile = req.positional[1];
   if (!profile) {
-    logger.error('Usage: c8ctl nano workforce remove <profile|all> [--profile <manifest>]');
+    logger.error('Usage: c8ctl nano workforce remove <profile|all> [--manifest <manifest>]');
     process.exit(1);
   }
   const manifest = readWorkforceManifestStrict(manifestName);
@@ -8841,9 +8894,9 @@ async function workforceRemoveCmd(req, flags, manifestName) {
 async function workforceListCmd(req, flags, manifestName) {
   const logger = getLogger();
   const json = coerceBool(flags?.json, false);
-  const explicitProfile = lastProfileValue(flags) !== '';
+  const explicitManifest = lastManifestValue(flags) !== '';
   const manifest = readWorkforceManifestStrict(manifestName);
-  const others = explicitProfile ? null : listWorkforceManifestNames();
+  const others = explicitManifest ? null : listWorkforceManifestNames();
   if (json) {
     const payload = { manifest: manifest || null };
     if (others) payload.manifests = others;
@@ -9042,15 +9095,15 @@ async function workforceStopCmd(req, flags, manifestName) {
 async function workforceCommand(req, flags) {
   const logger = getLogger();
   const action = (req.positional[0] || '').toLowerCase();
-  // A bare `--profile` (no value) is parsed as boolean `true`; reject it so we
+  // A bare `--manifest` (no value) is parsed as boolean `true`; reject it so we
   // fail fast instead of silently operating on the default manifest.
-  if (flags?.profile === true) {
-    logger.error('--profile requires a manifest name.');
+  if (flags?.manifest === true) {
+    logger.error('--manifest requires a manifest name.');
     process.exit(1);
   }
   const manifestName = workforceManifestName(flags);
   if (!isValidManifestName(manifestName)) {
-    logger.error(`Invalid --profile "${manifestName}". Use letters, digits, dot, dash or underscore.`);
+    logger.error(`Invalid --manifest "${manifestName}". Use letters, digits, dot, dash or underscore.`);
     process.exit(1);
   }
   switch (action) {
@@ -10820,6 +10873,7 @@ export {
   diffJobTypes,
   parseJobTypeFlags,
   scanAgentTaskLeaves,
+  serviceTaskHasAgentHeader,
   readDeployedAgentJobTypes,
   resolveAutoJobTypes,
   workAgent,
@@ -10903,7 +10957,7 @@ export {
   buildWorkforceStatus,
   formatWorkforceStatus,
   workforceManifestName,
-  lastProfileValue,
+  lastManifestValue,
 };
 
 export const metadata = {
@@ -10961,7 +11015,7 @@ export const metadata = {
         { command: 'c8ctl nano workforce add copilot --instances 5 --auto', description: 'Compose a reusable fleet: 5 copilot workers serving every deployed agent job type (--auto)' },
         { command: 'c8ctl nano workforce add qwen --instances 2 --roles pr-review,feature', description: "Add an entry mapped to explicit job types (<rank>:pr-review, <rank>:feature, where <rank> is the qwen hire's rank at start) — does not mutate the hired profile" },
         { command: 'c8ctl nano workforce start', description: "Ensure the daemon is up, then reconcile running workers to the 'default' manifest (idempotent — a second run changes nothing)" },
-        { command: 'c8ctl nano workforce start --profile review-only', description: 'Bring up a named manifest (<stateHome>/workforce/review-only.json)' },
+        { command: 'c8ctl nano workforce start --manifest review-only', description: 'Bring up a named manifest (<stateHome>/workforce/review-only.json)' },
         { command: 'c8ctl nano workforce status --json', description: 'Manifest entries joined against live supervisor status (desired vs actual), machine-readable for the install script / CI' },
         { command: 'c8ctl nano workforce list', description: 'Print the default manifest and list the manifests that exist on this machine' },
         { command: 'c8ctl nano workforce stop', description: "Remove this manifest's workers; stop the daemon too if no supervised workers remain" },
@@ -11036,9 +11090,8 @@ export const commands = {
       worker: { type: 'string', multiple: true, description: 'supervisor start: profile to launch as a supervised worker (repeatable)' },
       instances: { type: 'string', description: `supervisor add / workforce add: spawn/compose N distinct instances of the profile in one call (default 1, max ${MAX_ADD_INSTANCES}; for supervisor add cannot combine with --name)` },
       attach: { type: 'boolean', description: 'supervisor start: attach the interactive console after starting the daemon' },
-      profile: { type: 'string', description: `workforce: manifest name to operate on (default ${DEFAULT_WORKFORCE_MANIFEST}); each subcommand reads/writes <stateHome>/workforce/<name>.json` },
+      manifest: { type: 'string', description: `workforce: manifest name to operate on (default ${DEFAULT_WORKFORCE_MANIFEST}); each subcommand reads/writes <stateHome>/workforce/<name>.json. Renamed from --profile (which now collides with c8ctl's global connection-profile flag).` },
       roles: { type: 'string', description: 'workforce add: comma-separated role list for the entry (→ --job-type <rank>:<role> at start); mutually exclusive with --auto' },
-      json: { type: 'boolean', description: 'workforce list/status: emit machine-readable JSON (for the install script / CI)' },
     },
     handler: async (args, flags) => {
       const logger = getLogger();
@@ -11198,7 +11251,7 @@ function printUsage() {
   console.log('  c8ctl nano assign <profileName> <cap[,cap...]> [--name <n>] [--capabilities <a,b>]');
   console.log('  c8ctl nano work <profileName> [--auto [--auto-scope <p>]] [--arg <switch> ...] [--recovery-window <ms>] [--idle-timeout <ms>] [--job-timeout <ms>] [--poll-timeout <ms>] [--job-type <token> ...] [--sandbox none|docker|podman] [--image <ref>] [--env NAME=VALUE ...] [--secret-resolver host] [--min-free-mb <n>] [--clone-timeout <ms>] [--keep-runs] [--stream]');
   console.log('  c8ctl nano supervisor [start|status|add|remove|restart|stop|logs|attach] ... (manage many workers from one terminal)');
-  console.log('  c8ctl nano workforce [add|remove|list|start|status|stop] ... [--profile <manifest>] (declarative, reusable fleet manifests)');
+  console.log('  c8ctl nano workforce [add|remove|list|start|status|stop] ... [--manifest <manifest>] (declarative, reusable fleet manifests)');
   console.log('');
   console.log('Subcommands:');
   console.log('  start    Spawn an N-node local cluster wired to talk to each other on localhost');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c8ctl-plugin-nano",
-  "version": "1.43.1",
+  "version": "1.44.0",
   "type": "module",
   "description": "c8ctl plugin to start, inspect, and stop a local Nano BPM (nanobpmn) cluster",
   "main": "c8ctl-plugin.js",
@@ -57,12 +57,12 @@
   },
   "optionalDependencies": {
     "node-pty": "^1.0.0",
-    "@nanobpm/c8ctl-plugin-nano-darwin-arm64": "1.43.1",
-    "@nanobpm/c8ctl-plugin-nano-darwin-x64": "1.43.1",
-    "@nanobpm/c8ctl-plugin-nano-linux-x64": "1.43.1",
-    "@nanobpm/c8ctl-plugin-nano-linux-arm64": "1.43.1",
-    "@nanobpm/c8ctl-plugin-nano-linux-armv7": "1.43.1",
-    "@nanobpm/c8ctl-plugin-nano-linux-armv6": "1.43.1",
-    "@nanobpm/c8ctl-plugin-nano-win32-x64": "1.43.1"
+    "@nanobpm/c8ctl-plugin-nano-darwin-arm64": "1.44.0",
+    "@nanobpm/c8ctl-plugin-nano-darwin-x64": "1.44.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-x64": "1.44.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-arm64": "1.44.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-armv7": "1.44.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-armv6": "1.44.0",
+    "@nanobpm/c8ctl-plugin-nano-win32-x64": "1.44.0"
   }
 }