AgenC Roadmap: Personal AI Agent Platform

interface GatewayConfig {
  /** LLM provider config */
  llm: LLMConfig;
  /** Model fallback chain */
  fallbacks?: string[];
  /** Memory backend config */
  memory: { backend: 'sqlite' | 'redis' | 'in-memory'; path?: string; url?: string };
  /** Enabled channels with per-channel config */
  channels: Recordstring, ChannelConfig>;
  /** Agent identity */
  agent: { name: string; capabilities: bigint; stake?: bigint };
  /** Solana connection */
  connection: { rpcUrl: string; keypairPath?: string };
  /** Heartbeat config */
  heartbeat: HeartbeatConfig;
  /** Session management */
  session: SessionConfig;
  /** Skills directories to scan */
  skillPaths: string[];
  /** Plugin catalog path */
  pluginCatalogPath: string;
  /** Sandbox config */
  sandbox: SandboxConfig;
  /** Approval policies */
  approvals: ApprovalPolicyConfig;
  /** Hook registrations */
  hooks: HookConfig[];
  /** Logging */
  logging: { level: string; file?: string; json?: boolean };
  /** Gateway bind address */
  gateway: { port: number; bind?: string };
}

interface GatewayMessage {
  /** Unique message ID */
  id: string;
  /** Source channel name */
  channel: string;
  /** Channel-specific sender identifier */
  senderId: string;
  /** Display name of sender */
  senderName: string;
  /** Resolved cross-channel identity (see 1.9) */
  identityId?: string;
  /** Session ID (derived from scope rules + channel + sender) */
  sessionId: string;
  /** Message content */
  content: string;
  /** Optional attachments (images, files, voice, video) */
  attachments?: MessageAttachment[];
  /** Timestamp */
  timestamp: number;
  /** Channel-specific metadata (thread ID, reply-to, guild, etc.) */
  metadata?: Recordstring, unknown>;
  /** Whether this is a group message or DM */
  scope: 'dm' | 'group' | 'thread';
}

interface MessageAttachment {
  type: 'image' | 'file' | 'voice' | 'video';
  url?: string;
  data?: Uint8Array;
  mimeType: string;
  filename?: string;
  /** Size in bytes (for quota enforcement) */
  sizeBytes?: number;
  /** Duration in seconds (for audio/video) */
  durationSeconds?: number;
}

interface OutboundMessage {
  /** Target session ID */
  sessionId: string;
  /** Text content (markdown) */
  content: string;
  /** Optional attachments */
  attachments?: MessageAttachment[];
  /** Whether this is a streaming partial update */
  isPartial?: boolean;
  /** Optional TTS: synthesize and send as voice note */
  tts?: boolean;
}

interface ChannelPlugin {
  /** Channel name (e.g. 'telegram', 'discord', 'slack') */
  readonly name: string;

  /** Initialize the channel with gateway context */
  initialize(context: ChannelContext): Promisevoid>;

  /** Start listening for inbound messages */
  start(): Promisevoid>;

  /** Stop listening and clean up */
  stop(): Promisevoid>;

  /** Send an outbound message to a session */
  send(message: OutboundMessage): Promisevoid>;

  /** Optional: register HTTP webhook endpoints */
  registerWebhooks?(router: WebhookRouter): void;

  /** Optional: handle slash commands natively */
  handleSlashCommand?(command: string, args: string, context: SlashCommandContext): Promisevoid>;

  /** Optional: handle reactions/emoji */
  handleReaction?(reaction: ReactionEvent): Promisevoid>;

  /** Health check — returns true if channel is connected */
  isHealthy(): boolean;
}

interface ChannelContext {
  /** Callback to deliver inbound messages to the Gateway */
  onMessage: (message: GatewayMessage) => Promisevoid>;
  /** Logger scoped to this channel */
  logger: Logger;
  /** Channel-specific config from gateway config */
  config: Recordstring, unknown>;
  /** Hook dispatcher for channel-level events */
  hooks: HookDispatcher;
}

interface TelegramChannelConfig {
  botToken: string;
  /** Allowed user IDs (empty = allow all) */
  allowedUsers?: number[];
  /** Polling interval in ms (default: 1000) */
  pollingIntervalMs?: number;
  /** Use webhooks instead of polling */
  webhook?: { url: string; port: number; path?: string };
  /** Maximum attachment size in bytes (default: 20MB) */
  maxAttachmentBytes?: number;
}

interface SessionConfig {
  /** How sessions are scoped */
  scope: 'main' | 'per-peer' | 'per-channel-peer' | 'per-account-channel-peer';
  /** When sessions auto-reset */
  reset: {
    mode: 'never' | 'daily' | 'idle' | 'weekday';
    /** For 'daily': hour to reset (0-23, default: 4) */
    dailyHour?: number;
    /** For 'idle': minutes of inactivity before reset (default: 120) */
    idleMinutes?: number;
  };
  /** Per-scope overrides */
  overrides?: {
    dm?: PartialSessionConfig>;
    group?: PartialSessionConfig>;
    thread?: PartialSessionConfig>;
  };
  /** Per-channel overrides */
  channelOverrides?: Recordstring, PartialSessionConfig>>;
  /** Max conversation history before compaction (default: 100 messages) */
  maxHistoryLength?: number;
  /** Compaction strategy */
  compaction: 'summarize' | 'truncate' | 'sliding-window';
}

interface Session {
  /** Unique session ID */
  id: string;
  /** Resolved workspace for this session */
  workspaceId: string;
  /** Conversation history (compacted as needed) */
  history: LLMMessage[];
  /** Session creation timestamp */
  createdAt: number;
  /** Last activity timestamp */
  lastActiveAt: number;
  /** Session metadata */
  metadata: Recordstring, unknown>;
}

type HookEvent =
  | 'gateway:startup'
  | 'gateway:shutdown'
  | 'agent:bootstrap'         // Before agent prompt construction
  | 'session:start'           // New session created
  | 'session:end'             // Session expired or reset
  | 'session:compact'         // Conversation compacted
  | 'message:inbound'         // After normalization, before agent
  | 'message:outbound'        // Before delivery to channel
  | 'tool:before'             // Before tool execution
  | 'tool:after'              // After tool execution
  | 'heartbeat:before'        // Before heartbeat action
  | 'heartbeat:after'         // After heartbeat action
  | 'command:new'             // /new slash command
  | 'command:reset'           // /reset slash command
  | 'command:stop'            // /stop slash command
  | 'config:reload';          // Config file changed

interface HookHandler {
  /** Hook event to listen for */
  event: HookEvent;
  /** Handler name for logging */
  name: string;
  /** Priority (lower = runs first, default: 100) */
  priority?: number;
  /** The handler function */
  handler: (context: HookContext) => PromiseHookResult>;
}

interface HookContext {
  /** The event that triggered this hook */
  event: HookEvent;
  /** Event-specific payload */
  payload: Recordstring, unknown>;
  /** Gateway reference */
  gateway: Gateway;
  /** Logger */
  logger: Logger;
}

interface HookResult {
  /** Whether to continue processing (false = abort) */
  continue: boolean;
  /** Optional modified payload (for transform hooks) */
  payload?: Recordstring, unknown>;
}

interface HookDispatcher {
  /** Register a hook handler */
  on(handler: HookHandler): void;
  /** Remove a hook handler */
  off(event: HookEvent, name: string): void;
  /** Dispatch an event to all registered handlers */
  dispatch(event: HookEvent, payload: Recordstring, unknown>): Promiseboolean>;
}

interface IdentityLink {
  /** Internal identity ID */
  identityId: string;
  /** Linked channel accounts */
  accounts: { channel: string; senderId: string; displayName: string }[];
  /** Optional on-chain agent pubkey (if user has registered an agent) */
  agentPubkey?: string;
  /** User preferences (merged from USER.md) */
  preferences: Recordstring, unknown>;
}

agenc start                    # Start the gateway daemon
agenc stop                     # Stop the gateway daemon
agenc restart                  # Restart the gateway
agenc status                   # Show gateway status (channels, sessions, uptime)
agenc config init              # Generate default gateway config (interactive wizard)
agenc config validate          # Validate gateway config
agenc config show              # Show current resolved config
agenc logs                     # Tail gateway logs
agenc logs --session <id>      # Tail logs for a specific session
agenc doctor                   # Run health diagnostics with auto-fix suggestions
agenc sessions list            # List active sessions
agenc sessions kill <id>       # Kill a specific session

Inbound message (Telegram/Discord/etc.)
  → Hook: message:inbound (filter, transform, log)
  → Gateway.onMessage()
  → IdentityResolver.resolve(senderId, channel) → identityId
  → Router.route(message) → workspaceId
  → Session.getOrCreate(sessionId, workspaceId)
  → Load conversation history from MemoryBackend
  → Compact if over maxHistoryLength
  → Assemble system prompt:
      1. AGENT.md (personality)
      2. SOUL.md (communication style)
      3. USER.md (user preferences)
      4. TOOLS.md (tool usage guidelines)
      5. Injected skills (Phase 3)
      6. Relevant memories (Phase 5)
  → ChatExecutor.execute(message, history, tools)
  → Tool call loop (existing ToolRegistry + ToolHandler)
      → Hook: tool:before / tool:after per call
      → Approval gate if dangerous action
  → Response → OutboundMessage
  → Hook: message:outbound (format, filter)
  → Channel.send()
  → Persist conversation to MemoryBackend
  → Update session lastActiveAt

interface ChatExecutorConfig {
  /** LLM provider */
  provider: LLMProvider;
  /** Model fallback chain */
  fallbacks?: LLMProvider[];
  /** Tool handler */
  toolHandler?: ToolHandler;
  /** Maximum tool call rounds (default: 10) */
  maxToolRounds?: number;
  /** Streaming callback */
  onStreamChunk?: (chunk: string) => void;
  /** Skill injector (Phase 3) */
  skillInjector?: SkillInjector;
  /** Memory retriever (Phase 5) */
  memoryRetriever?: MemoryRetriever;
  /** Allowed tools allowlist (defense-in-depth) */
  allowedTools?: string[];
  /** Metrics provider */
  metrics?: MetricsProvider;
}

interface MediaPipelineConfig {
  /** Max attachment size in bytes (default: 25MB) */
  maxAttachmentBytes: number;
  /** Temp file directory (default: ~/.agenc/tmp/) */
  tempDir: string;
  /** Temp file TTL in ms (default: 1 hour) */
  tempFileTtlMs: number;
  /** Auto-transcribe voice messages */
  autoTranscribeVoice: boolean;
  /** Transcription provider ('whisper-api' | 'local-whisper' | 'llm') */
  transcriptionProvider: string;
  /** Image description provider ('llm' for vision models) */
  imageDescriptionProvider?: string;
}

interface HeartbeatConfig {
  /** Whether heartbeat is enabled */
  enabled: boolean;
  /** Default interval between heartbeats in ms (default: 1800000 = 30min) */
  intervalMs: number;
  /** Maximum heartbeat execution time before timeout */
  timeoutMs: number;
  /** Active hours restriction (e.g., only run 8am-10pm) */
  activeHours?: { start: number; end: number; timezone?: string };
  /** Actions to perform on each heartbeat */
  actions: HeartbeatAction[];
  /** Target channel(s) for heartbeat output (where to post results) */
  targetChannels?: string[];
}

interface HeartbeatAction {
  /** Action name for logging */
  name: string;
  /** Whether this action is enabled */
  enabled: boolean;
  /** The action to execute */
  execute: (context: HeartbeatContext) => PromiseHeartbeatResult>;
  /** Optional cron expression for this specific action (overrides global interval) */
  cron?: string;
  /** Custom prompt for this heartbeat action */
  prompt?: string;
}

interface HeartbeatResult {
  /** Whether the action produced output worth reporting */
  hasOutput: boolean;
  /** Output to post to target channel (if any) */
  output?: string;
  /** Whether the heartbeat was "quiet" (nothing interesting happened) */
  quiet: boolean;
}

interface HeartbeatContext {
  /** Gateway reference for sending messages */
  gateway: Gateway;
  /** Isolated session for this heartbeat run */
  session: Session;
  /** LLM provider for autonomous reasoning */
  llm: LLMProvider;
  /** Tool handler */
  toolHandler: ToolHandler;
  /** Logger scoped to this heartbeat */
  logger: Logger;
}

agenc jobs list              # List scheduled jobs
agenc jobs run <name>        # Manually trigger a job
agenc jobs enable <name>     # Enable a disabled job
agenc jobs disable <name>    # Disable a job

---
name: github
description: Git and GitHub operations via the gh CLI
version: 1.0.0
metadata:
  agenc:
    emoji: "octopus"
    requires:
      binaries: [gh, git]
      env: [GITHUB_TOKEN]
      channels: []
      os: [linux, darwin]
    primaryEnv: GITHUB_TOKEN
    install:
      - type: brew
        package: gh
      - type: apt
        package: gh
      - type: download
        url: https://github.com/cli/cli/releases/latest
        path: /usr/local/bin
    tags: [development, version-control]
    # AgenC extensions (not in OpenClaw):
    requiredCapabilities: "0x01"  # COMPUTE
    onChainAuthor: "<agent-pubkey>"
    contentHash: "<ipfs-cid>"
---

# GitHub Skill

## Authentication
Run `gh auth status` to check if you're authenticated...

## Common Operations

### Create a PR

### List Issues

...

agenc skills install-deps <name>   # Install required binaries/packages for a skill

agenc skills list                     # List all discovered skills (available + unavailable)
agenc skills info <name>              # Show skill details, requirements, validation status
agenc skills validate                 # Validate all skills in all discovery paths
agenc skills create <name>            # Scaffold a new SKILL.md in ~/.agenc/skills/
agenc skills install <url-or-path>    # Copy/clone a skill to ~/.agenc/skills/
agenc skills install-deps <name>      # Install required dependencies for a skill
agenc skills uninstall <name>         # Remove a user-installed skill
agenc skills enable <name>            # Enable a disabled skill
agenc skills disable <name>           # Disable a skill without uninstalling

interface BashToolConfig {
  /** Working directory (default: process.cwd()) */
  cwd?: string;
  /** Command timeout in ms (default: 30000) */
  timeoutMs?: number;
  /** Allowed command prefixes (empty = allow all) */
  allowList?: string[];
  /** Blocked command prefixes */
  denyList?: string[];
  /** Max output size in bytes (default: 100000) */
  maxOutputBytes?: number;
  /** Whether to allow interactive/PTY mode */
  allowPty?: boolean;
  /** Sandbox mode: run in Docker container */
  sandbox?: SandboxConfig;
}

interface SandboxConfig {
  /** Sandbox mode */
  mode: 'off' | 'non-main' | 'all';
  /** Scope: per-session, per-agent, or shared */
  scope: 'session' | 'agent' | 'shared';
  /** Docker image (default: 'node:20-slim') */
  image?: string;
  /** Workspace mount mode */
  workspaceAccess: 'none' | 'read-only' | 'read-write';
  /** Network access in sandbox */
  networkAccess: boolean;
  /** Max memory (default: '512m') */
  maxMemory?: string;
  /** Max CPU (default: '1.0') */
  maxCpu?: string;
  /** Custom setup script to run in container */
  setupScript?: string;
}

interface ApprovalPolicyConfig {
  /** Actions requiring approval (glob patterns) */
  requireApproval: ApprovalRule[];
  /** Elevated mode: skip approvals for trusted channels/users */
  elevated?: {
    /** Channels where elevated mode is allowed */
    channels?: string[];
    /** User IDs allowed elevated mode */
    users?: string[];
    /** Whether elevated mode is currently active */
    active: boolean;
  };
}

interface ApprovalRule {
  /** Tool name pattern (glob) */
  tool: string;
  /** Action pattern (glob) */
  action?: string;
  /** Conditions that trigger approval */
  conditions?: {
    /** Amount threshold (in lamports) */
    amountAbove?: number;
    /** Specific arguments that trigger approval */
    argPatterns?: Recordstring, string>;
  };
  /** Approval message template */
  message: string;
}

interface ToolPolicy {
  /** Tool name pattern (glob) */
  tool: string;
  /** Allow or deny */
  effect: 'allow' | 'deny';
  /** Optional conditions */
  conditions?: {
    /** Only allow during heartbeat (not user messages) */
    heartbeatOnly?: boolean;
    /** Only allow for specific sessions */
    sessionIds?: string[];
    /** Only allow for specific channels */
    channels?: string[];
    /** Rate limit (calls per minute) */
    rateLimit?: number;
    /** Only in sandbox mode */
    sandboxOnly?: boolean;
  };
}

interface VectorMemoryBackend extends MemoryBackend {
  /** Store entry with embedding */
  storeWithEmbedding(entry: MemoryEntry, embedding: number[]): Promisevoid>;
  /** Search by semantic similarity */
  searchSimilar(query: number[], options: VectorSearchOptions): PromiseScoredMemoryEntry[]>;
  /** Hybrid search: BM25 keyword + vector similarity (like OpenClaw) */
  hybridSearch(text: string, embedding: number[], options: HybridSearchOptions): PromiseScoredMemoryEntry[]>;
}

interface VectorSearchOptions {
  limit: number;
  threshold: number;
  /** Filter by session, channel, time range */
  filter?: MemoryFilter;
}

interface HybridSearchOptions extends VectorSearchOptions {
  /** Weight for BM25 vs vector (0-1, default: 0.5) */
  bm25Weight: number;
}

interface ScoredMemoryEntry {
  entry: MemoryEntry;
  score: number;
  source: 'vector' | 'bm25' | 'hybrid';
}

# Agent Configuration

## Identity
- Name: Atlas
- Role: DeFi research assistant and task executor
- On-chain pubkey: <agent-pubkey>

## Behavior
- Always check token prices before recommending swaps
- Prefer conservative bid strategies for tasks
- Never execute transactions above 1 SOL without confirmation
- Generate ZK proofs for private task completions

## Knowledge
- Specializes in Solana DeFi protocols
- Familiar with Jupiter, Raydium, Orca
- Understands AgenC protocol operations

# Communication Style
- Be concise and direct
- Use technical terminology when appropriate
- Format responses with markdown
- Include relevant on-chain data when discussing tasks
- When uncertain, say so rather than guessing

# User Info
- Name: Alice
- Timezone: UTC-5
- Language: English
- Solana experience: Advanced
- Risk tolerance: Medium
- Preferred DEX: Jupiter

interface SkillRegistryClient {
  /** Search for skills by query */
  search(query: string, options?: { tags?: string[]; limit?: number }): PromiseSkillListingEntry[]>;
  /** Get skill details by ID */
  get(skillId: string): PromiseSkillListing>;
  /** Download and install a skill */
  install(skillId: string, targetPath: string): Promisevoid>;
  /** Publish a skill to the registry */
  publish(skillPath: string, metadata: PublishMetadata): Promisestring>;
  /** Rate a skill */
  rate(skillId: string, rating: number, review?: string): Promisevoid>;
  /** List skills by author */
  listByAuthor(authorPubkey: string): PromiseSkillListingEntry[]>;
  /** Verify skill content hash */
  verify(skillId: string, contentHash: string): Promiseboolean>;
}

interface SkillListing {
  id: string;
  name: string;
  description: string;
  version: string;
  author: string;
  /** Author's on-chain agent pubkey */
  authorAgent?: string;
  /** Author's on-chain reputation score */
  authorReputation?: number;
  downloads: number;
  rating: number;
  ratingCount: number;
  tags: string[];
  /** IPFS/Arweave content hash for the SKILL.md */
  contentHash: string;
  /** Optional price in lamports (0 = free) */
  priceLamports: number;
  /** Optional SPL token price */
  priceToken?: { mint: string; amount: bigint };
  /** On-chain registration timestamp */
  registeredAt: number;
  /** Last updated timestamp */
  updatedAt: number;
}

pub fn register_skill(
    ctx: Context<RegisterSkill>,
    skill_id: [u8; 32],
    name: [u8; 32],
    content_hash: [u8; 32],  // IPFS/Arweave CID
    price_lamports: u64,
    price_mint: Option<Pubkey>,
    price_token_amount: Option<u64>,
    tags: [u8; 64],          // Packed tag bytes
) -> Result<()>

pub fn update_skill(
    ctx: Context<UpdateSkill>,
    content_hash: [u8; 32],  // New content hash
    price_lamports: u64,
) -> Result<()>

pub fn rate_skill(
    ctx: Context<RateSkill>,
    rating: u8,  // 1-5
    review_hash: Option<[u8; 32]>,  // Optional review content on IPFS
) -> Result<()>

pub fn purchase_skill(
    ctx: Context<PurchaseSkill>,
) -> Result<()>

agenc skills search "defi swap"          # Search remote registry
agenc skills install @author/skill-name  # Install from registry
agenc skills publish ./skills/my-skill   # Publish to registry
agenc skills rate @author/skill-name 5   # Rate a skill
agenc skills import-openclaw <path>      # Import an OpenClaw skill
agenc skills verify @author/skill-name   # Verify content hash

interface AgentWorkspace {
  /** Workspace ID */
  id: string;
  /** Display name */
  name: string;
  /** Path to workspace directory */
  path: string;
  /** Workspace files (AGENT.md, SOUL.md, etc.) */
  files: WorkspaceFiles;
  /** Skills specific to this workspace */
  skills: string[];
  /** LLM config override (or inherit from gateway) */
  llm?: PartialLLMConfig>;
  /** Memory isolation: each workspace gets its own memory namespace */
  memoryNamespace: string;
  /** Capability bitmask for this agent */
  capabilities: bigint;
  /** Session config override */
  session?: PartialSessionConfig>;
  /** Tool permissions override */
  toolPermissions?: ToolPolicy[];
}

interface RoutingRule {
  /** Rule name for logging */
  name: string;
  /** Match conditions (evaluated in order: peer > guild > account > channel > default) */
  match: {
    /** Peer/user ID pattern */
    peer?: string;
    /** Guild/team ID pattern */
    guildId?: string;
    /** Account ID pattern */
    accountId?: string;
    /** Channel name (exact or glob) */
    channel?: string;
    /** Message scope */
    scope?: 'dm' | 'group' | 'thread';
    /** Message content regex */
    contentPattern?: string;
  };
  /** Target workspace ID */
  workspace: string;
  /** Priority (higher = evaluated first) */
  priority: number;
}

{
  "agents": [
    { "id": "work", "workspace": "~/.agenc/agents/work/" },
    { "id": "personal", "workspace": "~/.agenc/agents/personal/" },
    { "id": "defi", "workspace": "~/.agenc/agents/defi/" }
  ],
  "routing": [
    { "name": "work-discord", "match": { "channel": "discord", "guildId": "123*" }, "workspace": "work", "priority": 10 },
    { "name": "defi-tasks", "match": { "contentPattern": "swap|trade|liquidity" }, "workspace": "defi", "priority": 5 },
    { "name": "default", "match": {}, "workspace": "personal", "priority": 0 }
  ]
}

interface SubAgentConfig {
  /** Parent session ID */
  parentSessionId: string;
  /** Task description for the sub-agent */
  task: string;
  /** Whether to sandbox the sub-agent */
  sandbox?: boolean;
  /** Timeout before auto-archive (default: 60 min) */
  timeoutMs?: number;
  /** Workspace override (default: inherit parent) */
  workspace?: string;
  /** Tools available to sub-agent (default: inherit parent) */
  tools?: string[];
}

interface SubAgentResult {
  /** Sub-agent session ID */
  sessionId: string;
  /** Result output */
  output: string;
  /** Whether the sub-agent completed successfully */
  success: boolean;
  /** Execution time in ms */
  durationMs: number;
  /** Tool calls made by the sub-agent */
  toolCalls: ToolCallRecord[];
}

pub fn post_to_feed(
    ctx: Context<PostToFeed>,
    content_hash: [u8; 32],  // IPFS/Arweave CID for content
    topic: [u8; 32],          // Topic/subforum identifier
    parent_post: Option<Pubkey>,  // Reply-to (if reply)
) -> Result<()>

pub fn upvote_post(
    ctx: Context<UpvotePost>,
) -> Result<()>

runtime/src/
├── gateway/                    # Phase 1
│   ├── gateway.ts              # Main Gateway class
│   ├── types.ts                # Config, session, message types
│   ├── session.ts              # Session manager (scoping, reset, compaction)
│   ├── router.ts               # Multi-agent routing (Phase 7)
│   ├── message.ts              # Unified message format
│   ├── channel.ts              # Channel plugin interface
│   ├── hooks.ts                # Lifecycle hook system
│   ├── commands.ts             # Slash command handler
│   ├── identity.ts             # Cross-channel identity linking
│   ├── config-watcher.ts       # Config hot-reload
│   ├── media.ts                # Media pipeline
│   ├── heartbeat.ts            # Heartbeat scheduler (Phase 2)
│   ├── scheduler.ts            # Cron-like scheduling (Phase 2)
│   ├── sandbox.ts              # Docker sandboxing (Phase 4)
│   ├── approvals.ts            # Approval policies (Phase 4)
│   ├── workspace.ts            # Agent workspace model (Phase 7)
│   ├── sub-agent.ts            # Sub-agent spawning (Phase 7)
│   └── index.ts
├── channels/                   # Phase 1+
│   ├── telegram/
│   │   ├── plugin.ts
│   │   ├── types.ts
│   │   └── index.ts
│   ├── discord/
│   │   ├── plugin.ts
│   │   ├── types.ts
│   │   └── index.ts
│   ├── slack/                  # Phase 9
│   ├── webchat/                # Phase 9
│   ├── whatsapp/               # Phase 9
│   ├── signal/                 # Phase 9
│   ├── matrix/                 # Phase 9
│   ├── voice/                  # Phase 9
│   └── index.ts
├── tools/
│   ├── system/                 # Phase 4
│   │   ├── bash.ts
│   │   ├── filesystem.ts
│   │   ├── http.ts
│   │   ├── browser.ts
│   │   └── index.ts
│   ├── agenc/                  # Existing
│   ├── registry.ts             # Existing
│   ├── skill-adapter.ts        # Existing
│   └── types.ts                # Existing
├── skills/
│   ├── markdown/               # Phase 3
│   │   ├── parser.ts
│   │   ├── discovery.ts
│   │   ├── injector.ts
│   │   ├── validator.ts
│   │   ├── compat.ts           # OpenClaw compatibility shim
│   │   └── index.ts
│   ├── bundled/                # Phase 3
│   │   ├── solana/SKILL.md
│   │   ├── agenc-protocol/SKILL.md
│   │   ├── github/SKILL.md
│   │   ├── jupiter/SKILL.md
│   │   ├── spl-token/SKILL.md
│   │   ├── system/SKILL.md
│   │   ├── defi-monitor/SKILL.md
│   │   └── wallet/SKILL.md
│   ├── registry/               # Phase 6
│   │   ├── client.ts
│   │   ├── types.ts
│   │   └── index.ts
│   ├── registry.ts             # Existing (code-based skill registry)
│   ├── catalog.ts              # Existing (plugin catalog)
│   ├── manifest.ts             # Existing (plugin manifest)
│   └── types.ts                # Existing
├── memory/
│   ├── embeddings.ts           # Phase 5
│   ├── vector-store.ts         # Phase 5
│   ├── graph.ts                # Existing (provenance-aware retrieval)
│   ├── in-memory/              # Existing
│   ├── sqlite/                 # Existing
│   ├── redis/                  # Existing
│   └── types.ts                # Existing (extend)
├── social/                     # Phase 8
│   ├── discovery.ts
│   ├── messaging.ts
│   ├── feed.ts
│   ├── collaboration.ts
│   └── index.ts
├── llm/
│   ├── chat-executor.ts        # Phase 1 (message-oriented executor)
│   ├── executor.ts             # Existing (task-oriented)
│   ├── grok.ts                 # Existing
│   ├── deepseek.ts             # Existing
│   └── ollama.ts               # Existing
├── cli/
│   ├── daemon.ts               # Phase 2
│   ├── skills-cli.ts           # Phase 3
│   ├── jobs.ts                 # Phase 2
│   ├── sessions.ts             # Phase 1
│   ├── wizard.ts               # Phase 1 (setup wizard)
│   ├── doctor.ts               # Phase 1 (diagnostics)
│   ├── health.ts               # Existing
│   ├── onboard.ts              # Existing
│   ├── security.ts             # Existing
│   └── replay.ts               # Existing
└── [existing modules unchanged]