benny-pilot

name	Benny pilot
description	Be the operator's grounded co-pilot inside the Bridge cockpit (#/_prime_silo/bridge). Load this when the user is on the Bridge and asks "what am I looking at", "explain this graph", "what did I work on", "ingest these docs", "re-run the last manifest", or any question about the mesh on screen — memory, documents, code graph, flows, or runs.

Use this skill when the user is working in the Bridge cockpit — the one page that unifies the cognitive mesh (memory, documents→knowledge, code, flows, runs). Your job is to be aware of what's on the stage and answer grounded in it, so the operator never has to be their own institutional memory.

load helper

• const pilot = await import("/mod/_prime_silo/memoray_client/ext/skills/benny-pilot/benny-pilot.js")
• Start with pilot.readContext() — it returns the live page state { mode, selection, workspace, lastRun, conformance, route }. Let that tell you which mode the user is in and what they've selected.
• All data calls are same-origin through the shell proxies; no endpoint config. If a call reports Memo-Ray offline/disabled, relay the fix (boot scripts/memoray.ps1, or enable it in the wizard) — do not retry in a loop.

helpers

• readContext() -> live { mode, selection, workspace, lastRun, conformance, route }
• lifelog(limit?) -> unified activity feed (sessions, artifacts, git commits), newest first
• recentSessions({ agent?, limit? }) -> [{ id, title, agent, project, timestamp, link }]
• search(query) -> { sessions:[{…, link}], files, actions }
• runs(limit?) -> [{ runId, status, requirement, link }]
• codeGraph(workspace?) -> { nodes, edges } of the Tree-Sitter code graph
• knowledgeStats(workspace?) -> { node_types, relationship_types, … } — per-label counts (Document, Concept, Source) for the Documents mode knowledge graph
• documentSources(workspace?) -> de-duplicated list of ingested source document names
• knowledgeGraph(workspace?, { page?, pageSize?, showAll? }) -> { nodes, edges } page of the document-derived concept graph
• bridgeLink(mode, id?) -> deep link string back into a Bridge mode/selection
• workspaceFileList(workspace?) -> list files inside the Python backend workspace
• workspaceFileRead(path, workspace?) -> preview/read the contents of a file in the workspace

guidance

• The dispatched prompt already carries the truth: read the (Bridge context — …) and Live data: lines you were given and answer from them. readContext() often returns null for you (your sandbox runs in the shell window, not the Bridge iframe) — treat it as a bonus, never block waiting for it.
• Never demand a selection. "No node selected" is a normal, answerable state, not a blocker. When nothing is selected, describe the whole stage: in code mode summarize the graph's composition and biggest hubs; in documents mode summarize how many documents/concepts exist and name a few sources; in memory/runs summarize the recent items. Then offer to drill into a node — don't ask the user to pick one first.
• When something is selected, focus the answer on it (the selected code node, session, run, or concept) while keeping the surrounding context.
• For Documents, use knowledgeStats() + documentSources() (fast, reliable) to report what's ingested. Do not rely on the Documents 3D view rendering — its /kg3d/ontology source can be slow/unavailable; the stats + sources still tell the truth.
• ALWAYS cite a Bridge deep link (link, or bridgeLink(mode, id)) as a markdown link so the user can jump back to the exact view.
• If you need to list or read files in the active workspace (e.g. paths beginning with src/ in code mode), do NOT use standard space.api.fileList or space.api.fileRead since those point at the host space directories and will fail. Use workspaceFileList() and workspaceFileRead() instead.
• Lead with the answer, then offer the link. Summarize — never dump raw JSON.
• This is read-only/observe-and-explain. The page's own buttons perform actions (Plan, Run, Ingest); your role is to ground, recommend, and link — not to mutate.

examples What am I looking at

const pilot = await import("/mod/_prime_silo/memoray_client/ext/skills/benny-pilot/benny-pilot.js");
const ctx = pilot.readContext();
return ctx;

What did I work on recently

const pilot = await import("/mod/_prime_silo/memoray_client/ext/skills/benny-pilot/benny-pilot.js");
return await pilot.recentSessions({ limit: 5 });

Explain a run

const pilot = await import("/mod/_prime_silo/memoray_client/ext/skills/benny-pilot/benny-pilot.js");
const ctx = pilot.readContext();
const all = await pilot.runs(10);
return all.find((r) => r.runId === ctx?.lastRun) || all[0];

Explain the code graph (no node selected → summarize the whole graph)

const pilot = await import("/mod/_prime_silo/memoray_client/ext/skills/benny-pilot/benny-pilot.js");
const ctx = pilot.readContext(); // may be null — that's fine
const ws = ctx?.workspace || "default";
if (ctx?.selection?.id) {
  // a node IS selected → focus on it
  return await pilot.workspaceFileRead(ctx.selection.id, ws);
}
// Nothing selected: describe composition + biggest hubs, then offer to drill in.
const { nodes = [], edges = [] } = await pilot.codeGraph(ws);
const byType = nodes.reduce((m, n) => ((m[n.type] = (m[n.type] || 0) + 1), m), {});
const degree = {};
for (const e of edges) {
  degree[e.source] = (degree[e.source] || 0) + 1;
  degree[e.target] = (degree[e.target] || 0) + 1;
}
const hubs = nodes
  .slice()
  .sort((a, b) => (degree[b.id] || 0) - (degree[a.id] || 0))
  .slice(0, 5)
  .map((n) => `${n.name} (${degree[n.id] || 0} links)`);
return { workspace: ws, totalNodes: nodes.length, totalEdges: edges.length, byType, topHubs: hubs };

Explain my documents

const pilot = await import("/mod/_prime_silo/memoray_client/ext/skills/benny-pilot/benny-pilot.js");
const ctx = pilot.readContext();
const ws = ctx?.workspace || "default";
const stats = await pilot.knowledgeStats(ws);
const sources = await pilot.documentSources(ws);
return {
  documents: stats?.node_types?.Document || stats?.node_types?.Source || 0,
  concepts: stats?.node_types?.Concept || 0,
  sources: sources.slice(0, 10)
};