agy-squad 0.1.0 → 0.1.1

package/mcp/dispatch.mjs

@@ -12,16 +12,26 @@ const defaultManifests = [
   "suite-manifest.json"
 ];
 
-function assertWithinWorkspace(root, file) {
+function isWithinWorkspace(root, file) {
   const relative = path.relative(root, file);
-  if (relative === ".." || relative.startsWith(".." + path.sep) || path.isAbsolute(relative)) {
+  return !(relative === ".." || relative.startsWith(".." + path.sep) || path.isAbsolute(relative));
+}
+
+function assertWithinWorkspace(root, file) {
+  if (!isWithinWorkspace(root, file)) {
     throw new Error("Manifest path must stay inside the workspace.");
   }
 }
 
-function readManifest(root, filename) {
+function readManifest(root, filename, logicalRoot = root) {
   const candidate = path.resolve(root, filename);
-  assertWithinWorkspace(root, candidate);
+  if (path.isAbsolute(filename)) {
+    if (!isWithinWorkspace(root, candidate) && !isWithinWorkspace(logicalRoot, candidate)) {
+      throw new Error("Manifest path must stay inside the workspace.");
+    }
+  } else {
+    assertWithinWorkspace(root, candidate);
+  }
   const file = fs.realpathSync(candidate);
   assertWithinWorkspace(root, file);
   const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
@@ -129,20 +139,22 @@ function resolveIntegrityAuditor(squads, targetSquad) {
   ];
 }
 
-function loadSquads(root, manifestPath) {
+function loadSquads(root, manifestPath, logicalRoot = root) {
   if (manifestPath !== undefined) {
-    return readManifest(root, manifestPath);
+    return readManifest(root, manifestPath.trim(), logicalRoot);
   }
 
   let firstError;
   for (const candidate of defaultManifests) {
     try {
-      return readManifest(root, candidate);
+      return readManifest(root, candidate, logicalRoot);
     } catch (error) {
       if (error.code !== "ENOENT") firstError ??= error;
     }
   }
-  throw firstError ?? new Error("No squad manifest found. Pass a workspace-relative manifestPath.");
+  const notFound = new Error("No squad manifest found. Pass a workspace-relative manifestPath.");
+  notFound.code = "ENOENT";
+  throw firstError ?? notFound;
 }
 
 const inlineLeadKeys = [
@@ -203,21 +215,65 @@ function specialistAssignments(squads, squadId) {
   return specialists.map((spec, index) => ({ spec, id: squadId, number: index + 1 }));
 }
 
-function handleDispatchSquad(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE || process.cwd()) {
+const ALLOWED_DISPATCH_KEYS = new Set(["squadId", "manifestPath", "workspace"]);
+
+function resolveCandidateWorkspace(argsWorkspace, fallbackWorkspace) {
+  if (argsWorkspace !== undefined && (typeof argsWorkspace !== "string" || !argsWorkspace.trim())) {
+    throw new Error("workspace must be a non-empty string.");
+  }
+  const candidate = argsWorkspace !== undefined
+    ? argsWorkspace.trim()
+    : typeof fallbackWorkspace === "string" && fallbackWorkspace.trim()
+      ? fallbackWorkspace.trim()
+      : "";
+  if (!candidate) {
+    throw new Error("workspace must be a non-empty string.");
+  }
+  return candidate;
+}
+
+function logicalWorkspaceRoot(argsWorkspace, fallbackWorkspace) {
+  return path.resolve(resolveCandidateWorkspace(argsWorkspace, fallbackWorkspace));
+}
+
+function resolveWorkspaceRoot(argsWorkspace, fallbackWorkspace) {
+  const candidate = resolveCandidateWorkspace(argsWorkspace, fallbackWorkspace);
+  const root = fs.realpathSync(candidate);
+  if (!fs.statSync(root).isDirectory()) {
+    throw new Error(`Workspace path must be a directory: '${candidate}'.`);
+  }
+  return root;
+}
+
+function formatNotFoundError(args, fallbackWorkspace) {
+  const fallback = typeof fallbackWorkspace === "string" && fallbackWorkspace.trim()
+    ? fallbackWorkspace.trim()
+    : process.cwd();
+  const attemptedWorkspace =
+    typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : fallback;
+  const manifestDetail =
+    typeof args?.manifestPath === "string" && args.manifestPath.trim()
+      ? `, manifestPath: '${args.manifestPath.trim()}'`
+      : "";
+  return `Manifest or workspace not found (workspace: '${attemptedWorkspace}'${manifestDetail}). Pass 'workspace' set to your active repository root, set AGY_SQUAD_WORKSPACE, or run 'node bin/agy-squad.mjs' from the repository root.`;
+}
+
+function handleDispatchSquad(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE?.trim() || process.cwd()) {
   try {
     if (!args || typeof args !== "object" || Array.isArray(args) ||
-        Object.keys(args).some(key => key !== "squadId" && key !== "manifestPath")) {
-      throw new Error("Only squadId and manifestPath are supported.");
+        Object.keys(args).some(key => !ALLOWED_DISPATCH_KEYS.has(key))) {
+      throw new Error("Only squadId, manifestPath, and workspace are supported.");
     }
-    const { squadId, manifestPath } = args;
+    const { squadId, manifestPath, workspace: argWorkspace } = args;
     if (typeof squadId !== "string" || !squadId.trim()) {
       throw new Error("Provide a squadId or use all_l1 for the leads.");
     }
     if (manifestPath !== undefined && (typeof manifestPath !== "string" || !manifestPath.trim())) {
       throw new Error("manifestPath must be a nonempty string.");
     }
-    const root = fs.realpathSync(workspace);
-    const { squads: loadedSquads, selectedManifest } = loadSquads(root, manifestPath);
+    const root = resolveWorkspaceRoot(argWorkspace, workspace);
+    const logicalRoot = logicalWorkspaceRoot(argWorkspace, workspace);
+    const { squads: loadedSquads, selectedManifest } = loadSquads(root, manifestPath, logicalRoot);
     const squads = { ...loadedSquads };
     const isIntegrityAuditor = squadId === "integrity_auditor" || squadId.startsWith("integrity_auditor:");
     const hasTargetColon = isIntegrityAuditor && squadId.includes(":");
@@ -234,8 +290,12 @@ function handleDispatchSquad(args = {}, workspace = process.env.AGY_SQUAD_WORKSP
       throw new Error(`Unknown targetSquad '${flatTarget}'.`);
     }
 
+    const delegateWorkspace = argWorkspace !== undefined ? root : undefined;
     const build = ({ spec, id, number }) =>
-      buildSubagentSpec(spec, id, selectedManifest, number, undefined, { isIntegrityAuditor });
+      buildSubagentSpec(spec, id, selectedManifest, number, undefined, {
+        isIntegrityAuditor,
+        workspace: delegateWorkspace
+      });
     let assignments;
     if (squadId === "all_l1") {
       const workingSquads = Object.entries(squads).filter(
@@ -263,18 +323,21 @@ function handleDispatchSquad(args = {}, workspace = process.env.AGY_SQUAD_WORKSP
       content: [{ type: "text", text: JSON.stringify({ Subagents }, null, 2) }]
     };
   } catch (error) {
-    const message = error.code === "ENOENT" ? "Manifest or workspace not found." : error.message;
+    const message = error.code === "ENOENT" ? formatNotFoundError(args, workspace) : error.message;
     return { isError: true, content: [{ type: "text", text: `dispatch_squad: ${message}` }] };
   }
 }
 
 export {
   assertWithinWorkspace,
+  formatNotFoundError,
   handleDispatchSquad,
   loadSquads,
+  logicalWorkspaceRoot,
   manifestSquads,
   readManifest,
   resolveIntegrityAuditor,
   resolveSquadLead,
+  resolveWorkspaceRoot,
   specialistAssignments
 };

package/mcp/index.js

@@ -12,6 +12,38 @@ const isEntryPoint = Boolean(process.argv[1] && realOrSelf(process.argv[1]) ===
 const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 
 const SERVER_NAME = "agy-squad";
+let sessionWorkspace;
+
+function workspaceFromInitializeParams(params) {
+  if (!params || typeof params !== "object") return undefined;
+  const candidates = [
+    ...(Array.isArray(params.workspaceFolders) ? params.workspaceFolders.map((folder) => folder?.uri) : []),
+    params.rootUri
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string") continue;
+    const trimmed = candidate.trim();
+    if (!/^file:\/\//i.test(trimmed)) continue;
+    try {
+      const parsedUrl = new URL(trimmed);
+      if (!parsedUrl.pathname || parsedUrl.pathname === "/") continue;
+      return fileURLToPath(parsedUrl);
+    } catch {
+      continue;
+    }
+  }
+  if (typeof params.rootPath === "string" && params.rootPath.trim()) {
+    return params.rootPath.trim();
+  }
+  return undefined;
+}
+
+const WORKSPACE_SCHEMA = {
+  type: "string",
+  minLength: 1,
+  description: "Active repository directory path (overrides initialize roots, AGY_SQUAD_WORKSPACE, and cwd)."
+};
+
 const TOOLS = [
   {
     name: "dispatch_squad",
@@ -20,7 +52,8 @@ const TOOLS = [
       type: "object",
       properties: {
         squadId: { type: "string", minLength: 1, description: "'all_l1', 'integrity_auditor[:<target>]', or squad ID." },
-        manifestPath: { type: "string", minLength: 1, description: "Workspace-relative manifest path." }
+        manifestPath: { type: "string", minLength: 1, description: "Workspace-relative manifest path." },
+        workspace: WORKSPACE_SCHEMA
       },
       required: ["squadId"],
       additionalProperties: false
@@ -40,6 +73,7 @@ const TOOLS = [
           required: ["squads"]
         },
         task: { type: "string", minLength: 1, description: "Freeform task (exclusive with manifestPath/manifest)." },
+        workspace: WORKSPACE_SCHEMA,
         squadId: { type: "string", minLength: 1, description: "Optional working squad filter (never 'all_l1')." },
         topology: { type: "string", enum: ["flat", "layered"], description: "Force flat (no leads) or layered (require leads) topology." },
         executionMode: { type: "string", enum: ["swarm", "subagent"], description: "Execution plane (default: swarm)." },
@@ -88,6 +122,7 @@ async function handleRequest(request) {
   }
 
   if (method === "initialize") {
+    sessionWorkspace = workspaceFromInitializeParams(params);
     return {
       jsonrpc: "2.0",
       id,
@@ -112,11 +147,13 @@ async function handleRequest(request) {
       return { jsonrpc: "2.0", id, error: { code: -32602, message: "Invalid params" } };
     }
     const { name, arguments: args = {} } = params;
+    const envWorkspace = process.env.AGY_SQUAD_WORKSPACE?.trim();
+    const defaultWorkspace = sessionWorkspace || envWorkspace || process.cwd();
     if (name === "dispatch_squad") {
-      return { jsonrpc: "2.0", id, result: handleDispatchSquad(args) };
+      return { jsonrpc: "2.0", id, result: handleDispatchSquad(args, defaultWorkspace) };
     }
     if (name === "squad_planner") {
-      return { jsonrpc: "2.0", id, result: handleSquadPlanner(args) };
+      return { jsonrpc: "2.0", id, result: handleSquadPlanner(args, defaultWorkspace) };
     }
     return { jsonrpc: "2.0", id, error: { code: -32602, message: `Unknown tool: ${name}` } };
   }

package/mcp/planner.mjs

@@ -2,10 +2,13 @@ import fs from "node:fs";
 import path from "node:path";
 import { SUBAGENT_MODEL_ALIASES, buildSubagentSpec, validateScopeFiles } from "./briefs.mjs";
 import {
+  formatNotFoundError,
   loadSquads,
+  logicalWorkspaceRoot,
   manifestSquads,
   resolveIntegrityAuditor,
   resolveSquadLead,
+  resolveWorkspaceRoot,
   specialistAssignments
 } from "./dispatch.mjs";
 import { normalizeReportRoot, reportPath } from "./handoffs.mjs";
@@ -14,6 +17,7 @@ const ALLOWED_PLANNER_KEYS = new Set([
   "manifestPath",
   "manifest",
   "task",
+  "workspace",
   "squadId",
   "executionMode",
   "model",
@@ -235,7 +239,7 @@ function buildSwarmWorkerBrief(compiledBrief, targetModel, workspaceIsolation) {
  * or invoke_subagent dispatch, explicit model provenance, scope-overlap checks, and L6-safe
  * integrity audit scaffolding.
  */
-function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE || process.cwd()) {
+function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE?.trim() || process.cwd()) {
   if (!args || typeof args !== "object" || Array.isArray(args)) {
     throw new Error("Provide a planner options object.");
   }
@@ -249,6 +253,7 @@ function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE
     manifestPath,
     manifest,
     task,
+    workspace: argWorkspace,
     squadId,
     executionMode = "swarm",
     model,
@@ -303,7 +308,8 @@ function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE
   }
   const normalizedReportRoot = reportRoot !== undefined ? normalizeReportRoot(reportRoot) : undefined;
 
-  const root = fs.realpathSync(workspace);
+  const root = resolveWorkspaceRoot(argWorkspace, workspace);
+  const logicalRoot = logicalWorkspaceRoot(argWorkspace, workspace);
   let loadedSquads;
   let selectedManifest;
   if (task !== undefined) {
@@ -328,7 +334,7 @@ function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE
     if (scopeFiles !== undefined || roles !== undefined) {
       throw new Error("scopeFiles and roles can only be passed with task.");
     }
-    const loaded = loadSquads(root, manifestPath);
+    const loaded = loadSquads(root, manifestPath, logicalRoot);
     loadedSquads = loaded.squads;
     selectedManifest = loaded.selectedManifest;
   }
@@ -573,8 +579,8 @@ function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE
             overriddenSubagentModels
           );
           const targetScopeNote = executionMode === "swarm"
-            ? `Audit provenanceScaffold entries for squad '${id}'. Verify reports, verifiedFiles hashes, and Evidence Digest ('agy-squad digest <record.json>'). read_board/swarm status confirm handoffs/roster/model only; verify worker execution traces via 'agy-context transcript query --id <id> --summary' (when granted access) or via a coordinator-extracted sanitized transcript index in scratch/ before CLEAN (re-execution alone cannot satisfy CLEAN; report 'Integrity Verdict: INTEGRITY VIOLATION' if traces are unavailable). NEVER copy raw .system_generated/ transcripts into scratch/.`
-            : `Audit provenanceScaffold entries for squad '${id}'. Verify reports, verifiedFiles hashes, Evidence Digest ('agy-squad digest <record.json>'), and spot-check traces ONLY via single-pass 'agy-context transcript query --id <id> --summary' (or query_transcript(summaryOnly=true)) on coordinator-recorded conversationIds. NEVER copy .system_generated/ transcripts into scratch/.`;
+            ? `Audit provenanceScaffold entries for squad '${id}', verifiedFiles hashes, and Evidence Digest ('agy-squad digest <record.json>'). Use a coordinator-extracted sanitized transcript index in scratch/ when transcript tools are restricted (re-execution alone cannot satisfy CLEAN; report 'Integrity Verdict: INTEGRITY VIOLATION' if traces are unavailable).`
+            : `Audit provenanceScaffold entries for squad '${id}', verifiedFiles hashes, and Evidence Digest ('agy-squad digest <record.json>') against coordinator-recorded conversationIds.`;
           const compiledAudit = buildSubagentSpec(
             {
               ...rawAudit,
@@ -740,14 +746,14 @@ function planSquadCohort(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE
   };
 }
 
-function handleSquadPlanner(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE || process.cwd()) {
+function handleSquadPlanner(args = {}, workspace = process.env.AGY_SQUAD_WORKSPACE?.trim() || process.cwd()) {
   try {
     const plan = planSquadCohort(args, workspace);
     return {
       content: [{ type: "text", text: JSON.stringify(plan, null, 2) }]
     };
   } catch (error) {
-    const message = error.code === "ENOENT" ? "Manifest or workspace not found." : error.message;
+    const message = error.code === "ENOENT" ? formatNotFoundError(args, workspace) : error.message;
     return { isError: true, content: [{ type: "text", text: `squad_planner: ${message}` }] };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-squad",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Swarm planning, Pointer-Over-Wire governance, integrity auditing, and SHA-256 verification for Google Antigravity.",
   "main": "mcp/index.js",
   "bin": {
@@ -35,7 +35,7 @@
     "type": "git",
     "url": "https://github.com/paragon-ux/Agy-Squad.git"
   },
-  "homepage": "https://paragon-ux.github.io/agy-squad/",
+  "homepage": "https://paragon-ux.github.io/Agy-Squad/",
   "bugs": {
     "url": "https://github.com/paragon-ux/Agy-Squad/issues"
   },

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-squad",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Swarm planning, Pointer-Over-Wire governance, integrity auditing, and SHA-256 verification for Google Antigravity.",
   "author": {
     "name": "paragon-ux"

package/scripts/install-register.mjs

@@ -22,9 +22,9 @@ const repoRoot = path.resolve(__dirname, "..");
 
 const PACKAGE_VERSION = (() => {
   try {
-    return JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8")).version || "0.1.0";
+    return JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8")).version || "0.1.1";
   } catch {
-    return "0.1.0";
+    return "0.1.1";
   }
 })();
 

package/scripts/release-preflight.mjs

@@ -82,6 +82,7 @@ if (pkg) {
   const requiredPackageFiles = [
     "bin/agy-squad.mjs",
     "mcp/index.js",
+    "mcp/dispatch.mjs",
     "mcp/planner.mjs",
     "mcp/briefs.mjs",
     "mcp/handoffs.mjs",
@@ -91,6 +92,8 @@ if (pkg) {
     ".agents/skills/pr-review/SKILL.md",
     ".agents/skills/full-review/SKILL.md",
     ".agents/skills/self-diagnosis/SKILL.md",
+    ".agents/skills/self-diagnosis/scripts/diagnose.mjs",
+    ".agents/skills/self-diagnosis/resources/self-diagnosis-manifest.json",
     ".agents/skills/swarm-governance/SKILL.md",
     "plugin.json",
     "install.sh",
@@ -100,6 +103,27 @@ if (pkg) {
     "LICENSE"
   ];
 
+  const fileEntries = (pkg.files ?? [])
+    .filter((entry) => typeof entry === "string" && entry.trim())
+    .map((entry) => {
+      const negated = entry.startsWith("!");
+      const normalized = (negated ? entry.slice(1) : entry)
+        .replace(/\\/g, "/")
+        .replace(/^\.\//, "")
+        .replace(/\/+$/, "");
+      return { negated, normalized };
+    });
+  const positiveEntries = fileEntries.filter((entry) => !entry.negated);
+  const negativeEntries = fileEntries.filter((entry) => entry.negated);
+  const matchesPackageEntry = (relativePath, normalized) => {
+    if (!normalized) return false;
+    if (normalized.includes("*")) {
+      const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(`^${escaped.replace(/\*\*|\*/g, (m) => (m === "**" ? ".*" : "[^/]*"))}$`).test(relativePath);
+    }
+    return relativePath === normalized || relativePath.startsWith(`${normalized}/`);
+  };
+
   for (const relativePath of requiredPackageFiles) {
     if (!exists(relativePath)) {
       errors.push(`Required runtime/release file is missing: ${relativePath}`);
@@ -107,10 +131,8 @@ if (pkg) {
     const alwaysIncluded = ["package.json", "README.md", "CHANGELOG.md", "LICENSE"].includes(relativePath);
     const coveredByFiles =
       alwaysIncluded ||
-      (pkg.files ?? []).some((entry) => {
-        const normalized = entry.replace(/\\/g, "/").replace(/\/$/, "");
-        return relativePath === normalized || relativePath.startsWith(`${normalized}/`);
-      });
+      (positiveEntries.some((entry) => matchesPackageEntry(relativePath, entry.normalized)) &&
+        !negativeEntries.some((entry) => matchesPackageEntry(relativePath, entry.normalized)));
     if (!coveredByFiles) {
       errors.push(`package.json "files" does not clearly include ${relativePath}.`);
     }
@@ -122,8 +144,15 @@ if (pkg) {
     }
   }
 
-  if (!pkg.scripts?.setup || !pkg.scripts?.status || !pkg.scripts?.uninstall || !pkg.scripts?.preflight || !pkg.scripts?.test) {
-    errors.push("Expected npm scripts setup, status, uninstall, preflight, and test to be present.");
+  if (
+    !pkg.scripts?.setup ||
+    !pkg.scripts?.status ||
+    !pkg.scripts?.uninstall ||
+    !pkg.scripts?.preflight ||
+    !pkg.scripts?.test ||
+    !pkg.scripts?.["verify:package"]
+  ) {
+    errors.push("Expected npm scripts setup, status, uninstall, preflight, test, and verify:package to be present.");
   }
 
   if (Object.keys(pkg.dependencies ?? {}).length > 0) {