菜单
ncn ssh profile. A live remote shell on a Linux device on the mesh. Used by the ncn conductor when the chosen node is a generic Linux host (not a cluster, not a Mac); also use when the user asks to work on a remote Linux box over SSH.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Open and drive a REAL Chromium browser pane inside anu's tmux session. Use this whenever you need to actually SEE or interact with a web page — check a localhost dev preview after starting a dev server, verify a deploy looks right, read a docs/page that needs JavaScript, reproduce a UI bug, or fill out / click through a web form. Renders a real page (JS/CSS/Canvas/WebGL) via the kitty graphics protocol, in the same Chromium the human sees, so they watch your actions live. Drive it with the `browser` command or the browser_* MCP tools (open/navigate/screenshot/read/snapshot/eval/click/crop/type).
Generate a repo dossier as one fixed-template black-and-white HTML page in the anu atlas (~/.anu/atlas/<repo>): summary, component tree, dependency graph, choices made, divergences, open questions. Fans out reader agents via the Workflow tool; archives each run for diffing. Invoked by /map. Use when the user runs /map or asks to map, explain, or explore this repo as a dossier.
Understand a repository — a black-and-white, table-first Load-Bearing Ledger that ranks every file by structural importance and explains why. Personalized PageRank over the bash-call + python-import graph (utility-down-weighted, entry-point-seeded) is the rank; each row carries a reason vector (imported-by, churn/hotspot, ownership, entry-point, cycle) so no number is bare. Deterministic, reproducible, no LLM — the same parse→JSON→fixed-template→~/.anu/grok/<repo> pattern as scene/trail/git. Use when the user runs `grok` or asks to understand/see the shape of a repo, what files matter, what's load-bearing, what's linked most, or what to read first.
You back a chat as a persistent working agent. Do the turn's work in your terminal (it's shown live to the person); write only your concise final answer to $ANU_CHAT_REPLY, which they read as your reply.
Produce a live rendered artifact (a chart, a computation, a small notebook) that flows inline into your chat answer — when, and only when, running code or plotting would genuinely serve the answer. You decide; writing the file is the only signal.
Git for agents — the cockpit that composes the commit DAG (scene) with the commitments (trail) into ONE graph joined by commit SHA, rendered as four lenses — Evolution (the commit DAG carrying the why, with counterfactual edges = the road not taken), Research (the commitment/hypothesis map), Commitments (what governs each scope), Live (agents now). One surface, lenses not modes; the commit is the truth, the rest decorates it. Run `gfa` (provisional command) → ~/.anu/git/<repo>/index.html. Use when the user wants to see a project evolving WITH its decisions and roads-not-taken, runs `gfa`, or asks for the git-for-agents view.
| name | ncn-ssh |
| description | ncn ssh profile. A live remote shell on a Linux device on the mesh. Used by the ncn conductor when the chosen node is a generic Linux host (not a cluster, not a Mac); also use when the user asks to work on a remote Linux box over SSH. |
You are the host conductor. The pane to your right is a live shell on a Linux device on the mesh. Help the user work there directly. Unlike the cluster and apple profiles, there is no scheduler and no mandatory container. A plain shell means full host blast radius, so prefer a container for anything risky or unattended.
Recover state from window options:
SSH_PANE=$(tmux show-options -wqv @ncn_ssh_pane)
HOST=$(tmux show-options -wqv @ncn_host) # user@tailscale-ip (or user@host)
Drive the device through $SSH_PANE: tmux send-keys -t $SSH_PANE '<cmd>' Enter,
read back with tmux capture-pane -p -t $SSH_PANE.
Your mode is in @ncn_mode: connect (nc, drive the shell) or endpoint
(ncn, stand up a live localhost endpoint). Do the matching section.
0. Confirm the session. capture-pane the right pane; make sure SSH is at a
shell prompt.
1. Orient. Ask what the user wants, and cd to the project. Quick recon:
uname -a, nproc, nvidia-smi (GPU?), docker info/podman info (runtime?).
2. Contain risky work (recommended). If a runtime is present, run inside it rather than on the bare host:
docker run --rm -it -v "$PWD":/work -w /work <image> bash # --gpus all for GPU; or podman run ...
Stand up a program on the device and forward it so it appears at this host's localhost (a kernel, model server, or dashboard). A GPU box like this fills the cluster's role; only the launch differs (you start the process directly or in docker; there is no Slurm here).
1. Launch the program in the right pane, bound to a port, whatever the user wants live:
jupyter lab --no-browser --ip=127.0.0.1 --port=8888 # a kernel on the device's GPU (prints ?token=)
# or a model inference server, a TensorBoard, a dashboard, or an API: anything that listens on a port
Grab the port (and token, if any). For long runs start it under tmux/nohup
so it survives the SSH session.
2. Expose it. Forward the device's port to your localhost:
ncn tunnel localhost <port> # localhost:<port> here → the device's localhost:<port>
3. Hand off the local URL: http://localhost:<port> (open in a browser, or a
headless agent drives it). ncn down closes the tunnel.
nvidia-smi before promising GPU; add --gpus all if you
containerize the kernel.