@hybridlabor-api/aos 4.7.0 → 4.7.1

package/skills/global_config/ask-tim/SKILL.md

@@ -41,6 +41,16 @@ Reach for `test-driven-development` or `tdd-workflow` on their own when you want
 
 **Forcing a specific skill into a run:** `--skill=<name>` on any startcycle variant makes it a hard requirement — for a private skill of your own no node would otherwise reach for. Validated before the run starts; a name that does not resolve halts rather than proceeding without it.
 
+## Outside the core: the ECC store
+
+When no native AOS skill fits, search the markdown-only ECC store before starting a pipeline:
+
+- `aos store search <query>` finds available fallback skills and agents.
+- `aos store install <name>` installs a verified item after explicit user action.
+- `aos store list --type=skills` and `aos store list --type=agents` show the catalogue.
+- The core remains the trusted AOS skill set; the store is a fallback, not a reason to bypass the startcycle validation.
+- A missing `--skill` is reported by the dispatcher with the exact install command. It never downloads during a run.
+
 ---
 
 ## On-ramps

package/skills/global_config/mcsc/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: mcsc
+description: Delegate a task to another installed CLI harness (Antigravity/agy, OpenCode, Codex) from inside an AOS repo. Use this instead of shelling out to that CLI directly whenever one is installed — it wraps the wrapper flags for you and streams live tool-call telemetry to agenttrail, which is why the board updates in real time. Reach for it any time you're about to delegate work to another harness.
+category: bdb-core
+metadata:
+  version: "0.1.0"
+---
+
+# mcsc — Multi-CLI Subagent Configurator
+
+mcsc (`mcps/mcsc/`) is AOS's own cross-harness delegation engine. It is the
+mandatory path for delegating work to another CLI harness inside an
+AOS-installed repo — not a Claude-Code-only convenience.
+
+## Why this exists
+
+Three separate, harness-specific delegation paths already exist (the Claude
+Code plugins `antigravity:antigravity-delegate`, `opencode:opencode-rescue`,
+`codex:codex-rescue` — see AGENTS.md's "Delegating to an external CLI"). Those
+are fine for interactive delegation *from a Claude Code session*, but they are
+Claude-Code-only, and none of them tell agenttrail's live board what is
+happening. mcsc's adapters
+(`mcps/mcsc/packages/core/src/adapters/{agy,codex,opencode}.js`) wrap each CLI
+once, work from any harness, and call `emitTrail()` around every delegated run
+— `SessionStart`/`SessionEnd`, plus live `PreToolUse`/`PostToolUse` where the
+underlying CLI supports structured/streaming output — so a delegated run shows
+up on the board the moment it starts, without any extra setup.
+
+Skipping mcsc doesn't just lose convenience — it makes the delegated agent
+invisible to anyone watching the live map, and to anyone in this repo who asks
+"what are the other agents doing right now."
+
+## How to use it
+
+Once installed (`mcsc` in `mcp_config.json`, entry point
+`mcps/mcsc/server.js`), it registers up to four MCP tools — one per
+installed CLI, only exposed when that CLI is detected as `ready` in the local
+inventory, and never offered back to a caller that's already running as that
+same CLI (`MCSC_CALLER` env var, avoids self-delegation loops):
+
+- `delegate_agy` — `{ prompt, model? }` → Antigravity / Gemini
+- `delegate_opencode` — `{ prompt, model?, variant? }` → OpenCode
+- `delegate_codex` — `{ prompt, model? }` → Codex
+- `delegate_smart` — `{ task_type, prompt }` → reads `rulebook.yaml` (or the
+  bundled default) and picks the best CLI for that task type automatically
+
+Call the tool that matches the harness you want, with a complete,
+self-contained `prompt` — the adapter underneath handles the CLI's actual
+flags, streams tool-call telemetry to agenttrail as it runs, and returns the
+final output. `variant` (OpenCode only) maps to `--variant` (reasoning
+effort).
+
+## What it is not
+
+- Not a replacement for the Claude Code delegation plugins for a quick,
+  interactive, single-turn ask inside a Claude Code session — those remain
+  fine for that case.
+- Not itself a review/QA step — verify a delegated result the same way
+  AGENTS.md already says to: read the actual diff, never trust the returned
+  status field alone.

package/skills/global_config/plan-canvas/scripts/lib/plan-canvas/server.js

@@ -97,6 +97,23 @@ function readJsonBody(req) {
   });
 }
 
+function isWithin(root, candidate) {
+  const relativePath = path.relative(root, candidate);
+  return relativePath === '' || (relativePath !== '..' && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath));
+}
+
+function confinedArtifactPath(file, workspaceRoot) {
+  if (typeof file !== 'string' || file.length === 0 || /^[a-z][a-z0-9+.-]*:\/\//i.test(file)) return null;
+  try {
+    const root = fs.realpathSync(path.resolve(workspaceRoot));
+    const candidate = fs.realpathSync(path.isAbsolute(file) ? file : path.resolve(root, file));
+    if (!isWithin(root, candidate) || !fs.statSync(candidate).isFile()) return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+
 function sendJson(res, statusCode, payload) {
   const body = JSON.stringify(payload);
   res.writeHead(statusCode, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
@@ -120,6 +137,7 @@ function createPlanCanvasServer({
   idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS,
   heartbeatMs = 15000,
   thinkingStaleMs = DEFAULT_THINKING_STALE_MS,
+  workspaceRoot = process.cwd(),
   typingExpiryMs = DEFAULT_TYPING_EXPIRY_MS,
   presenceSweepMs = DEFAULT_PRESENCE_SWEEP_MS,
   onIdleShutdown = null,
@@ -287,10 +305,11 @@ function createPlanCanvasServer({
       if (!body.file || typeof body.file !== 'string') {
         return sendJson(res, 400, { error: 'file is required' });
       }
-      if (!fs.existsSync(path.resolve(body.file))) {
-        return sendJson(res, 404, { error: `artifact not found: ${body.file}` });
+      const artifactPath = confinedArtifactPath(body.file, workspaceRoot);
+      if (!artifactPath) {
+        return sendJson(res, 403, { error: 'artifact path is outside the workspace' });
       }
-      const { session, refused } = store.open(body.file, { reopen: Boolean(body.reopen) });
+      const { session, refused } = store.open(artifactPath, { reopen: Boolean(body.reopen) });
       if (refused) {
         return sendJson(res, 409, {
           status: 'user-ended',
@@ -514,9 +533,15 @@ function createPlanCanvasServer({
 
     // Sibling assets resolve relative to the artifact's directory and must
     // stay confined to it.
-    const baseDir = path.dirname(session.file);
-    const resolved = path.resolve(baseDir, assetPath);
-    if (resolved !== baseDir && !resolved.startsWith(baseDir + path.sep)) {
+    let baseDir;
+    let resolved;
+    try {
+      baseDir = fs.realpathSync(path.dirname(session.file));
+      resolved = fs.realpathSync(path.resolve(baseDir, assetPath));
+    } catch {
+      return sendJson(res, 404, { error: 'asset not found' });
+    }
+    if (!isWithin(baseDir, resolved)) {
       return sendJson(res, 403, { error: 'asset path escapes artifact directory' });
     }
     let data;

package/skills/global_config/plan-canvas/scripts/plan-canvas.js

@@ -186,7 +186,8 @@ async function ensureServer({ stateDir, port }) {
   const child = spawn(process.execPath, [__filename, 'server', '--port', String(port)], {
     detached: true,
     stdio: ['ignore', logFd, logFd],
-    env: { ...process.env, AOS_PLAN_CANVAS_STATE_DIR: stateDir }
+    env: { ...process.env, AOS_PLAN_CANVAS_STATE_DIR: stateDir },
+    shell: false
   });
   child.unref();
   fs.closeSync(logFd);
@@ -204,7 +205,7 @@ function openBrowser(url) {
       : platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
         : ['xdg-open', [url]];
   try {
-    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    spawn(cmd, args, { detached: true, stdio: 'ignore', shell: false }).unref();
     return true;
   } catch {
     return false;
@@ -357,6 +358,7 @@ async function cmdServer(args, { stateDir, port }) {
   };
   const canvas = createPlanCanvasServer({
     store,
+    workspaceRoot: process.cwd(),
     host: hostArg || DEFAULT_HOST,
     version: VERSION,
     idleTimeoutMs: resolveIdleTimeoutMs(),