claude-symphony 0.2.7 → 0.2.9

package/README.md

@@ -18,6 +18,8 @@ claude-symphony is a 10-stage software development workflow pipeline that orches
 - **10-Stage Pipeline**: Complete development cycle from brainstorming to deployment
 - **Multi-AI Orchestration**: Intelligent collaboration between Gemini, Claude, and Codex
 - **Smart HANDOFF System**: Automatic context extraction and semantic compression
+- **Context Manager**: Automatic context monitoring with snapshot/HANDOFF generation at thresholds
+- **Memory Relay (Encore Mode)**: Infinite session orchestration - Claude never stops
 - **Auto-Checkpoint & Rollback**: Task-based triggers with partial rollback support
 - **Pipeline Forking**: Branch exploration for architecture alternatives
 - **Stage Personas**: Optimized AI behavior profiles per stage
@@ -52,6 +54,90 @@ cd my-project
 /brainstorm
 ```
 
+## Context Management
+
+claude-symphony includes automatic context management to ensure continuous workflow even when Claude's context window fills up.
+
+### How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Context Thresholds (Remaining %)                           │
+├─────────────────────────────────────────────────────────────┤
+│  60%  │ Warning    │ Display warning banner                 │
+│  50%  │ Action     │ Auto-snapshot + recommend /compact     │
+│  40%  │ Critical   │ Generate HANDOFF.md + /clear required  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Encore Mode (Memory Relay)
+
+Start with `claude-symphony-play` to enable automatic session handoff:
+
+```bash
+# Install Memory Relay (one-time)
+./scripts/memory-relay/install.sh
+
+# Start Encore Mode
+claude-symphony-play
+
+# With bypass mode
+claude-symphony-play --bypass
+```
+
+When context drops below 50%, the system automatically:
+1. Creates a snapshot in `state/context/`
+2. Generates `HANDOFF.md` with recovery instructions
+3. Signals Memory Relay to start a new session
+4. New session continues from where you left off
+
+### Manual Context Commands
+
+```bash
+# Check context status
+/context
+
+# Save snapshot manually
+/context --save
+
+# List all snapshots
+/context --list
+
+# Trigger relay manually
+/context --relay
+```
+
+### Context Automation Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  statusline.sh (polls every 300ms)                          │
+│    ↓ context ≤ 50%                                          │
+│  scripts/context-manager.sh --auto-compact                  │
+│    ↓                                                        │
+│  ┌────────────────────────────────────────────────────────┐ │
+│  │ 1. Auto-snapshot → state/context/auto-snapshot-*.md   │ │
+│  │ 2. HANDOFF.md → project root                          │ │
+│  │ 3. Archive → state/handoffs/                          │ │
+│  │ 4. RELAY_READY signal → Memory Relay FIFO             │ │
+│  └────────────────────────────────────────────────────────┘ │
+│    ↓                                                        │
+│  Memory Relay Orchestrator                                  │
+│    ↓                                                        │
+│  New Claude session starts with HANDOFF.md                  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `.claude/hooks/statusline.sh` | Real-time context monitoring |
+| `.claude/hooks/stop.sh` | Auto-trigger after response |
+| `scripts/context-manager.sh` | Snapshot/HANDOFF generation |
+| `state/context/` | Auto-saved snapshots |
+| `state/handoffs/` | HANDOFF archive |
+
 ## Commands
 
 ### CLI Commands
@@ -71,6 +157,7 @@ cd my-project
 | `/next` | Move to next stage |
 | `/handoff` | Create handoff document |
 | `/checkpoint` | Create checkpoint |
+| `/context` | Context management (status, save, list, relay) |
 
 See [template/docs/commands.md](template/docs/commands.md) for the complete command reference.
 
@@ -111,8 +198,10 @@ claude-symphony/
 ├── template/               # Project template (copied to user projects)
 │   ├── .claude/            # Claude Code config
 │   │   ├── commands/       # Slash commands (30+)
-│   │   ├── hooks/          # Lifecycle hooks (8)
+│   │   ├── hooks/          # Lifecycle hooks (statusline, stop, etc.)
 │   │   └── skills/         # AI skills (7)
+│   ├── scripts/            # Runtime scripts
+│   │   └── context-manager.sh  # Context automation
 │   ├── stages/             # 10-stage pipeline
 │   ├── config/             # Configuration files (25+)
 │   ├── state/              # State management

package/dist/cli/index.js

@@ -1532,7 +1532,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import os from "os";
 import path5 from "path";
 import { existsSync as existsSync3 } from "fs";
-var SESSION_NAME = "symphony-session";
+var SESSION_PREFIX = "symphony-session";
 var DEFAULT_RELAY_DIR = path5.join(os.homedir(), ".claude/memory-relay");
 var cachedConfig = null;
 function resolveBaseDir(scriptDir) {
@@ -1595,7 +1595,7 @@ async function checkDependencies2() {
   const [tmux, claude] = await Promise.all([commandExists("tmux"), commandExists("claude")]);
   return { tmux, claude };
 }
-function sessionExists(sessionName = SESSION_NAME) {
+function sessionExists(sessionName = SESSION_PREFIX) {
   try {
     execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`, { stdio: "pipe" });
     return true;
@@ -1603,31 +1603,43 @@ function sessionExists(sessionName = SESSION_NAME) {
     return false;
   }
 }
-async function handleExistingSession(sessionName = SESSION_NAME) {
+function findNextAvailableSessionName() {
+  if (!sessionExists(SESSION_PREFIX)) {
+    return SESSION_PREFIX;
+  }
+  let n = 2;
+  while (sessionExists(`${SESSION_PREFIX}-${n}`)) {
+    n++;
+  }
+  return `${SESSION_PREFIX}-${n}`;
+}
+async function handleExistingSession(sessionName = SESSION_PREFIX) {
   console.log(chalk5.yellow(`Session '${sessionName}' already exists.`));
   console.log("");
+  const nextName = findNextAvailableSessionName();
   const choice = await select2({
     message: "What would you like to do?",
     choices: [
       { name: "Attach to existing session", value: "attach" },
+      { name: `Create new session (${nextName})`, value: "new" },
       { name: "Kill and recreate", value: "recreate" },
       { name: "Cancel", value: "cancel" }
     ]
   });
   return choice;
 }
-function killSession(sessionName = SESSION_NAME) {
+function killSession(sessionName = SESSION_PREFIX) {
   try {
     execSync(`tmux kill-session -t "${sessionName}"`, { stdio: "pipe" });
   } catch {
   }
 }
-function attachSession(sessionName = SESSION_NAME) {
+function attachSession(sessionName = SESSION_PREFIX) {
   console.log("Attaching to existing session...");
   spawnSync("tmux", ["attach-session", "-t", sessionName], { stdio: "inherit" });
 }
 function createTmuxSession(options) {
-  const sessionName = SESSION_NAME;
+  const sessionName = options.sessionName ?? SESSION_PREFIX;
   try {
     execSync(
       `tmux new-session -d -s "${sessionName}" -c "${options.workDir}" -x 200 -y 50`,
@@ -1703,12 +1715,17 @@ async function startSession(options) {
     console.log("Please install Claude Code CLI first");
     process.exit(1);
   }
+  let sessionName = SESSION_PREFIX;
   if (sessionExists()) {
     const choice = await handleExistingSession();
     switch (choice) {
       case "attach":
         attachSession();
         return;
+      case "new":
+        sessionName = findNextAvailableSessionName();
+        console.log(`Creating parallel session: ${chalk5.green(sessionName)}`);
+        break;
       case "recreate":
         console.log("Killing existing session...");
         killSession();
@@ -1719,19 +1736,19 @@ async function startSession(options) {
     }
   }
   console.log("");
-  console.log(`Creating new session: ${chalk5.green(SESSION_NAME)}`);
+  console.log(`Creating new session: ${chalk5.green(sessionName)}`);
   console.log(`Working directory: ${chalk5.blue(options.workDir)}`);
   console.log(`Relay base: ${chalk5.blue(config.baseDir)}`);
   console.log("");
-  const created = createTmuxSession(options);
+  const created = createTmuxSession({ ...options, sessionName });
   if (!created) {
     console.error(chalk5.red("Failed to create session"));
     process.exit(1);
   }
   console.log(chalk5.green("Session created successfully!"));
   showSessionLayout();
-  console.log(`Attaching to session ${chalk5.green(SESSION_NAME)}...`);
-  attachSession();
+  console.log(`Attaching to session ${chalk5.green(sessionName)}...`);
+  attachSession(sessionName);
 }
 
 // src/relay/orchestrator.ts

package/dist/hooks/pre-transition.d.ts

@@ -0,0 +1,22 @@
+import { S as StageId } from '../stage-Cy_k5zNZ.js';
+
+/**
+ * Pre-transition result
+ */
+interface PreTransitionResult {
+    allowed: boolean;
+    currentStage: StageId;
+    nextStage: StageId | 'completed';
+    blockers: string[];
+    summary: string;
+}
+/**
+ * Run pre-transition validation
+ */
+declare function runPreTransition(projectRoot: string, currentStageArg?: StageId, nextStageArg?: StageId): Promise<PreTransitionResult>;
+/**
+ * CLI entry point
+ */
+declare function main(): Promise<void>;
+
+export { type PreTransitionResult, main, runPreTransition };