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:

  1. seed_get_governance → rules.

  2. seed_list_capabilities ${SEED_SITE} → writer set.

  3. cursor_get → token.

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

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

  6. 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).

  7. 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.