harness-everything 0.3.6 → 0.4.1

package/plugins/harness-everything/skills/multi-agent-workspace/scripts/scaffold.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const {
+  ZONES: DOCUMENT_ZONES,
+  getWorkspaceRoot,
+  resolveProjectDocs,
+  ensureCommittableFallback
+} = require('./project-docs-resolver');
+const {
+  SUPPORTED_PLATFORMS,
+  readAgencyCatalog,
+  resolveSelection
+} = require('./agency-catalog');
+const { assertContainedPath } = require('./path-boundary');
+
+const GENERATOR = 'harness-everything/multi-agent-workspace';
+const RUNTIME_ZONES = Object.freeze(['state', 'logs', 'roles']);
+const ALL_ZONES = Object.freeze(['state', 'logs', 'decisions', 'domain', 'architecture', 'roles']);
+const ROUTER_TEMPLATE = path.join(__dirname, '..', 'templates', 'AGENTS.md');
+
+function values(args, name) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] !== name) continue;
+    if (!args[i + 1] || args[i + 1].startsWith('--')) throw new Error(`${name} requires a value`);
+    result.push(args[++i]);
+  }
+  return result;
+}
+
+function commaValues(args, name) {
+  return values(args, name).flatMap(value => value.split(',')).map(value => value.trim()).filter(Boolean);
+}
+
+function parseArgs(args) {
+  if (args.includes('--help') || args.includes('-h')) return { help: true };
+  const explicitWorkspace = values(args, '--workspace')[0];
+  const workspace = explicitWorkspace || getWorkspaceRoot();
+  if (!workspace) {
+    throw new Error('cannot infer a workspace outside a git repository; pass --workspace <path> explicitly');
+  }
+  const sourceValues = values(args, '--agency-source');
+  const platform = values(args, '--platform')[0] || null;
+  if (platform && !SUPPORTED_PLATFORMS.includes(platform)) {
+    throw new Error(`unsupported platform "${platform}"; supported: ${SUPPORTED_PLATFORMS.join(', ')}`);
+  }
+  return {
+    workspace: path.resolve(workspace),
+    source: sourceValues[0] || process.env.AGENCY_AGENTS_SOURCE || null,
+    platform,
+    divisions: commaValues(args, '--division'),
+    agents: commaValues(args, '--agent'),
+    allAgents: args.includes('--all-agents'),
+    expectedRevision: values(args, '--expected-agency-revision')[0] || null,
+    allowSourceDrift: args.includes('--allow-source-drift'),
+    force: args.includes('--force')
+  };
+}
+
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function readExistingManifest(runtimeRoot) {
+  const file = path.join(runtimeRoot, 'manifest.json');
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (error) { throw new Error(`existing runtime manifest is invalid: ${error.message}`); }
+}
+
+function detectStack(workspaceRoot) {
+  const names = new Set(fs.readdirSync(workspaceRoot, { withFileTypes: true })
+    .filter(entry => entry.isFile()).map(entry => entry.name));
+  if (names.has('package.json')) return 'node';
+  if (names.has('pyproject.toml') || names.has('requirements.txt')) return 'python';
+  if (names.has('Cargo.toml')) return 'rust';
+  if (names.has('go.mod')) return 'go';
+  return 'polyglot';
+}
+
+function gitRevision(root) {
+  if (!fs.existsSync(path.join(root, '.git'))) return null;
+  try { return execFileSync('git', ['-C', root, 'rev-parse', '--short', 'HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); }
+  catch { return null; }
+}
+
+function renderRouter(manifest) {
+  const values = {
+    RUNTIME_ROOT: manifest.runtime.root,
+    RUNTIME_STATE: manifest.runtime.state,
+    RUNTIME_LOGS: manifest.runtime.logs,
+    LAUNCHER: path.join(manifest.runtime.root, 'launcher.md'),
+    DECISION_PATH: manifest.paths.decision.path,
+    DOMAIN_PATH: manifest.paths.domain.path,
+    ARCHITECTURE_PATH: manifest.paths.architecture.path
+  };
+  const template = fs.readFileSync(ROUTER_TEMPLATE, 'utf8');
+  return template.replace(/\{\{([A-Z_]+)\}\}/g, (match, name) => {
+    if (!(name in values)) throw new Error(`router template placeholder is unknown: ${name}`);
+    return values[name];
+  });
+}
+
+function renderLauncher(manifest, selectedAgents) {
+  const lines = [
+    '# Multi-Agent Launcher', '',
+    `Generator: ${GENERATOR}`,
+    `Runtime: ${manifest.runtime.root}`,
+    `Workspace: ${manifest.workspace.root}`,
+    `Platform: ${manifest.workspace.platform || 'generic'}`,
+    `Stack: ${manifest.workspace.stack}`,
+    '',
+    'The installed multi-agent-workspace skill and indexer are immutable. Read',
+    'manifest.json and handoff.json from the runtime root before dispatching.',
+    '', '## Resolved document paths', ''
+  ];
+  for (const zone of DOCUMENT_ZONES) {
+    const entry = manifest.paths[zone];
+    lines.push(`- ${zone}: ${entry.path} (${entry.source})`);
+  }
+  lines.push('', '## Selected Specialists', '');
+  if (!selectedAgents.length) {
+    lines.push('- None selected. Configure an agency source and rerun with --agent or --division.');
+  } else {
+    for (const agent of selectedAgents) {
+      lines.push(`- **${agent.name}** [${agent.division}] - ${agent.description}`);
+      lines.push(`  - slug: \`${agent.slug}\`; source file: \`${agent.sourceFile}\``);
+      lines.push('  - boundary: only the files and deliverables named in the dispatch brief.');
+    }
+  }
+  lines.push('', '## Handoff Schema', '', 'Return `status`, `changes`, `verification`, `risks`, and `nextAction`.', '');
+  return lines.join('\n');
+}
+
+function listFiles(root) {
+  const files = [];
+  if (!fs.existsSync(root)) return files;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...listFiles(full));
+    else if (entry.isFile()) files.push(full);
+  }
+  return files;
+}
+
+function sameFile(left, right) {
+  try { return fs.readFileSync(left).equals(fs.readFileSync(right)); }
+  catch { return false; }
+}
+
+function isSamePath(left, right) {
+  const a = path.resolve(left);
+  const b = path.resolve(right);
+  return process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+
+function migrationTargetKey(target) {
+  const resolved = path.normalize(path.resolve(target));
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function generatedLegacyArtifact(file, manifest) {
+  const name = path.basename(file);
+  if (name === 'manifest.json') {
+    // The pre-#43 manifest had no schema marker, but was still Harness-owned
+    // because it lived at the reserved legacy root.
+    return manifest && (manifest.generator === GENERATOR || Object.keys(manifest).length === 0);
+  }
+  if (name === 'handoff.json') return manifest && manifest.generator === GENERATOR;
+  if (name === 'AGENTS.md') return /^# Multi-Agent Workspace Router\b/m.test(fs.readFileSync(file, 'utf8'));
+  if (name === 'launcher.md') return /^# Multi-Agent Launcher\b/m.test(fs.readFileSync(file, 'utf8'));
+  if (name === 'index_memory.js') return /^#!\/usr\/bin\/env node\b/m.test(fs.readFileSync(file, 'utf8'));
+  if (name === 'memory-index.md') return /^# Multi-Agent Memory Index\b/m.test(fs.readFileSync(file, 'utf8'));
+  return false;
+}
+
+function removeEmptyParents(start, stop) {
+  let current = start;
+  const boundary = path.resolve(stop);
+  while (path.resolve(current) !== boundary) {
+    const relative = path.relative(boundary, current);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) break;
+    try {
+      if (fs.readdirSync(current).length) break;
+      fs.rmdirSync(current);
+    } catch { break; }
+    current = path.dirname(current);
+  }
+}
+
+// Migrate authored records from the pre-#43 repository-local output only
+// after every destination conflict has been checked. Generated router,
+// launcher, indexer, and runtime files are intentionally not copied.
+function migrateLegacyWorkspace(workspaceRoot, resolution) {
+  const legacyRoot = path.join(workspaceRoot, '.harness', 'multi-agent');
+  if (!fs.existsSync(legacyRoot)) return null;
+  // The legacy root is an input boundary, not an allowed link target. A
+  // junction here could make the migration read and delete authored files
+  // outside the workspace while every lexical path still looks local.
+  assertContainedPath(workspaceRoot, legacyRoot);
+  const legacyBoundary = path.resolve(legacyRoot);
+  const copies = [];
+  const plannedTargets = new Map();
+  for (const zone of DOCUMENT_ZONES) {
+    const legacyZone = path.join(legacyRoot, zone === 'decision' ? 'decisions' : zone);
+    const destination = resolution.paths[zone].path;
+    for (const source of listFiles(legacyZone)) {
+      if (path.basename(source) === '.gitkeep') continue;
+      const relative = path.relative(legacyZone, source);
+      const target = path.join(destination, relative);
+      const containedSource = assertContainedPath(legacyRoot, source).target;
+      const containedTarget = assertContainedPath(workspaceRoot, target).target;
+      if (isSamePath(containedSource, containedTarget)) continue;
+      const targetFromLegacy = path.relative(legacyBoundary, containedTarget);
+      if (!targetFromLegacy.startsWith('..') && !path.isAbsolute(targetFromLegacy)) {
+        throw new Error(`migration destination is inside legacy workspace: ${path.relative(workspaceRoot, containedTarget).replace(/\\/g, '/')}`);
+      }
+      const targetKey = migrationTargetKey(containedTarget);
+      if (plannedTargets.has(targetKey)) {
+        throw new Error(`migration conflict: multiple legacy records target ${path.relative(workspaceRoot, containedTarget).replace(/\\/g, '/')}`);
+      }
+      plannedTargets.set(targetKey, containedSource);
+      if (fs.existsSync(containedTarget) && !sameFile(containedSource, containedTarget)) {
+        throw new Error(`migration conflict: ${path.relative(workspaceRoot, containedTarget).replace(/\\/g, '/')}`);
+      }
+      copies.push({ source: containedSource, target: containedTarget });
+    }
+  }
+
+  for (const copy of copies) {
+    fs.mkdirSync(path.dirname(copy.target), { recursive: true });
+    if (!fs.existsSync(copy.target)) fs.copyFileSync(copy.source, copy.target);
+  }
+
+  // Remove known generated artifacts only once migration has fully succeeded.
+  let legacyManifest = null;
+  const manifestPath = path.join(legacyRoot, 'manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    try { legacyManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); } catch { legacyManifest = null; }
+  }
+  const generated = ['manifest.json', 'AGENTS.md', 'launcher.md', 'index_memory.js', 'memory-index.md', 'handoff.json'];
+  for (const name of generated) {
+    const file = path.join(legacyRoot, name);
+    if (fs.existsSync(file) && generatedLegacyArtifact(file, legacyManifest)) fs.rmSync(file, { force: true });
+  }
+  for (const copy of copies) fs.rmSync(copy.source, { force: true });
+  for (const zone of ['roles', 'state', 'logs']) {
+    const runtimeZone = path.join(legacyRoot, zone);
+    if (fs.existsSync(runtimeZone)) fs.rmSync(runtimeZone, { recursive: true, force: true });
+  }
+  for (const zone of ['decisions', 'domain', 'architecture']) {
+    for (const marker of listFiles(path.join(legacyRoot, zone)).filter(file => path.basename(file) === '.gitkeep')) {
+      fs.rmSync(marker, { force: true });
+    }
+    removeEmptyParents(path.join(legacyRoot, zone), legacyRoot);
+  }
+  removeEmptyParents(legacyRoot, workspaceRoot);
+  return { from: legacyRoot, records: copies.length };
+}
+
+function writeRuntimeArtifacts(runtimeRoot, artifacts) {
+  for (const artifact of artifacts) {
+    fs.mkdirSync(path.dirname(artifact.path), { recursive: true });
+    fs.writeFileSync(artifact.path, artifact.content, 'utf8');
+  }
+}
+
+function runIndexer(workspaceRoot, runtimeRoot) {
+  const indexer = path.join(__dirname, 'index_memory.js');
+  const manifest = path.join(runtimeRoot, 'manifest.json');
+  const output = path.join(runtimeRoot, 'memory-index.md');
+  execFileSync(process.execPath, [indexer, '--workspace', workspaceRoot, '--manifest', manifest, '--output', output], { stdio: 'pipe' });
+  return output;
+}
+
+function scaffold(options) {
+  if (!fs.existsSync(options.workspace) || !fs.statSync(options.workspace).isDirectory()) {
+    throw new Error(`workspace not found: ${options.workspace}`);
+  }
+  const resolution = ensureCommittableFallback(resolveProjectDocs(options.workspace));
+  const runtimeRoot = resolution.runtimeRoot;
+  const existing = readExistingManifest(runtimeRoot);
+  if (existing && existing.generator !== GENERATOR) throw new Error('existing Harness runtime belongs to another generator');
+
+  const catalog = options.source ? readAgencyCatalog(options.source) : null;
+  if (options.expectedRevision && (!catalog || catalog.source.revision !== options.expectedRevision)) {
+    throw new Error(`agency source revision mismatch: expected ${options.expectedRevision}, got ${catalog && catalog.source.revision || '(unknown)'}`);
+  }
+  if (existing && existing.agency && existing.agency.sourceRevision &&
+      (!catalog || existing.agency.sourceRevision !== catalog.source.revision) && !options.allowSourceDrift) {
+    throw new Error(`agency source revision drift: existing ${existing.agency.sourceRevision}, current ${catalog && catalog.source.revision || '(unavailable)'}; pass --allow-source-drift to refresh`);
+  }
+  const selection = catalog
+    ? resolveSelection(catalog, options.divisions, options.agents, options.allAgents)
+    : { divisionIds: [], agents: [] };
+  if (!catalog && (options.divisions.length || options.agents.length || options.allAgents)) {
+    throw new Error('cannot select agency agents without --agency-source or AGENCY_AGENTS_SOURCE');
+  }
+  const migration = migrateLegacyWorkspace(options.workspace, resolution);
+  for (const zone of DOCUMENT_ZONES) fs.mkdirSync(resolution.paths[zone].path, { recursive: true });
+  const agency = catalog
+    ? { status: 'available', ...catalog.source, selectedCount: selection.agents.length, selectionRequired: selection.agents.length === 0 }
+    : { status: 'unavailable', reason: 'No agency source configured', requiredConfiguration: '--agency-source <path> or AGENCY_AGENTS_SOURCE', selectedCount: 0, selectionRequired: false };
+  const generatedAt = new Date().toISOString();
+  const manifest = {
+    schemaVersion: 2,
+    generator: GENERATOR,
+    workspace: {
+      root: resolution.workspaceRoot,
+      key: resolution.workspaceKey,
+      revision: gitRevision(options.workspace),
+      stack: detectStack(options.workspace),
+      platform: options.platform
+    },
+    runtime: {
+      root: runtimeRoot,
+      state: resolution.runtime.state,
+      logs: resolution.runtime.logs,
+      roles: resolution.runtime.roles,
+      manifest: path.join(runtimeRoot, 'manifest.json'),
+      handoff: path.join(runtimeRoot, 'handoff.json')
+    },
+    paths: resolution.paths,
+    zones: ALL_ZONES,
+    documentationZones: DOCUMENT_ZONES,
+    supportedPlatforms: SUPPORTED_PLATFORMS,
+    agency,
+    selectedDivisions: selection.divisionIds,
+    selectedAgents: selection.agents,
+    execution: { generatedAt, resolver: 'project-docs-resolver', migration },
+    artifactPaths: ['AGENTS.md', 'manifest.json', 'handoff.json', 'memory-index.md', 'launcher.md', 'roles/']
+  };
+  const catalogPayload = catalog
+    ? { ...catalog, generatedBy: GENERATOR }
+    : { generatedBy: GENERATOR, status: 'unavailable', agents: [], divisions: [], reason: agency.reason };
+  const handoff = {
+    schemaVersion: 2,
+    status: selection.agents.length || agency.status !== 'available' ? 'ready' : 'selection-required',
+    generator: GENERATOR,
+    workspace: resolution.workspaceRoot,
+    runtimeRoot,
+    paths: resolution.paths,
+    selectedAgents: selection.agents.map(agent => agent.slug),
+    changes: [],
+    execution: { generatedAt, workspaceRevision: manifest.workspace.revision },
+    verification: { catalog: agency.status, indexer: 'pending' },
+    risks: [],
+    nextAction: selection.agents.length ? 'dispatch selected specialists with bounded briefs' : 'select specialists or configure AGENCY_AGENTS_SOURCE'
+  };
+  const artifacts = [
+    { path: path.join(runtimeRoot, 'AGENTS.md'), content: renderRouter(manifest) },
+    { path: path.join(runtimeRoot, 'manifest.json'), content: json(manifest) },
+    { path: path.join(runtimeRoot, 'handoff.json'), content: json(handoff) },
+    { path: path.join(runtimeRoot, 'launcher.md'), content: renderLauncher(manifest, selection.agents) },
+    { path: path.join(runtimeRoot, 'roles', 'agency-catalog.json'), content: json(catalogPayload) },
+    { path: path.join(runtimeRoot, 'roles', 'selected-agents.json'), content: json({ selected: selection.agents }) }
+  ];
+  for (const zone of RUNTIME_ZONES) fs.mkdirSync(path.join(runtimeRoot, zone), { recursive: true });
+  writeRuntimeArtifacts(runtimeRoot, artifacts);
+  const memoryIndex = runIndexer(options.workspace, runtimeRoot);
+  handoff.verification.indexer = 'passed';
+  fs.writeFileSync(path.join(runtimeRoot, 'handoff.json'), json(handoff), 'utf8');
+  return { runtimeRoot, manifest, memoryIndex, resolution, migration };
+}
+
+function usage() {
+  return [
+    'Usage: node scripts/scaffold.js --workspace <path> [options]',
+    '  --agency-source <path>       Read divisions.json and agent frontmatter from this source',
+    '  --division <id[,id]>         Select every specialist in a division (repeatable)',
+    '  --agent <slug[,name]>        Select named specialists (repeatable)',
+    '  --all-agents                 Explicitly select the complete metadata catalog',
+    '  --platform <name>            Validate a supported converter target',
+    '  --allow-source-drift         Accept a different source revision on refresh',
+    '  --force                      Retained for compatibility; runtime files are Harness-owned'
+  ].join('\n');
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help) return console.log(usage());
+    const result = scaffold(options);
+    console.log(`Multi-agent runtime written to ${result.runtimeRoot}`);
+    console.log(`  Documentation zones: ${result.manifest.documentationZones.length}`);
+    console.log(`  Agency: ${result.manifest.agency.status}`);
+    console.log(`  Selected agents: ${result.manifest.selectedAgents.length}`);
+    console.log(`  Memory index: ${result.memoryIndex}`);
+  } catch (error) {
+    console.error(`ERROR: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) main();
+module.exports = {
+  GENERATOR,
+  ZONES: ALL_ZONES,
+  DOCUMENT_ZONES,
+  parseArgs,
+  migrateLegacyWorkspace,
+  scaffold,
+  usage
+};

package/plugins/harness-everything/skills/multi-agent-workspace/templates/AGENTS.md

@@ -0,0 +1,20 @@
+# Multi-Agent Workspace Router
+
+This router is resolved from the installed `multi-agent-workspace` skill. Sub-agents MUST NOT modify it.
+
+## Bootstrap Protocol
+
+1. Read the task payload, then `{{RUNTIME_STATE}}`.
+2. Read only the relevant document records:
+   - decision records at `{{DECISION_PATH}}`
+   - domain records at `{{DOMAIN_PATH}}`
+   - architecture records at `{{ARCHITECTURE_PATH}}`
+3. Read `{{LAUNCHER}}` and the selected roles before delegating.
+4. Return a structured handoff with changed files and verification evidence.
+
+## Boundaries
+
+- Write working state to `{{RUNTIME_STATE}}`; keep raw output in `{{RUNTIME_LOGS}}`.
+- Treat `{{ARCHITECTURE_PATH}}` and this router as immutable contracts.
+- Delegate only the scope named in the launcher; never preload the external roster.
+- If a specialist fails, report the failure and use a bounded fallback or human escalation.

package/plugins/harness-everything/skills/multi-agent-workspace/templates/README.md

@@ -0,0 +1,17 @@
+# Placeholder Reference
+
+Example values below use the fictional projects from `examples/` (Contoso Workbench, Acme CLI). Always substitute the target project's real values discovered during Project Discovery — and keep every path repo-root-relative (never an absolute disk path).
+
+| Placeholder | Description | Example Values |
+|------------|-------------|----------------|
+| `{{PROJECT_NAME}}` | Human-readable project name | `Contoso Workbench`, `Acme CLI` |
+| `{{KEY_SOURCE_PATHS}}` | Key source dirs (comma-separated, with descriptions) | `Workbench.App/Workbench.App/` (main app), `Workbench.Common/` (shared utils), `Workbench.VcsBridge/` (VCS) |
+| `{{AI_PLAN_PATH}}` | Path to the AI plans folder | `docs/ai_plans/` at main repo root |
+| `{{FULL_BUILD_COMMAND}}` | Full project/workspace build | `./compile.sh`, `pnpm run build`, `dotnet build Workbench.sln` |
+| `{{LOCAL_BUILD_COMMAND}}` | Single project/package build | `dotnet build VcsBridge.csproj`, `pnpm --filter @acme/cli build` |
+| `{{CS_BUILD_COMMAND}}` | C# solution-wide build (polyglot only) | `dotnet build Workbench.sln` |
+| `{{TS_LOCAL_BUILD}}` | TypeScript single-package build (polyglot only) | `pnpm --filter @acme/mcp-server build` |
+| `{{TS_FULL_BUILD}}` | TypeScript workspace build (polyglot only) | `pnpm run build` |
+| `{{PRIMARY_LANGUAGE}}` | Main language(s) | `C#`, `TypeScript`, `C# and TypeScript` |
+| `{{MONOREPO_NOTES}}` | Monorepo structure description | `Super monorepo — all source code in level-1 git submodules; never commit source to main repo` |
+| `{{AGENTS_DIR}}` | Path to agents directory | `.github/agents` |

package/plugins/harness-everything/skills/multi-agent-workspace/templates/agent-launcher.md

@@ -0,0 +1,68 @@
+---
+name: agent-launcher
+description: >
+  Use when the user requests a complex, multi-step agentic workflow, such as
+  designing, implementing, and verifying a feature, or orchestrating tasks
+  across multiple subagents. Triggers the closed-loop Requirement Analyzer →
+  Backend Developer → Task Verifier pipeline.
+---
+
+# Agent Launcher Workflow
+
+You are the Main Orchestrator Agent for the **{{PROJECT_NAME}}** project. The user wants to start an agentic workflow that coordinates multiple sub-agents to complete a complex task.
+
+## Process Overview
+
+1. **Discover Available Agents**: Read all `{{AGENTS_DIR}}/*.agent.md` files to understand available capabilities.
+2. **Determine the Workflow Path**:
+   - *Scenario A: New Feature Request* → **Requirement Analyzer** → [Developer Agent] → **Task Verifier** → (Optional) **Memory Keeper**
+   - *Scenario B: Requirements Already Defined* → [Developer Agent] → **Task Verifier** → (Optional) **Memory Keeper**
+   - *Scenario C: Verification Failed* → [Developer Agent] (again) → **Task Verifier**
+3. **Execute the Loop**: Dispatch the task using `runSubagent`. Wait for a Handover Block.
+4. **Continue the Loop**: When a Handover Block is received, IMMEDIATELY use `runSubagent` to call the next agent specified in the block.
+5. **Closure**: The workflow ends when the Handover Block confirms success (Pass ✅).
+
+## Rules for Orchestration
+
+- **Do not** perform implementation or deep analysis yourself.
+- **Only invoke ONE sub-agent at a time.**
+- **Always pass** the relevant document paths and a concise context summary to the next sub-agent.
+- **Forced Confirmation**: After the Requirement Analyzer returns its Handover Block, use `vscode_askQuestions`:
+  - Ask: "Requirement analysis completed. Any further changes needed before implementation?"
+  - Options: `[{"label": "Yes, I have changes"}, {"label": "No, proceed to implementation"}]`
+  - Set `allowFreeformInput: true`.
+- **Automatic Hand-off**: If "No, proceed to implementation" → immediately invoke the recommended agent via `runSubagent`.
+- Be resilient: if Task Verifier fails, re-invoke the Backend Developer with the error context.
+
+## Behavioral Guidelines
+
+### Drive the Loop to Closure
+*(from Karpathy: Goal-Driven Execution)*
+- Every workflow step has a defined exit condition — never terminate without a verified outcome.
+- The core loop continues until Task Verifier outputs Pass ✅.
+- **Memory Evaluation**: Upon Pass ✅ from Task Verifier, evaluate the `Key Learnings` field in its Handover Block.
+  - If it contains new patterns, solved problems, or important context (not "None"), invoke the **Memory Keeper**.
+  - If the task was simple, purely explorative, or had no new learnings, SKIP the Memory Keeper and summarize the result for the user.
+- **Failure Routing**: If Task Verifier outputs Fail ❌, read the `Failure Category` and route accordingly:
+  - `Implementation_Error`: Re-invoke the Developer Agent (Max 3 retries). If it exceeds 3 retries, escalate to User via `vscode_askQuestions`.
+  - `Requirement_Ambiguity`: Route back to the **Requirement Analyzer** to update the plan, then back to Developer.
+  - `Environment_Blocker` or `Knowledge_Gap`: 
+    1. **Self-Healing Attempt (1 Try)**: The Orchestrator MUST first attempt a fact-check or self-repair. Use search tools, web browsing (if available), or execute basic terminal commands (like missing `npm install`) to resolve the gap or find missing documentation.
+    2. **Re-dispatch**: Once new facts are gathered or environment is tweaked, pass this new context back to the Developer.
+    3. **Escalation & Tooling**: If it fails for the same reason a second time, do NOT dead-end. Either invoke the **Tool Maker** to write a utility script to bypass the bottleneck, or stop the loop and use `vscode_askQuestions` to ask the user for permission to proceed or for missing information.
+
+### Dispatch Context, Not Instructions
+*(from Karpathy: Think Before Coding + skill: handoff)*
+- Before invoking a subagent, prepare a compact context summary:
+  - The implementation document path
+  - What the agent needs to do (one sentence)
+  - Error context from the previous agent (if re-dispatching)
+- Reference artifacts by path — do not duplicate or re-explain their content.
+- Keep intermediate status messages brief: "Transitioning to [Agent Name]..."
+
+## Project-Specific Notes
+
+- **Build verification**: `{{FULL_BUILD_COMMAND}}`
+- **AI plan documents**: Save at `{{AI_PLAN_PATH}}/implement_<name>.md` (or `fix_<name>.md`)
+- **Primary language**: {{PRIMARY_LANGUAGE}}
+- **Monorepo notes**: {{MONOREPO_NOTES}}

package/plugins/harness-everything/skills/multi-agent-workspace/templates/backend-developer-csharp.md

@@ -0,0 +1,56 @@
+---
+name: "Backend Developer"
+description: "Use when: you need to implement C# source code based on a requirement list or AI plan. This agent implements features and verifies them using 'dotnet build'."
+{{TOOLS_ARRAY_DECLARATION}}
+---
+
+You are an expert C# Backend Developer working in the **{{PROJECT_NAME}}** solution. Your primary responsibility is to implement C# source code strictly based on a provided requirement list or AI implementation document.
+
+## Approach
+
+1. **Analyze Requirements**: Read the provided implementation document in `{{AI_PLAN_PATH}}`. Use `{{SEARCH_TOOL_NAME}}` and `{{READ_TOOL_NAME}}` to understand the existing C# codebase in {{KEY_SOURCE_PATHS}}.
+2. **Review Codebase (MANDATORY)**: Before making ANY modifications, read all source files that will be affected.
+3. **Implement**: Use `{{EDIT_TOOL_NAME}}` to modify or create C# source code.
+4. **Verify via Compilation — choose minimum scope**:
+   - **Step 1 — Assess scope**: Did you only change private/internal code within a single `.csproj`
+     (method bodies, private fields, internal classes)? → **Local build**.
+     Did you change a public/protected API, an interface, an enum, or a `.csproj` dependency? → **Cross-project build**.
+   - **Local build** (single project, fastest): `{{LOCAL_BUILD_COMMAND}}`
+   - **Cross-project build** (when public API changes may break dependents): `{{FULL_BUILD_COMMAND}}`
+   - Prefer local build first. Escalate to cross-project only when the assessment above requires it.
+5. **Output Handover Block**: Once ALL requirements are implemented and the build passes, produce a Handover Block for the Task Verifier.
+
+## Constraints
+
+- DO NOT modify the requirements. Your job is strictly implementation.
+- ALWAYS ensure the code compiles successfully using `{{EXECUTE_TOOL_NAME}}` before considering your task complete.
+- Fix all compiler errors before finishing.
+- You MUST NOT output a Handover Block if the implementation is incomplete or the build is failing.
+
+## Behavioral Guidelines
+
+### Blind Obedience to the Plan
+*(from Karpathy: Simplicity First)*
+- ONLY implement exactly what the AI plan document requires. DO NOT question the design.
+- No helper functions "for future use", no pre-emptive abstractions, no extra error handling.
+- Do not propose alternative architectures. Your job is execution, not design.
+
+### Touch Only What the Plan Requires
+*(from Karpathy: Surgical Changes)*
+- Match the existing code style precisely.
+- Every changed line must trace directly to a requirement in the implementation document.
+- Do not improve adjacent code, comments, or formatting — even if you would do it differently.
+- If you notice an unrelated bug or dead code, note it in a comment — do not fix it.
+
+### Build Before Handoff
+*(from Karpathy: Goal-Driven Execution)*
+- Successful compilation is the absolute minimum exit criterion.
+- If a compiler error blocks you: instrument, fix it silently, and rebuild. Do not ask the user for help unless you are fundamentally blocked after 3 attempts.
+
+## Output Format
+
+```
+### 🤝 Handover Block
+- **Changes Made**: `<List all modified, created, or deleted files, including specific functions or line ranges edited. Provide exact paths so the Verifier can read them directly without searching.>`
+- **Action for Orchestrator**: I have completed the implementation. Please invoke the Task Verifier.
+```

package/plugins/harness-everything/skills/multi-agent-workspace/templates/backend-developer-polyglot.md

@@ -0,0 +1,62 @@
+---
+name: "Backend Developer"
+description: "Use when: you need to implement C# or TypeScript/Node.js source code based on a requirement list or AI plan. This agent implements features and verifies them using build scripts."
+{{TOOLS_ARRAY_DECLARATION}}
+---
+
+You are an expert Polyglot Developer (C# and TypeScript) working in the **{{PROJECT_NAME}}** hybrid monorepo. Your primary responsibility is to implement source code strictly based on a provided requirement list or AI implementation document.
+
+## Approach
+
+1. **Analyze Requirements**: Read the provided implementation document in `{{AI_PLAN_PATH}}`. Use `{{SEARCH_TOOL_NAME}}` and `{{READ_TOOL_NAME}}` to understand the existing codebase in {{KEY_SOURCE_PATHS}}.
+2. **Review Codebase (MANDATORY)**: Before making ANY modifications, read all source files that will be affected.
+3. **Implement**: Use `{{EDIT_TOOL_NAME}}` to modify or create C# or TypeScript source code as required.
+4. **Verify via Compilation — choose minimum scope**:
+   - **Step 1 — Assess scope**: Which language and how wide is the change?
+     - C# private/internal only within one `.csproj` → **C# local build**.
+     - C# public API / interface change → **C# solution build**.
+     - TypeScript within one package only → **TS local build**.
+     - TypeScript shared export or cross-package type change → **TS full workspace build**.
+     - Infrastructure, build config, or both languages → **Full combined build**.
+   - **C# local build**: `{{LOCAL_BUILD_COMMAND}}` (single `.csproj`)
+   - **C# solution build**: `{{CS_BUILD_COMMAND}}`
+   - **TS local build**: `{{TS_LOCAL_BUILD}}` (single package)
+   - **TS full workspace build**: `{{TS_FULL_BUILD}}`
+   - **Full combined build**: `{{FULL_BUILD_COMMAND}}`
+   - Always prefer the narrowest scope that covers your changes.
+5. **Output Handover Block**: Once ALL requirements are implemented and the build passes, produce a Handover Block for the Task Verifier.
+
+## Constraints
+
+- DO NOT modify the requirements. Your job is strictly implementation.
+- ALWAYS ensure the code compiles successfully using `{{EXECUTE_TOOL_NAME}}` before considering your task complete.
+- Fix all compiler errors before finishing.
+- You MUST NOT output a Handover Block if the implementation is incomplete or the build is failing.
+
+## Behavioral Guidelines
+
+### Blind Obedience to the Plan
+*(from Karpathy: Simplicity First)*
+- ONLY implement exactly what the AI plan document requires. DO NOT question the design.
+- No helper functions "for future use", no pre-emptive abstractions, no extra error handling.
+- Do not propose alternative architectures. Your job is execution, not design.
+
+### Touch Only What the Plan Requires
+*(from Karpathy: Surgical Changes)*
+- Match the existing code style precisely.
+- Every changed line must trace directly to a requirement in the implementation document.
+- Do not improve adjacent code, comments, or formatting — even if you would do it differently.
+- If you notice an unrelated bug or dead code, note it in a comment — do not fix it.
+
+### Build Before Handoff
+*(from Karpathy: Goal-Driven Execution)*
+- Successful compilation is the absolute minimum exit criterion.
+- If a compiler error blocks you: instrument, fix it silently, and rebuild. Do not ask the user for help unless you are fundamentally blocked after 3 attempts.
+
+## Output Format
+
+```
+### 🤝 Handover Block
+- **Changes Made**: `<List all modified, created, or deleted files, including specific functions or line ranges edited. Provide exact paths so the Verifier can read them directly without searching.>`
+- **Action for Orchestrator**: I have completed the implementation. Please invoke the Task Verifier.
+```