Add Cogito container, /lesson skill, CI/CD deploy pipeline

- cogito/: Content generation container (lesson watcher + paper/code
  enrichment via vLLM + x402 server). Fetches papers from arXiv,
  official code from GitHub, passes both to local LLM as context.
- .claude/skills/lesson/: Claude Code skill to record design decisions
  as lesson_learned on AIN blockchain
- .github/workflows/deploy-cogito.yml: CI/CD builds image, pushes to
  GHCR, registers deployment on AIN. Node pulls via passkey-bound
  GitHub identity (no Docker socket, no key exposure).
- architecture.md: Full system design documentation
- README.md: Updated with new architecture

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

.claude/skills/lesson/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: lesson
+description: Record a design decision as a lesson_learned on AIN blockchain. Use when the developer makes an architectural choice, picks a library, or resolves a trade-off.
+argument-hint: [decision description]
+allowed-tools: Bash(node *), Bash(npx *), Read, Grep
+---
+
+Record the following design decision as a **lesson_learned** on the AIN blockchain knowledge graph.
+
+**Decision:** $ARGUMENTS
+
+## What to capture
+
+Analyze the conversation context and extract:
+
+1. **Title** — A concise name for this decision (e.g., "Event Sourcing over CRUD for Audit Trails")
+2. **Content** — The full context:
+   - What was decided and why
+   - What alternatives were considered and why they were rejected
+   - What files/code are involved
+   - Any relevant papers, articles, or documentation that informed the decision
+3. **Summary** — 1-2 sentence summary of the decision
+4. **Topic path** — Categorize under one of: `lessons/architecture`, `lessons/engineering`, `lessons/ai`, `lessons/blockchain`, `lessons/security`, or a custom `lessons/{category}`
+5. **Tags** — Relevant keywords (the system auto-adds `lesson_learned`)
+
+## How to record
+
+Run the record script to write to AIN blockchain:
+
+```bash
+node /home/comcom/git/papers-with-claudecode/.claude/skills/lesson/scripts/record-lesson.js \
+  --title "Your title here" \
+  --content "Full decision context..." \
+  --summary "Brief summary" \
+  --topic "lessons/architecture" \
+  --tags "tag1,tag2,tag3"
+```
+
+If the script doesn't exist yet or fails, fall back to calling the Cogito container API:
+
+```bash
+curl -X POST http://localhost:3402/lesson \
+  -H "Content-Type: application/json" \
+  -d '{
+    "title": "Your title here",
+    "content": "Full decision context...",
+    "summary": "Brief summary",
+    "topicPath": "lessons/architecture",
+    "tags": ["tag1", "tag2"]
+  }'
+```
+
+## After recording
+
+Confirm to the user:
+- What was recorded (title + summary)
+- The topic path it was filed under
+- That the Cogito container will automatically enrich it with related papers and their official code repositories

.claude/skills/lesson/scripts/record-lesson.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * Record a lesson_learned to AIN blockchain.
+ * Called by the /lesson Claude Code skill.
+ *
+ * Usage:
+ *   node record-lesson.js --title "..." --content "..." --summary "..." --topic "lessons/..." --tags "tag1,tag2"
+ *
+ * Or pipe JSON via stdin:
+ *   echo '{"title":"...","content":"..."}' | node record-lesson.js
+ *
+ * Falls back to POST http://localhost:3402/lesson if ain-js is not available.
+ */
+
+const args = process.argv.slice(2);
+
+function parseArgs(argv) {
+  const result = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith('--') && i + 1 < argv.length) {
+      const key = argv[i].slice(2);
+      result[key] = argv[++i];
+    }
+  }
+  return result;
+}
+
+async function recordViaApi(lesson) {
+  const url = process.env.COGITO_URL || 'http://localhost:3402';
+  const res = await fetch(`${url}/lesson`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(lesson),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API error ${res.status}: ${text}`);
+  }
+
+  return res.json();
+}
+
+async function recordViaAinJs(lesson) {
+  // Try to use ain-js directly if available
+  try {
+    const AinModule = await import('@ainblockchain/ain-js');
+    const Ain = AinModule.default || AinModule;
+
+    const providerUrl = process.env.AIN_PROVIDER_URL || 'https://devnet-api.ainetwork.ai';
+    const privateKey = process.env.AIN_PRIVATE_KEY;
+
+    if (!privateKey) throw new Error('AIN_PRIVATE_KEY not set');
+
+    const ain = new Ain(providerUrl);
+    ain.wallet.addAndSetDefaultAccount(privateKey);
+
+    const topicPath = lesson.topicPath || 'lessons';
+    const tags = Array.isArray(lesson.tags) ? lesson.tags : (lesson.tags || '').split(',').filter(Boolean);
+
+    // Ensure topic exists
+    try {
+      const parts = topicPath.split('/');
+      const title = parts[parts.length - 1].replace(/-/g, ' ');
+      await ain.knowledge.registerTopic(topicPath, {
+        title,
+        description: `Lessons related to ${topicPath}`,
+      });
+    } catch {}
+
+    const result = await ain.knowledge.explore({
+      topicPath,
+      title: lesson.title,
+      content: lesson.content,
+      summary: lesson.summary || lesson.content.slice(0, 200),
+      depth: 2,
+      tags: ['lesson_learned', ...tags].join(','),
+    });
+
+    return { success: true, entryId: result.entryId, method: 'ain-js' };
+  } catch (err) {
+    // ain-js not available or failed, will fall back to API
+    throw err;
+  }
+}
+
+async function main() {
+  let lesson;
+
+  if (args.length > 0) {
+    const parsed = parseArgs(args);
+    lesson = {
+      title: parsed.title || 'Untitled Lesson',
+      content: parsed.content || '',
+      summary: parsed.summary || '',
+      topicPath: parsed.topic || 'lessons',
+      tags: parsed.tags ? parsed.tags.split(',') : [],
+    };
+  } else {
+    // Read from stdin
+    let input = '';
+    for await (const chunk of process.stdin) input += chunk;
+    lesson = JSON.parse(input);
+  }
+
+  if (!lesson.title || !lesson.content) {
+    console.error('Error: --title and --content are required');
+    process.exit(1);
+  }
+
+  console.log(`Recording lesson: "${lesson.title}"`);
+  console.log(`Topic: ${lesson.topicPath || 'lessons'}`);
+
+  // Try ain-js first, fall back to API
+  let result;
+  try {
+    result = await recordViaAinJs(lesson);
+  } catch {
+    try {
+      result = await recordViaApi(lesson);
+      result.method = 'api';
+    } catch (apiErr) {
+      console.error(`Failed to record lesson: ${apiErr.message}`);
+      console.error('Make sure either AIN_PRIVATE_KEY is set or the Cogito container is running on port 3402');
+      process.exit(1);
+    }
+  }
+
+  console.log(`Lesson recorded successfully!`);
+  console.log(`  Entry ID: ${result.entryId}`);
+  console.log(`  Method: ${result.method}`);
+  console.log(`  The Cogito container will enrich this with related papers + official code.`);
+}
+
+main();

.github/workflows/deploy-cogito.yml

@@ -0,0 +1,58 @@
+name: Build & Deploy Cogito
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'cogito/**'
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository_owner }}/cogito
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: cogito
+          push: true
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+
+      - name: Register deployment on AIN
+        run: |
+          cd cogito && npm ci
+          node -e "
+            const Ain = require('@ainblockchain/ain-js');
+            const ain = new Ain('${{ secrets.AIN_PROVIDER_URL }}');
+            ain.wallet.addAndSetDefaultAccount('${{ secrets.AIN_PRIVATE_KEY }}');
+            const addr = ain.wallet.defaultAccount.address;
+            ain.db.ref('/apps/knowledge/deployments/' + addr + '/cogito').setValue({
+              value: {
+                image: '${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}',
+                deployed_at: Date.now(),
+                github_sha: '${{ github.sha }}',
+                github_actor: '${{ github.actor }}',
+              },
+              nonce: -1,
+            }).then(r => console.log('Registered:', JSON.stringify(r?.result)))
+              .catch(e => console.log('Registration skipped:', e.message));
+          "