harness-everything 0.2.2 → 0.3.6

package/multi-agent-workspace/guidelines/platform-cursor.md

@@ -0,0 +1,40 @@
+---
+description: "Platform guidelines for generating agent scaffolds targeting Cursor. Covers naming, tool declarations, directory layout, and interaction mechanisms."
+---
+
+# Platform Guidelines: Cursor
+
+## Naming Convention
+
+- Agent/Rule names use lower-kebab-case (e.g., `requirement-analyzer`, `backend-developer`).
+- File names follow `.cursorrules` or `.cursor/rules/*.mdc` depending on project structure.
+
+## Tools Declaration
+
+Cursor manages tool permissions natively through its IDE setting UI. Use standard tool intent categories:
+
+```yaml
+tools: [read, edit, search, execute]
+```
+
+When generating agent files from templates, substitute the placeholders as follows:
+- `{{TOOLS_ARRAY_DECLARATION}}`: `tools: [read, edit, search, execute]`
+- `{{READ_TOOL_NAME}}`: `read`
+- `{{EDIT_TOOL_NAME}}`: `edit`
+- `{{SEARCH_TOOL_NAME}}`: `search`
+- `{{EXECUTE_TOOL_NAME}}`: `execute`
+
+## Directory Layout
+
+| Artifact | Path |
+|----------|------|
+| Native Project Rules | `.cursorrules` (project root) |
+| Modular Rule Definitions | `.cursor/rules/*.mdc` |
+| System Prompt | `.cursorrules` |
+
+Default target directory is `.cursor/`.
+
+## User Interaction & Enforcement Mechanism
+
+Cursor does not provide lifecycle hooks or exit code interception. All rule files operate as **Advisory Context** injected into the model prompt.
+Ask questions directly in chat or request user confirmation before major file modifications.

package/multi-agent-workspace/guidelines/platform-hermes.md

@@ -0,0 +1,38 @@
+---
+description: "Platform guidelines for generating agent scaffolds targeting Hermes Agent (Nous Research). Covers naming, tool declarations, directory layout, and interaction mechanisms."
+---
+
+# Platform Guidelines: Hermes Agent (Nous Research)
+
+## Naming Convention
+
+- Uses `.hermes.md` project-level context file or standard markdown rules files.
+
+## Tools Declaration
+
+Hermes Agent auto-detects CLI capabilities. Use standard tool declarations:
+
+```yaml
+tools: [read, edit, search, execute]
+```
+
+When generating agent files from templates, substitute the placeholders as follows:
+- `{{TOOLS_ARRAY_DECLARATION}}`: `tools: [read, edit, search, execute]`
+- `{{READ_TOOL_NAME}}`: `read`
+- `{{EDIT_TOOL_NAME}}`: `edit`
+- `{{SEARCH_TOOL_NAME}}`: `search`
+- `{{EXECUTE_TOOL_NAME}}`: `execute`
+
+## Directory Layout
+
+| Artifact | Path |
+|----------|------|
+| Native Context | `.hermes.md` (project root) |
+| Fallback Context | Reads `AGENTS.md` / `CLAUDE.md` / `.cursorrules` if present |
+
+Default target directory is project root (`.hermes.md`).
+
+## User Interaction & Enforcement Mechanism
+
+Hermes Agent loads `.hermes.md` into session context. Like other non-hook platforms, enforcement is **Advisory Only**.
+Interactions and question prompting happen in the Hermes terminal or web UI session.

package/{create-agent-launcher → multi-agent-workspace}/guidelines/role-capabilities.md

@@ -1,108 +1,108 @@
----
-description: >
-  Capability menu for create-agent-launcher. Maps Karpathy behavioral guidelines and
-  skill-derived behaviors to each subAgent role. Consult when generating any agent file.
-  Core roles use the templates directly. Specialist and custom roles inject the blocks below
-  into templates/specialist-agent.md.
----
-
-# Agent Role Capabilities Reference
-
-## How to Use This File
-
-When generating a specialist or custom agent (using `templates/specialist-agent.md`), pick the appropriate `## Behavioral Guidelines` block from this file and inject it into the `{{BEHAVIORAL_GUIDELINES_BLOCK}}` placeholder. Do not mix capabilities — keep roles strictly separated to avoid LLM context dilution.
-
----
-
-## Specialist Role Blocks
-
-### Document Writer (Markdown Editor)
-
-**Purpose**: Edit, format, and structure Markdown files (e.g., `README.md`, `docs/`) without touching source code.
-
-**Ready-to-Embed Block**:
-
-```markdown
-### Architect, Not a Coder
-*(from Karpathy: Think Before Coding)*
-- Your domain is strictly documentation and markdown. DO NOT write or modify application source code.
-- If documentation requirements are unclear, provide 2-3 structured outline options for the user to choose from. Do not guess.
-
-### Surgical Documentation Updates
-*(from Karpathy: Surgical Changes)*
-- When updating an existing document, touch ONLY the section that requires changes.
-- Preserve existing prose, formatting, and screenshots exactly as they are.
-- Do not "improve" or rewrite adjacent paragraphs unless explicitly asked.
-```
-
----
-
-### Shell Script Expert
-
-**Purpose**: Create, fix, and maintain bash, batch, or CI pipeline scripts.
-
-**Ready-to-Embed Block**:
-
-```markdown
-### Blind Obedience to the Task
-*(from Karpathy: Simplicity First)*
-- ONLY implement exactly what the task requires. DO NOT question the design or add pre-emptive abstraction.
-- Keep scripts as simple and POSIX-compliant as possible unless a specific shell (e.g., bash) is requested.
-
-### Instrument and Diagnose Silently
-*(from Karpathy: Goal-Driven Execution + skill: diagnose)*
-- If a script fails during verification, do not immediately ask for help.
-- Generate a hypothesis, add echo/set -x instrumentation, run it to confirm, and fix it silently.
-- Only output a Handover Block when the script executes successfully.
-```
-
----
-
-### Frontend Developer
-
-**Purpose**: Implement UI components and styling based on design requirements.
-
-**Ready-to-Embed Block**:
-
-```markdown
-### Blind Obedience to the Design
-*(from Karpathy: Simplicity First)*
-- Implement exactly what the UI specification requires. Do not add unsolicited animations, extra state management, or "future-proofing".
-- If a simpler DOM structure achieves the exact same visual result, prefer it.
-
-### Surgical UI Changes
-*(from Karpathy: Surgical Changes)*
-- Touch only the components explicitly mentioned in the plan.
-- Match the existing project styling system (e.g., Tailwind, CSS Modules) exactly.
-- Do not refactor adjacent UI components just because you are in the file.
-```
-
----
-
-### Architecture Reviewer
-
-**Purpose**: Perform broad structural audits and compliance checks. Read-only.
-
-**Ready-to-Embed Block**:
-
-```markdown
-### Map Before Analyzing
-*(from skill: zoom-out)*
-- Before rendering a verdict, you MUST map all relevant modules and architectural boundaries.
-- Do not make assumptions based on a single file; trace the dependency graph.
-
-### Strict Compliance Verification
-*(from skill: grill-with-docs)*
-- Compare the current structure against the project's Architectural Decision Records (ADRs) or established patterns.
-- Do not suggest subjective "clean code" improvements; only report objective architectural violations.
-- You are Read-Only. Do not modify files to fix the architecture.
-```
-
----
-
-## Custom Roles (Decision Matrix)
-
-If the user asks for a completely undefined role (e.g., "Database Expert"), compose a custom block using this philosophy:
-1. Is this a **thinking/planning** role? → Give it *Think Before Coding* (propose options, don't guess).
-2. Is this an **execution/coding** role? → Give it *Blind Obedience* (execute exactly, keep it simple) and *Surgical Changes* (touch only what's needed).
-3. Is this an **auditing/QA** role? → Give it *Strict Binary Verification* (pass/fail only, no modifications).
+---
+description: >
+  Capability menu for multi-agent-workspace. Maps Karpathy behavioral guidelines and
+  skill-derived behaviors to each subAgent role. Consult when generating any agent file.
+  Core roles use the templates directly. Specialist and custom roles inject the blocks below
+  into templates/specialist-agent.md.
+---
+
+# Agent Role Capabilities Reference
+
+## How to Use This File
+
+When generating a specialist or custom agent (using `templates/specialist-agent.md`), pick the appropriate `## Behavioral Guidelines` block from this file and inject it into the `{{BEHAVIORAL_GUIDELINES_BLOCK}}` placeholder. Do not mix capabilities — keep roles strictly separated to avoid LLM context dilution.
+
+---
+
+## Specialist Role Blocks
+
+### Document Writer (Markdown Editor)
+
+**Purpose**: Edit, format, and structure Markdown files (e.g., `README.md`, `docs/`) without touching source code.
+
+**Ready-to-Embed Block**:
+
+```markdown
+### Architect, Not a Coder
+*(from Karpathy: Think Before Coding)*
+- Your domain is strictly documentation and markdown. DO NOT write or modify application source code.
+- If documentation requirements are unclear, provide 2-3 structured outline options for the user to choose from. Do not guess.
+
+### Surgical Documentation Updates
+*(from Karpathy: Surgical Changes)*
+- When updating an existing document, touch ONLY the section that requires changes.
+- Preserve existing prose, formatting, and screenshots exactly as they are.
+- Do not "improve" or rewrite adjacent paragraphs unless explicitly asked.
+```
+
+---
+
+### Shell Script Expert
+
+**Purpose**: Create, fix, and maintain bash, batch, or CI pipeline scripts.
+
+**Ready-to-Embed Block**:
+
+```markdown
+### Blind Obedience to the Task
+*(from Karpathy: Simplicity First)*
+- ONLY implement exactly what the task requires. DO NOT question the design or add pre-emptive abstraction.
+- Keep scripts as simple and POSIX-compliant as possible unless a specific shell (e.g., bash) is requested.
+
+### Instrument and Diagnose Silently
+*(from Karpathy: Goal-Driven Execution + skill: diagnose)*
+- If a script fails during verification, do not immediately ask for help.
+- Generate a hypothesis, add echo/set -x instrumentation, run it to confirm, and fix it silently.
+- Only output a Handover Block when the script executes successfully.
+```
+
+---
+
+### Frontend Developer
+
+**Purpose**: Implement UI components and styling based on design requirements.
+
+**Ready-to-Embed Block**:
+
+```markdown
+### Blind Obedience to the Design
+*(from Karpathy: Simplicity First)*
+- Implement exactly what the UI specification requires. Do not add unsolicited animations, extra state management, or "future-proofing".
+- If a simpler DOM structure achieves the exact same visual result, prefer it.
+
+### Surgical UI Changes
+*(from Karpathy: Surgical Changes)*
+- Touch only the components explicitly mentioned in the plan.
+- Match the existing project styling system (e.g., Tailwind, CSS Modules) exactly.
+- Do not refactor adjacent UI components just because you are in the file.
+```
+
+---
+
+### Architecture Reviewer
+
+**Purpose**: Perform broad structural audits and compliance checks. Read-only.
+
+**Ready-to-Embed Block**:
+
+```markdown
+### Map Before Analyzing
+*(from skill: zoom-out)*
+- Before rendering a verdict, you MUST map all relevant modules and architectural boundaries.
+- Do not make assumptions based on a single file; trace the dependency graph.
+
+### Strict Compliance Verification
+*(from skill: grill-with-docs)*
+- Compare the current structure against the project's Architectural Decision Records (ADRs) or established patterns.
+- Do not suggest subjective "clean code" improvements; only report objective architectural violations.
+- You are Read-Only. Do not modify files to fix the architecture.
+```
+
+---
+
+## Custom Roles (Decision Matrix)
+
+If the user asks for a completely undefined role (e.g., "Database Expert"), compose a custom block using this philosophy:
+1. Is this a **thinking/planning** role? → Give it *Think Before Coding* (propose options, don't guess).
+2. Is this an **execution/coding** role? → Give it *Blind Obedience* (execute exactly, keep it simple) and *Surgical Changes* (touch only what's needed).
+3. Is this an **auditing/QA** role? → Give it *Strict Binary Verification* (pass/fail only, no modifications).

package/multi-agent-workspace/references/agency-agents.md

@@ -0,0 +1,31 @@
+# agency-agents source contract
+
+`agency-agents` is an optional development-time source input. The merged skill
+does not vendor its agent bodies or assume a machine-specific source path.
+
+## Verified source snapshot
+
+The local source used for issue 26 verification contains:
+
+- 18 divisions and 258 Markdown agent files with YAML frontmatter.
+- Source revision `3c9588880b7cafaec325a104899fd8bbe27e7d72`.
+- Frontmatter keys observed across the roster: `name`, `description`,
+  `color`, `emoji`, and `vibe`.
+- 14 converter targets: `antigravity`, `gemini-cli`, `opencode`, `cursor`,
+  `aider`, `windsurf`, `openclaw`, `qwen`, `zcode`, `kimi`, `codex`,
+  `osaurus`, `hermes`, and `vibe`.
+
+Counts and revision are evidence from the local checkout, not a promise that
+future upstream revisions are identical. `scaffold.js` records the revision,
+rejects empty divisions and duplicate names/slugs, and requires
+`--allow-source-drift` before refreshing an existing generated catalog.
+
+## Selection and provenance
+
+Pass `--agency-source <path>` or set `AGENCY_AGENTS_SOURCE`. Use repeated
+`--division` or `--agent` options to select roles; use `--all-agents` only when
+the complete metadata catalog is deliberately needed. The generated catalog
+stores metadata and relative source files, not specialist bodies. Load a body
+on demand after a bounded brief has been assigned.
+
+The upstream repository is [msitarzewski/agency-agents](https://github.com/msitarzewski/agency-agents), licensed under MIT by AgentLand Contributors. Harness preserves that provenance; see `NOTICE-agency-agents.md` for the license notice.

package/multi-agent-workspace/references/architecture-guide.md

@@ -0,0 +1,32 @@
+# Multi-Agent Workspace Architecture
+
+The canonical skill combines two responsibilities that previously routed
+independently: physical workspace scaffolding and specialist delegation.
+
+```text
+source catalog (optional)
+        |
+        v
+validate divisions + frontmatter + revision
+        |
+        +--> roles/agency-catalog.json --> explicit selection
+        |
+        v
+six zones --> launcher.md --> bounded specialist handoff
+        |
+        +--> index_memory.js --> memory-index.md
+        +--> AGENTS.md router + manifest.json
+```
+
+## Invariants
+
+- `.harness/multi-agent/` is the generated boundary. The external catalog is
+  read-only input and is never mutated.
+- `state/`, `logs/`, `decisions/`, `domain/`, `architecture/`, and `roles/`
+  have one semantic owner each. Raw logs do not enter default context.
+- The generated router is immutable. Specialists receive a bounded brief and
+  return `status`, `changes`, `verification`, `risks`, and `nextAction`.
+- A source that is absent is represented as `agency.status: unavailable`; an
+  unavailable source cannot be mistaken for a complete roster.
+- A changed source revision is a migration event. Refresh only with
+  `--allow-source-drift`, then review the new catalog and selection.

package/multi-agent-workspace/references/orchestration.md

@@ -0,0 +1,48 @@
+# Sub-agent Orchestration Details
+
+Details moved from SKILL.md. Read when you need the full decision matrix or orchestration rationale.
+
+## Process & Sub-agent Spawning Flow
+
+```mermaid
+flowchart TD
+    Start[Trigger: Need Specialized Division of Labor] --> ScopeCheck{Task Complexity Check<br>>2 files / >300 lines?}
+    
+    ScopeCheck -- No --> DirectTDD[Handle Directly via TDD / Tier 2 Flow]
+    ScopeCheck -- Yes --> CheckTool{1. Sub-agent Tool Available?<br>e.g. runSubagent / Task tool}
+    
+    CheckTool -- Yes --> SpawnSub[Spawn Specialized Sub-agent<br>Inject Domain Skill + Isolated Scope]
+    CheckTool -- No --> InlineSwitch{2. Inline Persona Role-Switch Fallback}
+    
+    InlineSwitch --> AssumePersona[Temporarily Assume Specialized Persona<br>e.g. DB Architect / Frontend Specialist]
+    AssumePersona --> ExecuteInline[Execute Domain Task with Isolated Context]
+    
+    SpawnSub --> Handoff[Receive Structured Handoff Report]
+    ExecuteInline --> Handoff
+    Handoff --> NextTask[Proceed to Next Milestone]
+```
+
+## Dynamic Sub-agent Orchestration
+
+When launching ad-hoc sub-agents during execution:
+- **Persona Alignment**: Give the sub-agent a focused role (e.g. "Senior Database Architect focusing solely on user table indexes").
+- **Scope Isolation**: Provide only the relevant file paths and context necessary for the specific sub-task.
+- **Model Efficiency**: Match sub-task complexity with appropriate model tiers (e.g. small/fast model for file lookup, main model for multi-file implementation).
+- **Handoff Contract**: Require a brief summary upon completion covering modified files, new interfaces, and notes for downstream tasks.
+- **Scope Monitoring**: Sub-agent tool executions are monitored by `hooks/scripts/subagent-scope-guard.js`, which alerts if files outside the briefed brief are edited.
+
+## Scaffolding Multi-Agent Project Infrastructure (Sequential Workflows)
+
+For generating structured, permanent agent manifests in a repository, follow the progressive workflow steps in order:
+1. **Phase 1 — Platform Discovery**: Read `multi-agent-workspace/workflows/01-init.md`
+2. **Phase 2 — Project Analysis**: Read `multi-agent-workspace/workflows/02-analysis.md`
+3. **Phase 3 — Scaffold Generation**: Read `multi-agent-workspace/workflows/03-generation.md`
+4. **Phase 4 — Execution & Handoff**: Read `multi-agent-workspace/workflows/04-launcher.md`
+
+- **Platform Guidelines**: Supported platforms in `multi-agent-workspace/guidelines/`:
+  - `platform-claude.md` — Claude Code (Hard enforcement via native hooks)
+  - `platform-cursor.md` — Cursor (Advisory rules via `.cursorrules`)
+  - `platform-copilot.md` — GitHub Copilot (Advisory custom instructions)
+  - `platform-codex.md` — Codex CLI (Advisory `AGENTS.md`)
+  - `platform-continue.md` — Continue.dev (Advisory `.continue/rules/harness.md`)
+  - `platform-hermes.md` — Hermes Agent (Advisory `.hermes.md`)

package/multi-agent-workspace/scripts/agency-catalog.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+
+const SUPPORTED_PLATFORMS = Object.freeze([
+  'antigravity', 'gemini-cli', 'opencode', 'cursor', 'aider', 'windsurf',
+  'openclaw', 'qwen', 'zcode', 'kimi', 'codex', 'osaurus', 'hermes', 'vibe'
+]);
+
+function scalar(value) {
+  const trimmed = value.trim();
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function parseFrontmatter(raw, filePath) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) throw new Error(`agent file lacks YAML frontmatter: ${filePath}`);
+  const fields = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    if (!line.trim() || line.trim().startsWith('#')) continue;
+    const field = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (field) fields[field[1]] = scalar(field[2]);
+  }
+  if (!fields.name || !fields.description) {
+    throw new Error(`agent frontmatter requires name and description: ${filePath}`);
+  }
+  return fields;
+}
+
+function slugify(value) {
+  const slug = value.normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!slug) throw new Error(`agent name cannot produce a safe slug: ${value}`);
+  return slug;
+}
+
+function safeSegment(value, label) {
+  if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value)) {
+    throw new Error(`${label} must be a single safe path segment: ${value}`);
+  }
+  return value;
+}
+
+function sourceIdentity(sourceRoot) {
+  let revision = null;
+  try {
+    revision = execFileSync('git', ['-C', sourceRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    // A source export may not be a Git checkout; use a content fingerprint.
+  }
+  if (!revision) {
+    const hash = crypto.createHash('sha256');
+    const files = [];
+    const walk = dir => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === '.git' || entry.name === 'integrations' || entry.name === 'scripts') continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) walk(full);
+        else if (entry.name === 'divisions.json' || entry.name.endsWith('.md')) files.push(full);
+      }
+    };
+    walk(sourceRoot);
+    for (const file of files.sort()) {
+      hash.update(path.relative(sourceRoot, file).replace(/\\/g, '/'));
+      hash.update('\0');
+      hash.update(fs.readFileSync(file));
+    }
+    revision = `export-${hash.digest('hex').slice(0, 40)}`;
+  }
+  let version = null;
+  const packagePath = path.join(sourceRoot, 'package.json');
+  if (fs.existsSync(packagePath)) {
+    try { version = JSON.parse(fs.readFileSync(packagePath, 'utf8')).version || null; } catch { /* optional */ }
+  }
+  return { revision, version };
+}
+
+function readAgencyCatalog(sourceRoot) {
+  const root = path.resolve(sourceRoot);
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    throw new Error(`agency source not found: ${root}`);
+  }
+  const divisionsPath = path.join(root, 'divisions.json');
+  if (!fs.existsSync(divisionsPath)) throw new Error(`agency source is missing divisions.json: ${root}`);
+
+  let divisionsManifest;
+  try { divisionsManifest = JSON.parse(fs.readFileSync(divisionsPath, 'utf8')); }
+  catch (error) { throw new Error(`invalid divisions.json: ${error.message}`); }
+  if (!divisionsManifest.divisions || typeof divisionsManifest.divisions !== 'object') {
+    throw new Error('divisions.json must contain a divisions object');
+  }
+
+  const divisions = [];
+  const agents = [];
+  const seenNames = new Map();
+  const seenSlugs = new Map();
+  for (const [rawId, metadata] of Object.entries(divisionsManifest.divisions).sort(([a], [b]) => a.localeCompare(b))) {
+    const id = safeSegment(rawId, 'division id');
+    const divisionPath = path.join(root, id);
+    if (!fs.existsSync(divisionPath) || !fs.statSync(divisionPath).isDirectory()) {
+      throw new Error(`division directory is missing: ${id}`);
+    }
+    const files = fs.readdirSync(divisionPath).filter(file => file.endsWith('.md')).sort();
+    if (files.length === 0) throw new Error(`division is empty: ${id}`);
+    const divisionAgents = [];
+    for (const file of files) {
+      const absolutePath = path.join(divisionPath, file);
+      const fields = parseFrontmatter(fs.readFileSync(absolutePath, 'utf8'), absolutePath);
+      const slug = slugify(path.basename(file, '.md'));
+      const normalizedName = fields.name.toLowerCase();
+      if (seenNames.has(normalizedName)) {
+        throw new Error(`duplicate agent name "${fields.name}" in ${seenNames.get(normalizedName)} and ${absolutePath}`);
+      }
+      if (seenSlugs.has(slug)) {
+        throw new Error(`duplicate agent slug "${slug}" in ${seenSlugs.get(slug)} and ${absolutePath}`);
+      }
+      seenNames.set(normalizedName, absolutePath);
+      seenSlugs.set(slug, absolutePath);
+      const agent = {
+        slug,
+        name: fields.name,
+        description: fields.description,
+        division: id,
+        sourceFile: path.relative(root, absolutePath).replace(/\\/g, '/'),
+        color: fields.color || null,
+        emoji: fields.emoji || null,
+        vibe: fields.vibe || null
+      };
+      divisionAgents.push(agent);
+      agents.push(agent);
+    }
+    divisions.push({
+      id,
+      label: metadata && metadata.label ? metadata.label : id,
+      icon: metadata && metadata.icon ? metadata.icon : null,
+      color: metadata && metadata.color ? metadata.color : null,
+      agentCount: divisionAgents.length,
+      agents: divisionAgents
+    });
+  }
+
+  const identity = sourceIdentity(root);
+  return {
+    source: {
+      kind: 'agency-agents',
+      locator: path.basename(root),
+      revision: identity.revision,
+      version: identity.version,
+      divisionCount: divisions.length,
+      agentCount: agents.length,
+      converterTargets: SUPPORTED_PLATFORMS
+    },
+    divisions,
+    agents
+  };
+}
+
+function resolveSelection(catalog, divisionIds = [], agentIds = [], allAgents = false) {
+  const divisionMap = new Map(catalog.divisions.map(division => [division.id, division]));
+  const agentMap = new Map(catalog.agents.map(agent => [agent.slug, agent]));
+  const nameMap = new Map(catalog.agents.map(agent => [agent.name.toLowerCase(), agent]));
+  const selected = new Map();
+  const requestedDivisions = [...new Set(divisionIds)].sort();
+  for (const id of requestedDivisions) {
+    if (!divisionMap.has(id)) throw new Error(`unknown agency division: ${id}`);
+    for (const agent of divisionMap.get(id).agents) selected.set(agent.slug, agent);
+  }
+  if (allAgents) for (const agent of catalog.agents) selected.set(agent.slug, agent);
+  for (const requested of [...new Set(agentIds)]) {
+    const agent = agentMap.get(requested) || nameMap.get(requested.toLowerCase());
+    if (!agent) throw new Error(`unknown agency agent: ${requested}`);
+    selected.set(agent.slug, agent);
+  }
+  return {
+    divisionIds: requestedDivisions,
+    agents: [...selected.values()].sort((a, b) => a.slug.localeCompare(b.slug))
+  };
+}
+
+module.exports = { SUPPORTED_PLATFORMS, parseFrontmatter, readAgencyCatalog, resolveSelection, safeSegment, slugify };

package/multi-agent-workspace/scripts/index_memory.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ZONES = Object.freeze(['state', 'logs', 'decisions', 'domain', 'architecture', 'roles']);
+
+function option(args, name) {
+  const index = args.indexOf(name);
+  return index === -1 ? undefined : args[index + 1];
+}
+
+function buildIndex(root) {
+  const base = path.join(root, '.harness', 'multi-agent');
+  const manifestPath = path.join(base, 'manifest.json');
+  let manifest = {};
+  if (fs.existsSync(manifestPath)) manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  const selected = Array.isArray(manifest.selectedAgents) ? manifest.selectedAgents : [];
+  const lines = [
+    '# Multi-Agent Memory Index',
+    '',
+    'This index is generated from the local multi-agent manifest. Read linked records on demand.',
+    '',
+    '## Zones',
+    ''
+  ];
+  for (const zone of ZONES) lines.push(`- [${zone}](${zone}/)`);
+  lines.push('', '## Selected specialists', '');
+  if (selected.length === 0) {
+    lines.push('- None selected. Do not claim that the external roster is complete.');
+  } else {
+    for (const agent of selected) {
+      lines.push(`- **${agent.name}** (${agent.division}) - \`${agent.slug}\``);
+    }
+  }
+  lines.push('', '## Handoff', '', '- [Structured handoff](handoff.json)', '- [Launcher](launcher.md)');
+  return `${lines.join('\n')}\n`;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const root = path.resolve(option(args, '--root') || '.');
+  const output = path.resolve(option(args, '--output') || path.join(root, '.harness', 'multi-agent', 'memory-index.md'));
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+  fs.writeFileSync(output, buildIndex(root), 'utf8');
+  console.log(`Memory index written to ${output}`);
+}
+
+if (require.main === module) main();
+module.exports = { ZONES, buildIndex };