@10et/cli 1.0.0

package/packages/pi/skills/x-algorithm/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: x-algorithm
+description: X/Twitter For You feed ranking algorithm - optimize tweets for maximum reach
+metadata:
+  tags: twitter, x, algorithm, social, ranking, engagement
+  source: https://github.com/xai-org/x-algorithm
+---
+
+# X Algorithm Skill
+
+Optimize tweets and threads for the X (Twitter) For You feed algorithm.
+
+## How the Algorithm Works
+
+The X For You feed uses a Grok-based Phoenix transformer that predicts engagement probabilities for each tweet. No hand-engineered features—it learns entirely from engagement patterns.
+
+### The Formula
+
+```
+Final Score = Σ (weight × P(action))
+```
+
+Each tweet gets scored by predicting the probability you'll take various actions, then weighting them.
+
+### What It Predicts
+
+**Positive signals (boost score):**
+| Signal | What It Measures |
+|--------|------------------|
+| `P(favorite)` | Likelihood of like |
+| `P(reply)` | Likelihood of reply |
+| `P(repost)` | Likelihood of repost |
+| `P(quote)` | Likelihood of quote tweet |
+| `P(click)` | Likelihood of clicking through |
+| `P(profile_click)` | Likelihood of visiting author's profile |
+| `P(video_view)` | Likelihood of watching video |
+| `P(photo_expand)` | Likelihood of expanding image |
+| `P(share)` | Likelihood of sharing externally |
+| `P(dwell)` | Time spent reading/viewing |
+| `P(follow_author)` | Likelihood of following |
+
+**Negative signals (reduce score):**
+| Signal | What It Measures |
+|--------|------------------|
+| `P(not_interested)` | Likelihood of "Not interested" |
+| `P(block_author)` | Likelihood of blocking |
+| `P(mute_author)` | Likelihood of muting |
+| `P(report)` | Likelihood of reporting |
+
+### Additional Ranking Factors
+
+- **Author Diversity**: Repeated posts from same author get attenuated
+- **Out-of-Network Boost**: Discovered content (not from follows) gets special scoring
+- **Candidate Isolation**: Each tweet scored independently
+
+## Commands
+
+```
+/x-algorithm analyze [tweet]     # Score a tweet draft
+/x-algorithm optimize [tweet]    # Suggest improvements
+/x-algorithm signals             # Show all ranking signals
+/x-algorithm hooks               # Generate high-engagement hooks
+```
+
+## Usage
+
+### Analyzing a Tweet
+
+```
+/x-algorithm analyze "Just shipped a new feature"
+
+ANALYSIS:
+┌─────────────────────────────────────────────────┐
+│  Tweet: "Just shipped a new feature"            │
+├─────────────────────────────────────────────────┤
+│  Predicted signals:                             │
+│  ├─ P(favorite)      LOW   - no emotional hook  │
+│  ├─ P(reply)         LOW   - no question/gap    │
+│  ├─ P(repost)        LOW   - no value to share  │
+│  ├─ P(quote)         LOW   - nothing to add to  │
+│  ├─ P(dwell)         LOW   - too short          │
+│  └─ P(not_interested) MED  - generic update     │
+│                                                 │
+│  Overall: WEAK                                  │
+│                                                 │
+│  Issues:                                        │
+│  • No specificity (what feature? why care?)     │
+│  • No emotional trigger                         │
+│  • No reason to engage                          │
+└─────────────────────────────────────────────────┘
+
+Optimize? (yes/no)
+```
+
+### Optimizing a Tweet
+
+```
+/x-algorithm optimize "Just shipped a new feature"
+
+OPTIMIZED VERSIONS:
+
+v1 (curiosity gap):
+"The feature everyone asked for just shipped.
+
+Took 6 months. Here's why it was worth the wait:"
+
+v2 (social proof):
+"1,247 people requested this feature.
+
+Today we shipped it.
+
+[screenshot]"
+
+v3 (contrarian):
+"Everyone said this feature was impossible.
+
+We built it anyway.
+
+Here's how:"
+
+---
+
+Which version, or iterate?
+```
+
+## Optimization Principles
+
+### Maximize Positive Signals
+
+**For P(favorite) - likes:**
+- Strong opinion or take
+- Relatable observation
+- Emotional resonance
+- Beautiful visually
+
+**For P(reply) - replies:**
+- Ask a question
+- Create a knowledge gap
+- Be slightly wrong (people love to correct)
+- Request input
+
+**For P(repost) - reposts:**
+- Provide shareable value (tips, insights)
+- Create "I wish I said that" moments
+- Make people look smart for sharing
+
+**For P(quote) - quotes:**
+- Leave room for commentary
+- Take a stance others want to respond to
+- Share something people want to add context to
+
+**For P(dwell) - time on tweet:**
+- Longer, readable content
+- Images that require study
+- Threads with substance
+- Videos
+
+**For P(follow) - new followers:**
+- Demonstrate unique expertise
+- Show personality
+- Consistent topic/niche
+
+### Minimize Negative Signals
+
+**Avoid P(not_interested):**
+- Don't be generic
+- Don't repeat what everyone says
+- Don't post off-topic
+
+**Avoid P(block/mute):**
+- Don't be annoying
+- Don't spam
+- Don't be hostile
+- Don't engage in bad faith
+
+**Avoid P(report):**
+- Don't violate ToS
+- Don't harass
+- Don't spread misinfo
+
+## High-Engagement Patterns
+
+### The Hook Patterns
+
+```
+1. CURIOSITY GAP
+   "I spent 3 years learning [X]. Here's what I wish I knew:"
+
+2. CONTRARIAN
+   "Unpopular opinion: [hot take]"
+
+3. STORY OPENER
+   "In 2019 I was [relatable struggle]. Now I [impressive outcome]."
+
+4. SPECIFIC NUMBER
+   "I've [done X] 847 times. Here's what works:"
+
+5. BEFORE/AFTER
+   "I used to [common mistake]. Then I learned [insight]."
+
+6. QUESTION
+   "What's one thing you wish you learned earlier about [X]?"
+```
+
+### Thread Structures That Work
+
+```
+LISTICLE:
+"10 [things] about [topic]:"
+→ High dwell, easy to repost individual tweets
+
+BUILD-UP:
+1. Hook
+2. Context
+3. Insight
+4. Proof
+5. Implication
+6. CTA
+→ Maximizes dwell across thread
+
+STORY:
+1. "It was 2AM when..."
+2. Rising action
+3. Crisis point
+4. Resolution
+5. Lesson
+6. CTA
+→ High engagement, emotional resonance
+```
+
+### Visual Content
+
+```
+IMAGES:
+- Screenshots > stock photos
+- Before/after comparisons
+- Data visualizations
+- Behind-the-scenes
+
+VIDEOS:
+- Hook in first 1-3 seconds
+- Subtitles (most watch muted)
+- Native upload > links
+- <2 min optimal
+```
+
+## Integration with /content
+
+When using `/content thread` or `/content post`, the X algorithm principles are automatically applied:
+
+```
+/content thread "our new pricing model"
+
+Applying X algorithm optimization...
+├─ Hook pattern: SPECIFIC NUMBER
+├─ Thread structure: BUILD-UP
+├─ Engagement triggers: curiosity, social proof
+└─ Visual: screenshot recommendation
+
+[generates thread with algorithm principles]
+```
+
+## Author Diversity Consideration
+
+The algorithm attenuates repeated authors. Posting strategy matters:
+
+```
+SUBOPTIMAL:
+Post → Post → Post → Post (same hour)
+Algorithm reduces later posts' reach
+
+BETTER:
+Post → [gap] → Post → [gap] → Post
+Each post gets full scoring potential
+```
+
+## Out-of-Network Discovery
+
+To reach beyond your followers:
+
+```
+- Quote tweet popular accounts (your take on their content)
+- Reply meaningfully to trending topics
+- Create highly repostable content (others share to their network)
+- Post content that generates quotes (your reach + quoter's reach)
+```
+
+## Metrics to Watch
+
+After posting, monitor:
+
+| Metric | What It Tells You |
+|--------|-------------------|
+| Impressions from For You | Algorithm reach |
+| Impressions from profile | Direct followers |
+| Engagement rate | Content quality signal |
+| Quote:Repost ratio | How "discussable" content is |
+| Reply quality | Community engagement depth |
+
+## Source
+
+Based on the open-sourced X algorithm:
+https://github.com/xai-org/x-algorithm
+
+The algorithm is continuously updated. Check the repo for latest changes.

package/packages/pi/teams/dev-team.yaml

@@ -0,0 +1,63 @@
+name: dev-team
+description: JFL dev team — focused on code quality, tests, and shipping
+
+agents:
+  - name: scout
+    role: Research and discovery
+    description: Researches libraries, APIs, and technical approaches
+    model: claude-sonnet-4-6
+    skills:
+      - search
+      - agent-browser
+    color: cyan
+    health_interval: 5000
+
+  - name: planner
+    role: Architecture and design
+    description: Designs systems, writes specs, plans implementation
+    model: claude-opus-4-6
+    skills:
+      - spec
+    color: blue
+    health_interval: 5000
+
+  - name: builder
+    role: Implementation
+    description: Primary coding agent — writes features and fixes bugs
+    model: claude-sonnet-4-6
+    skills:
+      - react-best-practices
+      - fly-deploy
+    color: green
+    default: true
+    health_interval: 5000
+
+  - name: reviewer
+    role: Code review
+    description: Reviews PRs, finds bugs, suggests improvements
+    model: claude-sonnet-4-6
+    skills:
+      - spec
+    color: orange
+    health_interval: 5000
+
+  - name: tester
+    role: Testing and validation
+    description: Writes tests, runs evals, validates behavior
+    model: claude-sonnet-4-6
+    skills:
+      - eval
+    color: yellow
+    health_interval: 5000
+
+orchestration:
+  mode: rpc
+  extension: "@jfl/pi/extensions/index.js"
+  map_events:
+    - eval:scored
+    - review:findings
+    - task:requested
+    - agent:health
+  peter_parker:
+    enabled: true
+    max_iterations: 3

package/packages/pi/teams/gtm-team.yaml

@@ -0,0 +1,79 @@
+name: gtm-team
+description: JFL GTM team — research, planning, building, content, and eval
+
+agents:
+  - name: scout
+    role: Research and discovery
+    description: Finds trends, researches competitors, discovers opportunities
+    model: claude-sonnet-4-6
+    skills:
+      - search
+      - agent-browser
+      - x-algorithm
+    color: cyan
+    health_interval: 5000
+
+  - name: planner
+    role: Spec and strategy
+    description: Turns insights into specs and roadmaps
+    model: claude-opus-4-6
+    skills:
+      - spec
+      - startup
+      - hud
+    color: blue
+    health_interval: 5000
+
+  - name: builder
+    role: Implementation
+    description: Writes code, runs tests, ships features
+    model: claude-sonnet-4-6
+    skills:
+      - spec
+      - react-best-practices
+      - fly-deploy
+    color: green
+    default: true
+    health_interval: 5000
+
+  - name: gtm
+    role: Go-to-market
+    description: Coordinates launch, outreach, and pipeline
+    model: claude-sonnet-4-6
+    skills:
+      - hud
+      - content-creator
+      - x-algorithm
+    color: orange
+    health_interval: 5000
+
+  - name: content
+    role: Content generation
+    description: Writes threads, articles, scripts, and one-pagers
+    model: claude-sonnet-4-6
+    skills:
+      - content-creator
+      - founder-video
+    color: purple
+    health_interval: 5000
+
+  - name: eval
+    role: Quality scoring
+    description: Runs evals, scores outputs, provides structured feedback
+    model: claude-haiku-4-5-20251001
+    skills:
+      - eval
+    color: yellow
+    health_interval: 5000
+
+orchestration:
+  mode: rpc
+  extension: "@jfl/pi/extensions/index.js"
+  map_events:
+    - eval:scored
+    - review:findings
+    - task:requested
+    - agent:health
+  peter_parker:
+    enabled: true
+    max_iterations: 5

package/packages/pi/themes/jfl.theme.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "jfl",
+  "vars": {
+    "purple": "#7c3aed",
+    "purpleDeep": "#6d28d9",
+    "cyan": "#06b6d4",
+    "blue": "#3b82f6",
+    "green": "#10b981",
+    "red": "#ef4444",
+    "amber": "#f59e0b",
+    "gray": "#666666",
+    "dimGray": "#444444",
+    "surface": "#161616",
+    "surfaceDark": "#111111",
+    "surfaceDeep": "#0d0d0d"
+  },
+  "colors": {
+    "accent": "purple",
+    "border": "purple",
+    "borderAccent": "cyan",
+    "borderMuted": "gray",
+    "success": "green",
+    "error": "red",
+    "warning": "amber",
+    "muted": "gray",
+    "dim": "dimGray",
+    "text": "",
+    "thinkingText": "gray",
+    "selectedBg": "#2d2d30",
+    "userMessageBg": "#1a1128",
+    "userMessageText": "",
+    "customMessageBg": "#161620",
+    "customMessageText": "",
+    "customMessageLabel": "purple",
+    "toolPendingBg": "#12121a",
+    "toolSuccessBg": "#0f1a14",
+    "toolErrorBg": "#1a0f0f",
+    "toolTitle": "purple",
+    "toolOutput": "",
+    "mdHeading": "cyan",
+    "mdLink": "purple",
+    "mdLinkUrl": "gray",
+    "mdCode": "cyan",
+    "mdCodeBlock": "",
+    "mdCodeBlockBorder": "gray",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "gray",
+    "mdHr": "gray",
+    "mdListBullet": "cyan",
+    "toolDiffAdded": "green",
+    "toolDiffRemoved": "red",
+    "toolDiffContext": "gray",
+    "syntaxComment": "gray",
+    "syntaxKeyword": "purple",
+    "syntaxFunction": "cyan",
+    "syntaxVariable": "amber",
+    "syntaxString": "green",
+    "syntaxNumber": "#c084fc",
+    "syntaxType": "cyan",
+    "syntaxOperator": "purple",
+    "syntaxPunctuation": "gray",
+    "thinkingOff": "gray",
+    "thinkingMinimal": "purple",
+    "thinkingLow": "blue",
+    "thinkingMedium": "cyan",
+    "thinkingHigh": "#c084fc",
+    "thinkingXhigh": "red",
+    "bashMode": "amber"
+  },
+  "export": {
+    "pageBg": "#0a0a0a",
+    "cardBg": "#111111",
+    "infoBg": "#1a1128"
+  }
+}

package/packages/pi/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./extensions",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "paths": {
+      "../../src/lib/*.js": ["../../src/lib/*.ts"]
+    }
+  },
+  "include": ["extensions/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/scripts/collect-tuples.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# collect-tuples.sh — Pull training data from all VMs in a wave
+#
+# Usage:
+#   ./scripts/collect-tuples.sh [WAVE_ID]
+#
+# Collects from each agent VM:
+#   - training-buffer.jsonl (RL tuples)
+#   - eval.jsonl (eval results)
+#   - journal/ (experiment logs)
+#
+# Merges all tuples into a single buffer and optionally retrains policy head.
+
+set -euo pipefail
+
+WAVE_ID=${1:-$(prlctl list -a 2>/dev/null | grep "agent-" | head -1 | sed 's/.*agent-\([0-9]*\)-.*/\1/' || echo "")}
+
+if [ -z "${WAVE_ID}" ]; then
+  echo "Usage: ./scripts/collect-tuples.sh <WAVE_ID>"
+  echo "  or ensure agent VMs are running (agent-WAVEID-N)"
+  exit 1
+fi
+
+TUPLES_DIR="/tmp/jfl-fleet-${WAVE_ID}/tuples"
+mkdir -p "${TUPLES_DIR}"
+
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "  Collecting tuples — Wave ${WAVE_ID}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+COLLECTED=0
+TOTAL_TUPLES=0
+
+for vm in $(prlctl list -a --json 2>/dev/null | python3 -c "import sys,json; [print(v['name']) for v in json.load(sys.stdin) if v['name'].startswith('agent-${WAVE_ID}-')]" 2>/dev/null); do
+  echo -n "  [${vm}] "
+
+  # Check if VM is running
+  STATUS=$(prlctl status "${vm}" 2>/dev/null | grep -o "running\|stopped" || echo "unknown")
+  if [ "${STATUS}" != "running" ] && [ "${STATUS}" != "stopped" ]; then
+    echo "SKIP (${STATUS})"
+    continue
+  fi
+
+  # Copy training tuples
+  prlctl copy-from "${vm}" \
+    /tmp/workspace/.jfl/training-buffer.jsonl \
+    "${TUPLES_DIR}/${vm}-tuples.jsonl" 2>/dev/null || true
+
+  # Copy eval results
+  prlctl copy-from "${vm}" \
+    /tmp/workspace/.jfl/eval.jsonl \
+    "${TUPLES_DIR}/${vm}-evals.jsonl" 2>/dev/null || true
+
+  # Copy journals
+  mkdir -p "${TUPLES_DIR}/${vm}-journals"
+  prlctl copy-from "${vm}" \
+    /tmp/workspace/.jfl/journal/ \
+    "${TUPLES_DIR}/${vm}-journals/" 2>/dev/null || true
+
+  # Copy autoresearch log
+  prlctl copy-from "${vm}" \
+    /tmp/autoresearch.log \
+    "${TUPLES_DIR}/${vm}-autoresearch.log" 2>/dev/null || true
+
+  if [ -f "${TUPLES_DIR}/${vm}-tuples.jsonl" ]; then
+    COUNT=$(wc -l < "${TUPLES_DIR}/${vm}-tuples.jsonl" | tr -d ' ')
+    TOTAL_TUPLES=$((TOTAL_TUPLES + COUNT))
+    echo "${COUNT} tuples"
+  else
+    echo "no tuples"
+  fi
+
+  COLLECTED=$((COLLECTED + 1))
+done
+
+# Merge all tuples
+MERGED="${TUPLES_DIR}/merged.jsonl"
+cat "${TUPLES_DIR}"/*-tuples.jsonl 2>/dev/null | sort -u > "${MERGED}" || true
+MERGED_COUNT=$(wc -l < "${MERGED}" 2>/dev/null | tr -d ' ' || echo "0")
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "  Collected from ${COLLECTED} VMs"
+echo "  Total tuples: ${TOTAL_TUPLES} (${MERGED_COUNT} unique)"
+echo "  Merged file: ${MERGED}"
+echo ""
+
+# Append to local training buffer
+if [ "${MERGED_COUNT}" -gt 0 ]; then
+  LOCAL_BUFFER=".jfl/training-buffer.jsonl"
+  BEFORE=$(wc -l < "${LOCAL_BUFFER}" 2>/dev/null | tr -d ' ' || echo "0")
+
+  # Dedup: only append tuples with IDs not already in local buffer
+  if [ -f "${LOCAL_BUFFER}" ]; then
+    EXISTING_IDS=$(grep -o '"id":"[^"]*"' "${LOCAL_BUFFER}" | sort -u)
+    while IFS= read -r line; do
+      TUPLE_ID=$(echo "${line}" | grep -o '"id":"[^"]*"' || echo "")
+      if ! echo "${EXISTING_IDS}" | grep -qF "${TUPLE_ID}"; then
+        echo "${line}" >> "${LOCAL_BUFFER}"
+      fi
+    done < "${MERGED}"
+  else
+    cat "${MERGED}" >> "${LOCAL_BUFFER}"
+  fi
+
+  AFTER=$(wc -l < "${LOCAL_BUFFER}" | tr -d ' ')
+  NEW=$((AFTER - BEFORE))
+
+  echo "  Appended ${NEW} new tuples to ${LOCAL_BUFFER}"
+  echo "  Total local buffer: ${AFTER} tuples"
+
+  # Check if retrain is warranted
+  TRAINED_ON=$(python3 -c "import json; print(json.load(open('.jfl/policy-weights.json'))['trained_on'])" 2>/dev/null || echo "0")
+  DELTA=$((AFTER - TRAINED_ON))
+
+  if [ "${DELTA}" -ge 20 ]; then
+    echo ""
+    echo "  ${DELTA} new tuples since last train (threshold: 20)"
+    echo "  Retrain: python3 scripts/train-policy-head.py --epochs 200"
+  fi
+fi
+
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"