Outcome: directory seed-knowledge-manager/agent/ with empty placeholders + the operator README skeleton. No deploy yet.

Tasks:

Create seed-knowledge-manager/agent/{config,mcp/seed-cli-mcp,scripts,systemd,templates,logrotate} with stub files.

Stub seed-knowledge-manager/agent/README.md with the operator runbook outline.

Stub templates/agent-charter.md, agent-rules.md, agent-runbook.md, agent-allowlist.md (empty frontmatter + placeholder bodies).

Verify: tree seed-knowledge-manager/agent/ shows the layout; pnpm typecheck still passes (no real code yet).

Outcome: server has all OS dependencies, the km user, and Docker-based Seed daemon running and synced.

Tasks:

SSH ubuntu@oc.hyper.media. Install: python3.12 python3.12-venv pipx libsecret-1-0 libsecret-tools dbus-user-session bubblewrap nodejs npm jq curl docker.io docker-compose-plugin logrotate rsync.

Create user km, loginctl enable-linger km. Add km to docker group.

As km: mkdir -p ~/seed-daemon/data && cd ~/seed-daemon. Add compose.yaml:

services:
  seed-daemon:
    image: ghcr.io/seed-hypermedia/seed-daemon:latest
    restart: unless-stopped
    ports:
      - "127.0.0.1:55001:55001"   # HTTP
      - "127.0.0.1:55002:55002"   # gRPC
      - "55000:55000/tcp"         # P2P
      - "55000:55000/udp"
    volumes:
      - ./data:/data
    environment:
      - SEED_DAEMON_FLAGS=--data.dir=/data

docker compose up -d. Tail logs docker compose logs -f until daemon reports healthy on 127.0.0.1:55001.

Create user-systemd unit seed-daemon.service that runs docker compose up so it survives reboots.

Verify (must pass before phase 2):

curl -s http://127.0.0.1:55001/healthz (or /status) returns 200.

npx -y @seed-hypermedia/cli -s http://127.0.0.1:55001 account list works.

Daemon survives reboot.

Outcome: agent's Ed25519 key in keyring, owner has granted WRITER on the site, contact published.

Tasks (as km):

npx -y @seed-hypermedia/cli -s http://127.0.0.1:55001 key generate --name knowledge-manager --show-mnemonic. Capture mnemonic OFFLINE. Capture KM_AID.

On owner's machine (with owner key in their keyring):

seed-cli capability create --delegate <KM_AID> --role WRITER --path / --label "knowledge-manager" --key <owner>
seed-cli contact create --subject <KM_AID> --name "Knowledge Manager" --key <owner>

From km: seed-cli account capabilities <SITE_AID> confirms KM_AID is listed as WRITER on /.

Verify:

From km: create + delete a throwaway document under any path → succeeds.

Owner sees "Knowledge Manager" appear with avatar in the site UI.

Outcome: seed-knowledge-manager/agent/mcp/seed-cli-mcp/ is a working Node MCP server with unit tests, runnable on macOS without server access.

Tasks:

Set up Node package: TS + Vitest + @modelcontextprotocol/sdk. package.json name @km/seed-cli-mcp, bin: ./dist/index.js. Workspace member of pnpm root.

Implement modules:

src/governance.ts — fetches the four governance docs via seed_get_document, parses YAML frontmatter, caches 60s, returns Rules.

src/limits.ts — path allow/deny matcher (globstar), per-run / per-day counter persistence in KM_STATE_DIR/rate-counters.json.

src/seedcli.ts — typed wrapper: runSeedCli(args), captures argv/exit/stdout/stderr/ms, redacts env values, returns structured result. Force-injects --key knowledge-manager and -s ${SEED_SERVER} for write commands.

src/audit.ts — current-run dir resolution (created at process start), append-only writers for trace, llm, tools, seed-cli JSONL streams, secret redaction.

src/mentions.ts — parses Seed activity / citations responses, classifies into mention { kind: comment|doc-block, doc, blockId?, commentId?, author, text }.

src/state.ts — cursor + inbox + processed-set helpers.

src/index.ts — registers MCP tools (seed_search, seed_query_space, seed_get_document, seed_list_comments, seed_get_activity, seed_get_citations, seed_list_capabilities, seed_get_governance, seed_create_document, seed_update_document, seed_create_comment, seed_reply_comment, inbox_pop, inbox_mark_done, cursor_get, cursor_set).

Hardcoded denylist: never accept key *, capability *, account create, document delete <governance-path>.

Tests (*.test.ts, Vitest): governance YAML parsing, deny-path beats allow-path, rate caps, denylist refusal, draft-only mode forces comment-only, mention parsing for both surfaces, redaction of env values.

Build: pnpm --filter @km/seed-cli-mcp build produces dist/index.js.

Verify:

pnpm --filter @km/seed-cli-mcp test green.

Smoke run locally: MCP_DEBUG=1 node dist/index.js then send tools/list JSON-RPC over stdin → returns the expected toolset.

Outcome: nanobot gateway running on oc.hyper.media; agent has created the four governance docs in the site on first run.

Tasks (as km):

pipx install nanobot-ai. nanobot --version.

nanobot onboard (creates ~/.nanobot/{config.json,workspace/}).

rsync seed-knowledge-manager/ → ~/.nanobot/workspace/skill/ (read-only).

Deploy ~/.nanobot/secrets.env (mode 600):

DEEPSEEK_API_KEY=...
SEED_SERVER=http://127.0.0.1:55001
SEED_SITE=hm://...

Write ~/.nanobot/config.json:

{
  "providers": { "deepseek": { "apiKey": "${DEEPSEEK_API_KEY}" } },
  "agents": {
    "defaults": {
      "provider": "deepseek",
      "model": "deepseek-chat",
      "systemPrompt": "You are the Knowledge Manager for ${SEED_SITE}. Always call seed_get_governance first; obey it strictly. Methodology: workspace/skill/SKILL.md and templates under workspace/skill/templates/. Default language: en (override only if charter sets language).",
      "temperature": 0.2,
      "timezone": "UTC",
      "idleCompactAfterMinutes": 15
    }
  },
  "tools": {
    "restrictToWorkspace": true,
    "exec": { "enable": true, "sandbox": "bwrap", "pathAppend": "/usr/bin:/usr/local/bin" },
    "web": { "enable": true, "search": { "provider": "duckduckgo", "maxResults": 5 } },
    "mcpServers": {
      "seed": {
        "command": "node",
        "args": ["/home/km/km-agent/mcp/seed-cli-mcp/dist/index.js"],
        "toolTimeout": 60,
        "env": {
          "SEED_SERVER": "${SEED_SERVER}",
          "SEED_SITE": "${SEED_SITE}",
          "KM_KEY_NAME": "knowledge-manager",
          "KM_STATE_DIR": "/home/km/km-state",
          "KM_LOGS_DIR": "/home/km/km-logs"
        }
      }
    }
  },
  "channels": {}
}

Deploy nanobot-gateway.service and km-bootstrap.service (oneshot, runs nanobot agent -m "/bootstrap-governance").

systemctl --user daemon-reload && systemctl --user enable --now nanobot-gateway.

systemctl --user start km-bootstrap.service.

Verify:

The four governance docs exist in the site at /agents/knowledge-manager/{charter,rules,runbook,allowlist}.

A run dir exists under km-logs/runs/...__bootstrap__<ulid>/ with meta.json, trace.jsonl, seed-cli.jsonl showing the four document create calls.

Outcome: writer mentions in comments and documents trigger an agent reply within 2 minutes.

Tasks:

Deploy km-poll.timer/.service (60s cadence).

System prompt addendum (committed in repo): the /poll-mentions flow:

seed_get_governance → rules.

seed_list_capabilities ${SEED_SITE} → writer set.

cursor_get → token.

seed_get_activity --token <cursor> → events. Filter mentions to KM_AID.

For each mention, if author ∈ writers and not in processed.jsonl → inbox_pop queue.

For each queued mention: classify against capabilities 1–7 in SKILL.md; respond via seed_reply_comment (comment-mention) or seed_create_comment <doc>#<blockId> (doc-mention).

cursor_set newer.

Deploy km-log Bash helper to /home/km/.local/bin/km-log.

Deploy logrotate user config.

Verify:

From a writer account, comment @[Knowledge Manager](hm://<KM_AID>) what does this community know about X? → reply within 60s.

From the same account, edit a doc and add inline mention → block-anchored comment within 60s.

From a non-writer account, mention → ignored, processed.jsonl records reason: not-allowed.

km-log tail shows full event sequence with timestamps and DeepSeek reasoning_content.

Outcome: weekly bulletin, weekly gap report, monthly health report run on schedule.

Tasks:

Deploy km-boletin.{timer,service} (Mon 09:00 UTC, message /run-capability boletin --period last-7d).

Deploy km-gap.{timer,service} (Wed 10:00 UTC, message /run-capability gap-detection --period last-7d).

Deploy km-health.{timer,service} (1st of month 09:00 UTC, message /run-capability network-health --period last-30d).

Add system prompt support for /run-capability <name> --period <range> (maps capability name → SKILL section).

Verify:

systemctl --user start km-boletin.service produces a doc at /agents/knowledge-manager/state/boletin/<YYYY-WW>.

systemctl --user start km-health.service rewrites /agents/knowledge-manager/state/network-health.

Each run has its own dir under km-logs/runs/.

Outcome: operator can chat with the agent over Telegram about agent status, force a poll, query logs, toggle kill-switch.

Tasks:

Create Telegram bot via @BotFather → token. Get operator's Telegram user ID.

Add to secrets.env: TELEGRAM_TOKEN=..., OPS_TELEGRAM_ID=<numeric>.

Edit ~/.nanobot/config.json:

"channels": {
  "sendProgress": true,
  "telegram": {
    "enabled": true,
    "token": "${TELEGRAM_TOKEN}",
    "allowFrom": ["${OPS_TELEGRAM_ID}"]
  }
}

systemctl --user restart nanobot-gateway.

Extend the agent's system prompt with operator-only verbs (/status, /poll-now, /show-rules, /last-runs, /draft-only on|off). These never write to Seed; they only read state and emit human-formatted Telegram replies.

Document in operator README that allowFrom is locked to ops only — community members must use Seed comments, not Telegram.

Verify:

/start on Telegram returns a welcome.

Send /status from operator's account → bot responds with daemon health, last run time, comments-today count.

Send /status from a different Telegram account → silently ignored (allowFrom enforced).

Send /draft-only on → check next mention reply is a draft comment.

Outcome: full smoke test of every flow; logs make sense from SSH.

Tasks:

Run all 19 verification steps end-to-end (combined from earlier plan plus Telegram).

Capture screenshots / log excerpts in seed-knowledge-manager/agent/README.md.