@yemi33/minions 0.1.2398 → 0.1.2399

package/dashboard/slim/js/modals-tiles.js

@@ -12,11 +12,15 @@
       if (ev.key === 'Escape' && modal.classList.contains('open')) close();
     });
   }
+  function clearTileModalBody() {
+    var body = document.getElementById('slim-tile-body');
+    if (body) body.textContent = '';
+  }
   // Stop the agent-detail "Working for" ticker on every dismiss path so the
   // 1s interval started in openAgentDetail can't leak after the modal closes.
   bindModalClose('slim-agent-modal', 'slim-agent-close', _stopAgentDetailRuntime);
   bindModalClose('slim-tools-modal', 'slim-tools-close');
-  bindModalClose('slim-tile-modal', 'slim-tile-close');
+  bindModalClose('slim-tile-modal', 'slim-tile-close', clearTileModalBody);
 
   function tileEmpty(body, text) {
     var d = document.createElement('div');
@@ -83,16 +87,24 @@
 
   // Per-tile body renderers for the detail modal. Each reads the latest status
   // snapshot and fills the modal body; openTileModal looks them up by key.
-  function renderEngineTileBody(body, data) {
-    var e = data.engine || {};
-    appendAgentRow(body, 'State', e.state || '—', !e.state);
-    appendAgentRow(body, 'Version', e.codeVersion || '—', !e.codeVersion);
-    appendAgentRow(body, 'PID', e.pid != null ? String(e.pid) : '—', e.pid == null);
-    appendAgentRow(body, 'Started', e.started_at ? (relTime(e.started_at) + ' · ' + new Date(e.started_at).toLocaleString()) : '—', !e.started_at);
-    appendAgentRow(body, 'Last tick', e.lastTickAt ? relTime(e.lastTickAt) : '—', !e.lastTickAt);
-    appendAgentRow(body, 'Tick interval', e.tickInterval ? Math.round(e.tickInterval / 1000) + 's' : '—', !e.tickInterval);
-    appendAgentRow(body, 'Worktrees', e.worktreeCount != null ? String(e.worktreeCount) : '—', e.worktreeCount == null);
-    appendAgentRow(body, 'Heartbeat', e.heartbeatStale ? 'stale' : 'ok', false);
+  // Engine tile body — reuses the LITERAL classic dashboard /engine screen
+  // instead of a slim-specific key/value readout, so there is one Engine UI, not
+  // two (W-mrtdnknm000med95 / "reuse, don't fork" — mirrors renderQueuedWorkBody
+  // for the Work tile, renderPlansBody for the Plans tile, and renderPrsBody for
+  // the PRs tile). Slim and classic are two separate IIFE bundles with no shared
+  // scope, so we embed the real /engine screen in an iframe with the chrome-off
+  // ?embed=1 mode. The iframed page IS the classic screen — the full engine
+  // dashboard (quick stats, engine log, managed-process panel + its log SSE
+  // stream, memory + diagnostics panels), backed by the same /api endpoints and
+  // live streams — with zero duplicated rendering logic. Classic is reachable at
+  // /engine even with slim-ux ON (only / is taken over). Built with createElement
+  // (no innerHTML) to satisfy the dashboard no-unsanitized lint gate.
+  function renderEngineBody(body) {
+    var frame = document.createElement('iframe');
+    frame.className = 'slim-engine-embed';
+    frame.src = '/engine?embed=1';
+    frame.title = 'Engine';
+    body.appendChild(frame);
   }
 
   function renderDispatchTileBody(body, data, isActive) {
@@ -184,7 +196,7 @@
 
   // tile key -> { title, render }. Adding a tile is a one-line table edit.
   var TILE_VIEWS = {
-    engine:     { title: 'Engine',            render: renderEngineTileBody },
+    engine:     { title: 'Engine',            render: function(body) { renderEngineBody(body); } },
     dispatches: { title: 'Active dispatches', render: function(body, data) { renderDispatchTileBody(body, data, true); } },
     queued:     { title: 'Queued work',       render: function(body) { renderQueuedWorkBody(body); } },
     plans:      { title: 'Plans',             render: function(body) { renderPlansBody(body); } },
@@ -209,10 +221,11 @@
     // The "+ Link PR" header chip only applies to the PR list.
     var headerChip = document.getElementById('slim-tile-modal-linkpr');
     if (headerChip) headerChip.style.display = (key === 'prs') ? '' : 'none';
-    // The queued, plans + prs tiles embed a full classic screen (/work, /plans,
-    // /prs) in an iframe — widen the modal + drop the body padding so the
-    // embedded screen gets real estate. All three reuse the shared wide-modal
-    // treatment.
+    // The engine, queued, plans + prs tiles embed a full classic screen
+    // (/engine, /work, /plans, /prs) in an iframe — widen the modal + drop the
+    // body padding so the embedded screen gets real estate. All four reuse the
+    // shared wide-modal treatment.
+    modal.classList.toggle('tile-modal--engine', key === 'engine');
     modal.classList.toggle('tile-modal--work', key === 'queued');
     modal.classList.toggle('tile-modal--plans', key === 'plans');
     modal.classList.toggle('tile-modal--prs', key === 'prs');
@@ -251,4 +264,3 @@
   (function bindPlansTileCount() {
     if (typeof loadPlansCounts === 'function') setTimeout(loadPlansCounts, 1500);
   })();
-

package/dashboard/slim/styles.css

@@ -677,16 +677,19 @@
       max-width: calc(100vw - 32px);
     }
 
-    /* Cockpit-tile detail modal: list of dispatches / PRs / watches, or a
-       key/value engine readout (reuses .agent-detail-row). */
+    /* Cockpit-tile detail modal: list of dispatches or watches (reuses
+       .agent-detail-row / .tile-item). */
     #slim-tile-modal .modal { width: 720px; max-width: calc(100vw - 32px); }
-    /* W-mqrdggys000f94a4 / W-mr28ko750010199f / W-mr3l7y0m0007102a — the
-       Queued-work + Plans + PRs tiles embed a full classic screen (/work,
-       /plans, /prs) in an iframe; widen the modal + remove body padding so the
-       embedded screen gets the full width/height. */
+    /* W-mqrdggys000f94a4 / W-mr28ko750010199f / W-mr3l7y0m0007102a /
+       W-mrtdnknm000med95 — the Engine + Queued-work + Plans + PRs tiles embed a
+       full classic screen (/engine, /work, /plans, /prs) in an iframe; widen the
+       modal + remove body padding so the embedded screen gets the full
+       width/height. */
+    #slim-tile-modal.tile-modal--engine .modal,
     #slim-tile-modal.tile-modal--work .modal,
     #slim-tile-modal.tile-modal--plans .modal,
     #slim-tile-modal.tile-modal--prs .modal { width: 1180px; }
+    #slim-tile-modal.tile-modal--engine .modal-body,
     #slim-tile-modal.tile-modal--work .modal-body,
     #slim-tile-modal.tile-modal--plans .modal-body,
     #slim-tile-modal.tile-modal--prs .modal-body { padding: 0; }
@@ -696,6 +699,7 @@
        full width/height. Mirrors the Queued-work/Plans/PRs tile treatment. */
     #slim-settings-modal .modal { width: 1180px; max-width: calc(100vw - 32px); }
     #slim-settings-modal .modal-body { padding: 0; }
+    .slim-engine-embed,
     .slim-work-embed,
     .slim-plans-embed,
     .slim-prs-embed,

package/dashboard.js

@@ -62,6 +62,7 @@ const createPrWorktree = require('./engine/create-pr-worktree');
 const prResolve = require('./engine/pr-resolve');
 const prFixTarget = require('./engine/pr-fix-target');
 const prTrack = require('./engine/pr-track');
+const resolveArea = require('./engine/resolve-area');
 const features = require('./engine/features');
 const ccWorkerPool = require('./engine/cc-worker-pool');
 const diagnosticsMemory = require('./engine/diagnostics-memory');
@@ -13246,6 +13247,33 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         builder: () => getDispatchQueue(),
       });
     }},
+    // GET /api/resolve-area — reverse "component name → subproject path" resolver
+    // (WI W-mrpbsbs7000ce8ac). Given a configured project and a user token
+    // ("OCM", "loop"), resolve it to real subproject path(s) via the filesystem
+    // (engine/resolve-area.js reuses the bounded first-level area enumeration) so
+    // CC threads a resolved PATH into scope instead of guessing from PR titles.
+    { method: 'GET', path: '/api/resolve-area', desc: 'Resolve a monorepo component/subproject NAME to real subproject path(s) for a configured project, via the filesystem (never PR titles). Query: project (configured project name), token (component name e.g. "OCM"). Returns {ok, project, token, area, paths, absPaths, matched:"exact"|"alias"|"none"}. matched:"none" means the caller should ask the user, not guess.', params: 'project (required), token (required)', handler: (req, res) => {
+      const params = new URL(req.url, 'http://localhost').searchParams;
+      const projectName = (params.get('project') || '').trim();
+      const token = (params.get('token') || '').trim();
+      if (!projectName) return jsonReply(res, 400, { error: 'project query param is required' }, req);
+      if (!token) return jsonReply(res, 400, { error: 'token query param is required' }, req);
+      const descriptor = shared.resolveProjectSource(projectName, PROJECTS, { allowCentral: false });
+      const project = descriptor && descriptor.project;
+      if (!project) return jsonReply(res, 404, { error: `unknown project "${projectName}"` }, req);
+      if (!project.localPath) return jsonReply(res, 400, { error: `project "${project.name}" has no localPath (no checkout to resolve against)` }, req);
+      const resolved = resolveArea.resolveAreaFromToken(project.localPath, token);
+      const absPaths = resolved.paths.map(p => path.join(project.localPath, p).replace(/\\/g, '/'));
+      return jsonReply(res, 200, {
+        ok: true,
+        project: project.name,
+        token,
+        area: resolved.area,
+        paths: resolved.paths,
+        absPaths,
+        matched: resolved.matched,
+      }, req);
+    }},
     { method: 'GET', path: '/api/metrics', desc: 'Per-agent metrics with PR/runtime enrichment (joined against pull-requests + dispatch.completed)', handler: (req, res) => {
       return serveFreshJson(req, res, {
         tag: 'metrics',

package/engine/resolve-area.js

@@ -0,0 +1,200 @@
+/**
+ * engine/resolve-area.js — Reverse "component name → subproject path" resolver.
+ *
+ * WI W-mrpbsbs7000ce8ac. Command Center (and other callers) frequently receive
+ * a monorepo component name in a natural-language request ("audit OCM changes",
+ * "Loop Android"). Without a way to turn that name into a real filesystem path,
+ * CC used to guess the subproject's location from PR titles — a documented
+ * incident where CC repeatedly asked the operator where OCM lived even though
+ * `<repo>/ocm/` exists on disk.
+ *
+ * This module is the reverse of the (now-removed) dominant-subproject detector:
+ * that mapped `changed paths → area`; this maps `user token → area path(s)`.
+ *
+ * NOTE ON REUSE: the original first-level area enumeration lived in
+ * `engine/discover-project-skills.js` as `_listAreas`. That entire module (and
+ * its area/skill/harness heuristics) was deliberately removed when repository
+ * harness discovery was delegated to the native runtimes (PR #817,
+ * "Delegate repository harness discovery to native runtimes"). No `_listAreas`
+ * remains to import, so this file carries the single, minimal, bounded
+ * first-level enumeration — it is NOT a parallel copy of a live helper.
+ *
+ * Design constraints (match the removed helper's conventions):
+ *   - Bounded / deadline-guarded filesystem work (no unbounded recursion).
+ *   - Deterministic, sorted output across OSes.
+ *   - Cross-platform: paths are emitted as POSIX forward-slash, dir-suffixed.
+ *   - Zero runtime deps — Node built-ins only.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULTS = {
+  // Cap on first-level directories enumerated (monorepo roots are wide but
+  // still O(dozens), so this is a generous ceiling that bounds a pathological
+  // directory).
+  maxAreas: 400,
+  // Wall-clock budget for the whole resolve (enumeration + alias existence
+  // probes). Bounded like the removed helper so a slow/again-networked FS can
+  // never hang a caller.
+  walltimeMs: 750,
+};
+
+/**
+ * Documented alias map for known multi-path components — a single user token
+ * that resolves to several real subproject paths (a primary top-level area PLUS
+ * wrapper / native / telemetry paths scattered elsewhere in the tree).
+ *
+ * Keys are lowercase tokens. `primary` is the first-level area used for the
+ * returned `area`; `paths` is the full candidate set (repo-relative, POSIX,
+ * trailing slash). At resolve time each candidate is verified against the
+ * on-disk tree so a token used against a repo that is NOT the monorepo cleanly
+ * returns no match instead of inventing paths.
+ */
+const AREA_ALIASES = {
+  // OCM (Office Copilot Mobile): the top-level `ocm/` area plus its wrapper /
+  // native / telemetry paths under officemobile/.
+  ocm: {
+    primary: 'ocm',
+    paths: [
+      'ocm/',
+      'officemobile/ocmnative/',
+      'officemobile/android/ocmciq/',
+      'officemobile/android/JavaKotlin/ocmciq/',
+      'officemobile/android/hubframework/ocmsdk-wrapper/',
+      'officemobile/android/JavaKotlin/hubframework/ocmsdk-wrapper/',
+      'officemobile/ios/OCMWrapper/',
+      'officemobile/telemetry/android/ocm/',
+      'officemobile/telemetry/tml/ocm/',
+    ],
+  },
+};
+
+function _now() { return Date.now(); }
+
+/** Normalize a repo-relative path to POSIX forward-slash with a trailing slash. */
+function _toPosixDir(p) {
+  let s = String(p).replace(/\\/g, '/').replace(/\/+$/, '');
+  return s.length ? `${s}/` : s;
+}
+
+/** Bounded existence check: true iff `rel` resolves to a directory under `projectPath`. */
+function _isDir(projectPath, rel) {
+  try {
+    const abs = path.join(projectPath, rel);
+    return fs.statSync(abs).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Enumerate first-level subproject directories of `projectPath`.
+ *
+ * Deterministic (locale-sorted), bounded by `opts.maxAreas` and `deadline`,
+ * dot-dir and `node_modules` filtered. Returns bare directory names (no slash).
+ *
+ * @param {string} projectPath — absolute path to the project checkout / worktree
+ * @param {object} [opts] — { maxAreas, walltimeMs } overrides
+ * @param {number} [deadline] — absolute ms timestamp; enumeration stops past it
+ * @returns {string[]} sorted first-level directory names
+ */
+function listAreas(projectPath, opts, deadline) {
+  const o = Object.assign({}, DEFAULTS, opts || {});
+  const stopAt = typeof deadline === 'number' ? deadline : _now() + Math.max(1, o.walltimeMs);
+  const out = [];
+  if (!projectPath || typeof projectPath !== 'string') return out;
+  let entries;
+  try {
+    entries = fs.readdirSync(projectPath, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  // Sort for deterministic ordering across OSes.
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const ent of entries) {
+    if (out.length >= o.maxAreas) break;
+    if (_now() > stopAt) break;
+    if (!ent.isDirectory()) continue;
+    // Skip dot-dirs (.git, .github, .claude, …) and node_modules.
+    if (ent.name.startsWith('.')) continue;
+    if (ent.name === 'node_modules') continue;
+    out.push(ent.name);
+  }
+  return out;
+}
+
+/**
+ * Reverse resolver: map a user-supplied component/subproject token to the real
+ * subproject path(s) inside `projectPath`.
+ *
+ * Resolution order:
+ *   1. Alias expansion — if the token is a known multi-path component (see
+ *      AREA_ALIASES), return every candidate path that actually exists on disk,
+ *      with `area` set to the primary first-level area. `matched: 'alias'`.
+ *   2. Exact match — case-insensitive match of the token against the first-level
+ *      areas enumerated by `listAreas`. Returns the single `<area>/` path.
+ *      `matched: 'exact'`.
+ *   3. No match — `{ area: null, paths: [], matched: 'none' }`. Callers should
+ *      then ask the user instead of guessing.
+ *
+ * All work is bounded by `opts.walltimeMs`. Output paths are deterministic
+ * (sorted, de-duped), POSIX forward-slash, trailing-slash directories.
+ *
+ * @param {string} projectPath — absolute path to the project checkout / worktree
+ * @param {string} token — user-supplied component name (e.g. "OCM", "loop")
+ * @param {object} [opts] — { maxAreas, walltimeMs } overrides
+ * @returns {{area: string|null, paths: string[], matched: 'exact'|'alias'|'none'}}
+ */
+function resolveAreaFromToken(projectPath, token, opts) {
+  const result = { area: null, paths: [], matched: 'none' };
+  if (!projectPath || typeof projectPath !== 'string') return result;
+  if (typeof token !== 'string') return result;
+  const t = token.trim().toLowerCase();
+  if (!t) return result;
+
+  const o = Object.assign({}, DEFAULTS, opts || {});
+  const deadline = _now() + Math.max(1, o.walltimeMs);
+
+  const areas = listAreas(projectPath, o, deadline);
+  const areasLower = new Map(areas.map(a => [a.toLowerCase(), a]));
+
+  // 1. Alias expansion (multi-path components like OCM).
+  const alias = Object.prototype.hasOwnProperty.call(AREA_ALIASES, t)
+    ? AREA_ALIASES[t]
+    : null;
+  if (alias) {
+    const verified = [];
+    for (const rel of alias.paths) {
+      if (_now() > deadline) break;
+      if (_isDir(projectPath, rel)) verified.push(_toPosixDir(rel));
+    }
+    if (verified.length > 0) {
+      const primaryDir = areasLower.get(alias.primary.toLowerCase()) || alias.primary;
+      return {
+        area: primaryDir,
+        paths: Array.from(new Set(verified)).sort(),
+        matched: 'alias',
+      };
+    }
+    // Alias known but none of its paths exist here (token used against a repo
+    // that is not the monorepo). Fall through to exact / none.
+  }
+
+  // 2. Exact case-insensitive match against enumerated first-level areas.
+  const exact = areasLower.get(t);
+  if (exact) {
+    return { area: exact, paths: [_toPosixDir(`${exact}/`)], matched: 'exact' };
+  }
+
+  return result;
+}
+
+module.exports = {
+  DEFAULTS,
+  AREA_ALIASES,
+  listAreas,
+  resolveAreaFromToken,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2398",
+  "version": "0.1.2399",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"

package/prompts/cc-system.md

@@ -204,6 +204,25 @@ curl -s http://localhost:{{dashboard_port}}/api/work-items
 curl -s http://localhost:{{dashboard_port}}/api/status
 ```
 
+## Resolving a monorepo component/subproject by name — GET /api/resolve-area
+
+Monorepo projects (e.g. the Office `src` repo) contain many **subprojects** under first-level directories (`ocm/`, `loop/`, `officemobile/`, …). When a request names a component or subproject — "audit OCM changes", "Loop Android", "the LMF area" — that name refers to a **path inside the repo**, not to a PR title.
+
+**Rule: resolve the area from the filesystem — NEVER infer a subproject's location from PR titles.** Scanning PR titles/branches to guess where a component lives is wrong (it caused a real incident: CC kept asking the operator where OCM was even though `<repo>/ocm/` exists on disk). Resolve the name to a real path first, then scope your work (`git log -- <path>`, `Glob`, dispatched WI description) to that path.
+
+Resolve via `GET /api/resolve-area?project=<name>&token=<component>`:
+```
+curl -s 'http://localhost:{{dashboard_port}}/api/resolve-area?project=src&token=OCM'
+```
+Returns `{ok, project, token, area, paths, absPaths, matched}` where `matched` is:
+- `"exact"` — the token is a first-level area (`paths: ["<area>/"]`).
+- `"alias"` — a known multi-path component; `paths` lists every real subpath that exists on disk.
+- `"none"` — no area matched. **Ask the user where the component lives — do not guess from PR titles.**
+
+**Worked example (OCM → `ocm/` + wrapper/native paths).** `token=OCM` resolves to the top-level `ocm/` area PLUS its wrapper/native/telemetry paths (`officemobile/ocmnative/`, `officemobile/android/ocmciq/`, `officemobile/ios/OCMWrapper/`, `officemobile/telemetry/android/ocm/`, …) — only the paths that actually exist in the checkout are returned. Scope OCM audits/fixes to that full path set, not to PRs whose title happens to say "OCM".
+
+If the endpoint returns `matched:"none"`, you may also enumerate first-level areas yourself with your `Glob`/`Bash` tools against the project's `localPath` (the reverse resolver just reuses that same first-level directory listing) — but still never fall back to PR titles.
+
 ## Read-only PR actions on ANY PR — POST /api/pr-action
 
 When the user asks you to **review / summarize / comment-on / triage a specific PR by URL or id** — including PRs in repos that are NOT a configured Minions project (e.g. "review this PR https://github.com/some/repo/pull/42", "summarize ado:org/proj/repo#5215493", "triage github:yemi33/minions#2702") — route it through `POST /api/pr-action` instead of dispatching a `review`/`explore` work item. This path is **projectless and read-only**: it resolves the PR, fetches its diff + metadata with NO clone/worktree, and reasons over the (untrusted-fenced) content. Use it for one-off, look-don't-touch asks on an arbitrary PR.