@hybridlabor-api/aos 4.2.0-beta.0 → 4.2.0

package/.agents/graph.md

@@ -45,7 +45,9 @@ the registry's own per-node allowlist would have reached for.
 - The dispatcher script (`startcycle-dispatch.mjs`) extracts every
   `--skill=` flag from the invocation text before anything else runs, then
   validates each name resolves to a real installed skill (a `SKILL.md`
-  under `~/.claude/skills/<name>/` or this project's own `skills/` tree) via
+  under any harness's global skills directory — `~/.claude/skills/<name>/`,
+  `~/.agents/skills/`, `~/.codex/skills/`, `~/.cursor/skills/`, `~/.roo/skills/`,
+  all of which the installer writes — or this project's own `skills/` tree) via
   a read-only lookup agent. **A name that doesn't resolve escalates
   immediately** — same "never silently fall back or guess" posture as a
   missing registry node id. This is a fail-fast check specifically so a

package/.agents/nodes.json

@@ -72,7 +72,8 @@
         "drizzle-orm-expert",
         "postgres-best-practices",
         "typescript-pro",
-        "python-pro"
+        "python-pro",
+        "bdbresilience"
       ],
       "instructions": "Implement the backend per the plan: DDD models, type-safe schemas, API routes, Clean Architecture. Write production_artifacts/02_backend_schema.md and the code."
     },
@@ -128,7 +129,8 @@
         "seo-audit",
         "wcag-audit-patterns",
         "github-repo",
-        "clean-code"
+        "clean-code",
+        "bdbresilience"
       ],
       "instructions": null
     }

package/.claude/workflows/startcycle-dispatch.mjs

@@ -385,10 +385,17 @@ const mandatorySkillNames = [...new Set([...skillsFromFlags, ...skillsFromArgs])
 if (mandatorySkillNames.length > 0) {
   const skillCheckResult = await agent(
     `Check whether each of these skill names resolves to an installed skill with a real SKILL.md: ${JSON.stringify(mandatorySkillNames)}. ` +
-      'Look under ~/.claude/skills/<name>/SKILL.md first (the global install location every harness syncs to); ' +
-      'if this project has its own skills/ directory, also accept skills/<name>/SKILL.md or skills/<container>/<name>/SKILL.md. ' +
-      'This is a read-only lookup, not a reasoning task -- do not invent a path that does not exist, and do not guess a close match for a name that is not actually there.\n\n' +
-      'Return only: { "found": string[], "missing": string[] }.',
+      'The installer syncs the same skill set to every harness it detects, so check all of these global locations, not just the first: ' +
+      '~/.claude/skills/<name>/SKILL.md, ~/.agents/skills/<name>/SKILL.md, ~/.codex/skills/<name>/SKILL.md, ' +
+      '~/.cursor/skills/<name>/SKILL.md, ~/.roo/skills/<name>/SKILL.md. A skill present in any one of them counts as installed — ' +
+      'this workflow may be driven from a harness whose directory is not ~/.claude. ' +
+      'If this project has its own skills/ directory, also accept skills/<name>/SKILL.md or skills/<container>/<name>/SKILL.md. ' +
+      'This is a read-only lookup, not a reasoning task -- do not invent a path that does not exist, and never report a close match as `found`.\n\n' +
+      'For any name that does NOT resolve, list up to five installed skills whose directory names are plausible near-misses ' +
+      '(substring, obvious typo, or the same words in another order) in `suggestions`. Read the real directory listing to do this -- ' +
+      'suggest only names that actually exist on disk. `--skill=` requires an exact directory name, and a user who mistyped one ' +
+      'has no way to discover the right spelling from an error that only says "not found".\n\n' +
+      'Return only: { "found": string[], "missing": string[], "suggestions": string[] }.',
     {
       label: 'validate-mandatory-skills',
       model: 'haiku',
@@ -398,15 +405,21 @@ if (mandatorySkillNames.length > 0) {
         properties: {
           found: { type: 'array', items: { type: 'string' } },
           missing: { type: 'array', items: { type: 'string' } },
+          suggestions: { type: 'array', items: { type: 'string' } },
         },
       },
     }
   );
   const missing = skillCheckResult?.missing ?? [];
   if (missing.length > 0) {
+    const near = skillCheckResult?.suggestions ?? [];
     return await escalate(
       `--skill named skill(s) that could not be found on this machine: ${missing.join(', ')}. ` +
-        'Refusing to silently proceed without a mandated skill -- check the name (it must match an installed skill directory) and re-run.'
+        (near.length
+          ? `Did you mean: ${near.join(', ')}? `
+          : 'No installed skill has a similar name. ') +
+        '--skill= takes the exact skill directory name; run /ask-tim to find the one you want. ' +
+        'Refusing to silently proceed without a mandated skill.'
     );
   }
   mandatorySkills = skillCheckResult?.found ?? mandatorySkillNames;

package/.claude/workflows/teamwork-dispatch.mjs

@@ -0,0 +1,287 @@
+// Dispatcher for /teamwork-preview. Turns the 9-step prompt-crafting protocol
+// from skills/basic/teamwork-preview/SKILL.md into an actual runnable sequence.
+//
+// Why a script and not prose: this repo has already paid for the alternative
+// once, recorded verbatim in skills/basic/startcycle-graph/SKILL.md --
+//
+//   "an earlier version of this file embedded the full pipeline description in
+//    prose, and the model followed it 'in spirit' inline instead of invoking the
+//    script -- silently skipping the whole graph, with no state.json, no
+//    subagents, no Reviewer, and no quality gate ever running."
+//
+// A 9-step protocol with acceptance criteria and integrity modes is exactly the
+// kind of thing that gets followed approximately. A script either runs or it
+// does not.
+//
+// Runtime constraints inherited from startcycle-dispatch.mjs, all four of which
+// this script obeys:
+//   1. No filesystem access from the script itself. Every read and write happens
+//      inside an agent() call; the script branches on schema-validated returns.
+//   2. No module loading. `agent`, `args` are ambient globals injected by the
+//      runtime, not imports.
+//   3. Concurrent agents writing one file race. This script is deliberately
+//      sequential -- each step's answers reshape the next question, so there is
+//      nothing to parallelise and no fragment/merge dance is needed.
+//   4. Prompts are the interface. An agent that returns prose instead of the
+//      declared schema breaks the branch, so every step declares one.
+//
+// This is NOT Antigravity's /teamwork-preview. That command is compiled into the
+// agy binary (its own conductor/orchestrator/auditor agent types, maintained by
+// Google). This is an independent implementation of the same idea, on a
+// different runtime, and it will behave differently.
+
+export const meta = {
+  name: 'teamwork-dispatch',
+  description:
+    'Interactive 9-step prompt crafting for multi-agent delegation: elicit, disambiguate, set integrity mode, draft requirements, design verification, set acceptance criteria, then assemble and validate a spec. Produces prompt_draft.md; does not build anything.',
+};
+
+// The user's answers accumulate here. Each step gets the answers so far, so a
+// later question can be shaped by an earlier one -- which is the whole point of
+// an interview and the reason these run sequentially rather than in parallel.
+const spec = {
+  idea: null,
+  scale: null,
+  integrityMode: null,
+  requirements: [],
+  verification: null,
+  acceptanceCriteria: [],
+  infrastructure: null,
+  workingDirectory: null,
+};
+
+// One shared preamble. Every step is an interview turn, not a build turn: the
+// agent asks, the human answers, nothing gets implemented. Stated once here
+// rather than restated nine times, where the ninth copy would drift.
+const INTERVIEW_RULE =
+  'You are conducting one step of an interactive interview. Ask the user, wait for their answer, and record it. ' +
+  'Do NOT implement anything, do NOT write project code, and do NOT proceed past your own step. ' +
+  'Finding facts is your job, not the user\'s: if a question can be answered by reading the filesystem or running a command, ' +
+  'do that yourself instead of asking. The decisions are the user\'s: put each to them and wait. ' +
+  'If the user has already answered something in an earlier step, do not ask it again -- the answers so far are given below.';
+
+function answersSoFar() {
+  const known = Object.entries(spec).filter(([, v]) =>
+    Array.isArray(v) ? v.length > 0 : v !== null
+  );
+  if (known.length === 0) return 'Nothing settled yet -- this is the first step.';
+  return `Answers settled so far:\n${JSON.stringify(Object.fromEntries(known), null, 2)}`;
+}
+
+async function step(n, title, instruction, schema, label) {
+  return await agent(
+    `${INTERVIEW_RULE}\n\n` +
+      `## Step ${n} of 9: ${title}\n\n${instruction}\n\n` +
+      `${answersSoFar()}\n\n` +
+      'Return only the declared JSON.',
+    { label: label || `step-${n}`, schema }
+  );
+}
+
+const goal = typeof args === 'string' ? args : args?.goal;
+
+// ---------------------------------------------------------------------
+// Steps 1-3: what is this, how big, and what is it allowed to use
+// ---------------------------------------------------------------------
+
+const s1 = await step(
+  1,
+  'Elicit the idea',
+  'Ask what the user wants to build, what its purpose is (production, demo, eval, or prototype), and who the audience is. ' +
+    'Condense their answer into a description of one or two sentences -- not a paragraph, and not a restatement of the question.' +
+    (goal ? `\n\nThe user already said: ${JSON.stringify(goal)}. Start from that; ask only what it leaves open.` : ''),
+  {
+    type: 'object',
+    required: ['description', 'purpose'],
+    properties: {
+      description: { type: 'string' },
+      purpose: { type: 'string', enum: ['production', 'demo', 'eval', 'prototype'] },
+      audience: { type: 'string' },
+    },
+  }
+);
+spec.idea = s1;
+
+const s2 = await step(
+  2,
+  'Identify ambiguity and scale',
+  'Probe every point that has more than one reasonable interpretation -- data sources, third-party services, where the scope stops. ' +
+    'Then establish the shape of the effort:\n' +
+    '- a single self-contained fix or feature (one implementer plus repeated adversarial review)\n' +
+    '- math, formal proofs, or a massive search space (may warrant a large agent team)\n' +
+    '- a standard multi-agent build\n\n' +
+    'Ambiguity you leave unresolved here becomes a wrong assumption baked into the spec, so be thorough now rather than agreeable.',
+  {
+    type: 'object',
+    required: ['scale'],
+    properties: {
+      scale: { type: 'string', enum: ['single-focused', 'large-scale', 'standard'] },
+      ambiguitiesResolved: { type: 'array', items: { type: 'string' } },
+    },
+  }
+);
+spec.scale = s2;
+
+const s3 = await step(
+  3,
+  'Determine integrity mode',
+  'Clarify the operational boundaries: may code be copied from existing open-source projects? Are pre-built libraries allowed for the core logic ' +
+    '(as opposed to the scaffolding)? May the implementer inspect the tests before writing the code?\n\n' +
+    'Map the answers: unrestricted → `development`; some shortcuts acceptable because it is a showcase → `demo`; ' +
+    'strict isolation, zero external leakage → `benchmark`.\n\n' +
+    'The last question matters more than it looks: an implementer who can read the tests first can satisfy them without solving the problem.',
+  {
+    type: 'object',
+    required: ['integrityMode'],
+    properties: {
+      integrityMode: { type: 'string', enum: ['development', 'demo', 'benchmark'] },
+      rationale: { type: 'string' },
+    },
+  }
+);
+spec.integrityMode = s3.integrityMode;
+
+// ---------------------------------------------------------------------
+// Steps 4-6: what must be true, and how anyone would know
+// ---------------------------------------------------------------------
+
+const s4 = await step(
+  4,
+  'Draft requirements',
+  'Write two to five requirement blocks (R1, R2, ...). Each states **what** is required, never **how** to implement it.\n\n' +
+    'Apply the litmus test to every one: would a senior engineer feel over-constrained by this? If yes, prune it. ' +
+    'A requirement that dictates implementation removes the judgement you are hiring the implementer for.',
+  {
+    type: 'object',
+    required: ['requirements'],
+    properties: {
+      requirements: {
+        type: 'array',
+        minItems: 2,
+        maxItems: 5,
+        items: {
+          type: 'object',
+          required: ['id', 'text'],
+          properties: { id: { type: 'string' }, text: { type: 'string' } },
+        },
+      },
+    },
+  }
+);
+spec.requirements = s4.requirements;
+
+const s5 = await step(
+  5,
+  'Design the verification mechanism',
+  'This is the forcing function, and it is the step that decides whether the whole exercise works.\n\n' +
+    'Its job is to create an objective target that forces a real build → test → debug loop and makes premature self-certification impossible. ' +
+    'An agent that can declare its own work done, will.\n\n' +
+    'Prefer something programmatic: a unit test suite, a test runner invocation, a CLI script that asserts. ' +
+    'Only if that is genuinely infeasible, draft an explicit agent-as-judge rubric -- and say why programmatic was not possible. ' +
+    'Ask whether the user has existing test suites, schemas, or a reference implementation to hand the implementer.',
+  {
+    type: 'object',
+    required: ['mechanism', 'isProgrammatic'],
+    properties: {
+      mechanism: { type: 'string' },
+      isProgrammatic: { type: 'boolean' },
+      resources: { type: 'array', items: { type: 'string' } },
+    },
+  }
+);
+spec.verification = s5;
+
+const s6 = await step(
+  6,
+  'Set acceptance criteria',
+  'Convert the verification mechanism into checkable criteria -- each one a thing that is either true or false, never a judgement call.\n\n' +
+    `Calibrate to the stated purpose (${spec.idea.purpose}): a demo must be achievable in a rapid time budget; ` +
+    'production needs real coverage, error handling and readiness; an eval needs reproducible metrics far more than polish.\n\n' +
+    'A criterion nobody can mechanically check is a wish, not a criterion.',
+  {
+    type: 'object',
+    required: ['criteria'],
+    properties: { criteria: { type: 'array', minItems: 1, items: { type: 'string' } } },
+  }
+);
+spec.acceptanceCriteria = s6.criteria;
+
+// ---------------------------------------------------------------------
+// Steps 7-8: where it runs
+// ---------------------------------------------------------------------
+
+const s7 = await step(
+  7,
+  'Infrastructure constraints',
+  'Only if the work reaches outside the local workspace: define the sandboxing or controlled APIs for remote file operations, ' +
+    'job launching, and outbound network calls.\n\n' +
+    'If the project stays entirely within local workspace files, say so and skip -- do not invent constraints to fill this step.',
+  {
+    type: 'object',
+    required: ['applicable'],
+    properties: { applicable: { type: 'boolean' }, constraints: { type: 'string' } },
+  }
+);
+spec.infrastructure = s7.applicable ? s7.constraints : null;
+
+const s8 = await step(
+  8,
+  'Choose the working directory',
+  'Confirm where this runs. Default to a path inside the current repository if the work belongs to it, ' +
+    `otherwise \`~/teamwork_projects/<project_name>\`. Check that the path exists or can be created, and say which.`,
+  {
+    type: 'object',
+    required: ['workingDirectory'],
+    properties: { workingDirectory: { type: 'string' }, exists: { type: 'boolean' } },
+  }
+);
+spec.workingDirectory = s8.workingDirectory;
+
+// ---------------------------------------------------------------------
+// Step 9: assemble, validate, and stop for approval
+// ---------------------------------------------------------------------
+
+const s9 = await agent(
+  'You are assembling the final specification from a completed 9-step interview. Do NOT implement any of it.\n\n' +
+    `Write \`prompt_draft.md\` into ${JSON.stringify(spec.workingDirectory)} with this structure:\n\n` +
+    '- the one-to-two sentence project description\n' +
+    '- `Working directory: <path>`\n' +
+    '- `Integrity mode: <mode>`\n' +
+    '- a team-scaling directive, if the scale calls for one\n' +
+    '- `## Requirements` — the R1..Rn blocks\n' +
+    '- `## Verification` — the mechanism, and the resources it may use\n' +
+    '- `## Acceptance Criteria` — as markdown checkboxes (`- [ ]`)\n' +
+    (spec.infrastructure ? '- `## Infrastructure Constraints`\n' : '') +
+    '\nThen validate it against three checks and report each honestly:\n' +
+    '1. Does every acceptance criterion trace back to a stated requirement? An orphan criterion means the interview missed a requirement.\n' +
+    '2. Is every criterion mechanically checkable — true or false, no judgement call?\n' +
+    '3. Does any requirement dictate *how* rather than *what*?\n\n' +
+    'Report failures rather than quietly fixing them: a validation step that edits its own input proves nothing.\n\n' +
+    `The interview produced:\n${JSON.stringify(spec, null, 2)}`,
+  {
+    label: 'step-9-assemble',
+    schema: {
+      type: 'object',
+      required: ['draftPath', 'validationsPassed'],
+      properties: {
+        draftPath: { type: 'string' },
+        validationsPassed: { type: 'boolean' },
+        issues: { type: 'array', items: { type: 'string' } },
+      },
+    },
+  }
+);
+
+// Deliberately stops here. Delegation is a separate, human-approved act: the
+// spec is the deliverable of this workflow, not a launch command. Handing an
+// unapproved spec straight to a swarm is precisely the premature
+// self-certification step 5 exists to prevent.
+return {
+  phase: s9.validationsPassed ? 'ready_for_approval' : 'validation_failed',
+  draftPath: s9.draftPath,
+  issues: s9.issues ?? [],
+  integrityMode: spec.integrityMode,
+  reason: s9.validationsPassed
+    ? `Spec assembled at ${s9.draftPath}. Review it, then delegate to the execution harness of your choice — this workflow deliberately does not launch anything.`
+    : `Spec assembled at ${s9.draftPath} but validation found issues; resolve them before delegating.`,
+};

package/THIRD_PARTY_NOTICES.md

@@ -127,6 +127,56 @@ SOFTWARE.
 
 ---
 
+## mattpocock/skills
+
+<https://github.com/mattpocock/skills> — MIT.
+
+The grilling family and the domain-modeling discipline it composes with:
+
+| In AOS | Upstream |
+|---|---|
+| `skills/global_config/grilling/` | `skills/productivity/grilling/` |
+| `skills/global_config/grill-me/` | `skills/productivity/grill-me/` |
+| `skills/global_config/grill-with-docs/` | `skills/engineering/grill-with-docs/` |
+| `skills/global_config/domain-modeling/` | `skills/engineering/domain-modeling/` (incl. `ADR-FORMAT.md`, `CONTEXT-FORMAT.md`) |
+
+`grilling`'s interview protocol and `domain-modeling` are carried over
+essentially verbatim; `grill-me` and `grill-with-docs` are rewritten to name AOS's
+own pipelines in their hand-off sections, but keep upstream's composition — both
+are thin wrappers that invoke the primitive rather than restating it. Upstream's
+`agents/openai.yaml` under `domain-modeling` is harness-specific to that project
+and was not carried over.
+
+`skills/global_config/ask-tim/` is derived from upstream's `ask-matt` router. It
+is not a copy: the flow it maps is AOS's own, since most of the skills on
+upstream's main flow have no AOS equivalent.
+
+```
+MIT License
+
+Copyright (c) 2026 Matt Pocock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+---
+
 ## Note on `mcps/`
 
 Sub-repositories vendored under `mcps/` carry their own `LICENSE` files in

package/docs/skills_table.md

@@ -48,6 +48,7 @@
 | `subagent-driven-development` | Use when executing implementation plans with independent tasks in the current session |
 | `tdd-workflow` | Test-Driven Development workflow principles. RED-GREEN-REFACTOR cycle. |
 | `tmux` | Expert tmux session, window, and pane management for terminal multiplexing, persistent remote workflows, and shell scripting automation. |
+| `teamwork-preview` | Interactive 9-step prompt crafting and delegation protocol for autonomous multi-agent teams across harnesses. |
 
 #### 🎨 Frontend & UI/UX
 | Skill Name | Description |

package/installer.js

@@ -2554,6 +2554,21 @@ function injectHarnessRules() {
             log.step(`Installed GEMINI.md to ${path.join(geminiDir, 'GEMINI.md')}`);
         }, 'The harness injection below still runs.');
 
+        // Dispatcher scripts must land in ~/.claude/workflows/, because that is
+        // where the skills that route to them look: startcycle-graph's SKILL.md
+        // and teamwork-preview's both tell the model to call `Workflow` with
+        // scriptPath `$HOME/.claude/workflows/<name>.mjs`. installProjectHarness()
+        // copies them into a *project*, which only helps a project that opted into
+        // the local harness -- on a plain global install those paths did not exist
+        // at all, so the skill pointed at a file that was never delivered.
+        installStep(`install dispatcher workflows to ${path.join(homeDir, '.claude', 'workflows')}`, () => {
+            const workflowsSrc = path.join(srcDir, '.claude', 'workflows');
+            if (fs.existsSync(workflowsSrc)) {
+                copyDirRecursiveSync(workflowsSrc, path.join(homeDir, '.claude', 'workflows'));
+                log.step(`Installed dispatcher workflows to ${path.join(homeDir, '.claude', 'workflows')}`);
+            }
+        }, '/startcycle-graph and /teamwork-preview fall back to their prose protocols.');
+
         const startcycleWorkflowSrc = path.join(srcDir, '.agents', 'workflows', 'startcycle.md');
         const sources = installStep('read the global rule sources', () => ({
             globalRules: fs.readFileSync(geminiMdSrc, 'utf8'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridlabor-api/aos",
-  "version": "4.2.0-beta.0",
+  "version": "4.2.0",
   "description": "AOS — A Curated AI AGENT OS. Optimized agent skills and add-ons like memB, OpenWiki, Heimdall Token Saver, and Godmode architectures.",
   "main": "installer.js",
   "bin": {

package/skills/basic/bdbmediastorm/SKILL.md

@@ -26,9 +26,11 @@ Ideation must never be performed in isolation. Spawn specialized subagents to an
 
 ---
 
-## 2. Interactive `/grill-me` Technical Interview
+## 2. Interactive Technical Interview
 
-Before drafting signal flow diagrams or system configs, execute a mandatory `/grill-me` interactive interview. Deeply challenge the user's technical assumptions and hardware readiness by asking targeted questions:
+Before drafting signal flow diagrams or system configs, **invoke the `grill-with-docs` skill** (or `grill-me` when there is no working directory) and run it to completion. Those skills hold the interview protocol — design tree, frontier rounds, numbered questions each with a recommended answer — and it is not restated here.
+
+What this domain adds to that protocol: deeply challenge the user's technical assumptions and hardware readiness. The frontier questions for a show-control build are:
 
 * **Signal & Network Protocols:**
   - What protocols govern data movement? (OSC, Art-Net, sACN, MIDI, SMPTE Timecode, NDI)?
@@ -48,7 +50,7 @@ Before drafting signal flow diagrams or system configs, execute a mandatory `/gr
 
 ## 3. Target Directory & Scaffolding
 
-After aligning on system architecture through the `/grill-me` process:
+After aligning on system architecture through the grilling interview:
 1. **Confirm Output Directory:** Ask the user: *"In which project directory should the output show-control plan and architecture files be stored?"*
 2. **Scaffold Foundational Files:** Once confirmed, write the core show specification files (`agent.md`, `signal-flow.md`, `network-patch.json`, `failover-matrix.md`).
 
@@ -94,7 +96,7 @@ BDB MediaStorm is the master ideation and brainstorming engine for live show-con
 - **Exclude:** Do not use for generating video timelines or 3D meshes.
 
 ## Core Process
-1. Run an interactive `/grill-me` session to challenge assumptions about protocols, hardware, and bandwidth.
+1. Run `grill-with-docs` (or `grill-me`) to challenge assumptions about protocols, hardware, and bandwidth.
 2. Scaffold foundational files (`agent.md`, `signal-flow.md`, `network-patch.json`).
 3. Generate a strict Mermaid.js signal flow diagram mapping all protocols.
 4. Document a main/backup redundancy and failover matrix.
@@ -115,7 +117,7 @@ BDB MediaStorm is the master ideation and brainstorming engine for live show-con
 
 ## Verification
 
-- [ ] `/grill-me` session was completed with answers regarding protocols and bandwidth.
+- [ ] The grilling interview was completed with answers regarding protocols and bandwidth.
 - [ ] Output includes a Mermaid.js signal flow diagram.
 - [ ] A dedicated failover/blackout mechanism is documented.
 

package/skills/basic/startcycle/SKILL.md

@@ -88,7 +88,9 @@ Run only the streams the goal actually needs. A plain backend feature does not n
 > does the work `startcycle-graph`'s script does for you: extract the
 > `--skill=` flag(s) from the invocation text before anything else runs,
 > confirm each name resolves to a real `SKILL.md` (under
-> `~/.claude/skills/<name>/` or this project's own `skills/` tree) — stop
+> any harness's global skills directory — `~/.claude/skills/<name>/`,
+> `~/.agents/skills/`, `~/.codex/skills/`, `~/.cursor/skills/` or `~/.roo/skills/`
+> — or this project's own `skills/` tree) — stop
 > and tell the user if one doesn't, don't silently proceed without it —
 > note the validated list in `00_execution_plan.md`, and include it as a
 > **hard requirement, not a suggestion** in each Build stream's dispatch

package/skills/basic/startcycle-graph/SKILL.md

@@ -56,8 +56,24 @@ rather than guessing one.
 (repeatable, quote a name with spaces) forces that skill into this run as a
 hard requirement for the build nodes, validated to exist before anything
 else runs — this is how you make the pipeline use your own private skill
-that isn't part of `.agents/nodes.json`'s registry. See
-[`.agents/graph.md`](../../../.agents/graph.md)'s "Mandatory Skill
+that isn't part of `.agents/nodes.json`'s registry.
+
+`<name>` is the **exact skill directory name**, not a description — `ui-component`,
+not "the UI one". Two ways to find it without leaving the terminal:
+
+- `/ask-tim` — the routing skill; start there when you know the *job* but not the name
+- list the installed skills directly, if you half-remember the spelling. The installer
+  syncs the same set to every harness it detects, so use whichever path is yours:
+  `~/.claude/skills`, `~/.agents/skills`, `~/.codex/skills`, `~/.cursor/skills`, or
+  `~/.roo/skills`. `ls ~/.agents/skills` is the safest guess on an unknown machine —
+  that one is written on every install regardless of harness.
+
+A name that does not resolve halts the run before any agent works, and the
+error now lists installed near-misses rather than only saying "not found".
+That is deliberate: silently running without a skill you explicitly demanded
+is worse than stopping.
+
+See [`.agents/graph.md`](../../../.agents/graph.md)'s "Mandatory Skill
 Injection" section for the full mechanics; nothing about it needs handling
 in this router file, since `args` is passed through as raw text either way.
 

package/skills/basic/startcycle-graph-user/SKILL.md

@@ -36,7 +36,9 @@ with spaces) forces that skill into this run as a hard requirement — for a
 private skill of the user's own this throwaway graph would otherwise never
 know to reach for. Extract any `--skill=` flag(s) from the invocation text
 before step 1, confirm each name resolves to a real `SKILL.md` (under
-`~/.claude/skills/<name>/` or this project's own `skills/` tree if it has
+any harness's global skills directory — `~/.claude/skills/<name>/`,
+`~/.agents/skills/`, `~/.codex/skills/`, `~/.cursor/skills/`, `~/.roo/skills/` —
+or this project's own `skills/` tree if it has
 one) — stop and tell the user if one doesn't, never silently proceed
 without it — and include it as a **hard requirement, not a suggestion** in
 the Plan node's and every Worker node's prompt. The Review node checks the