claude-symphony 0.2.8 → 0.2.10

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-symphony",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Multi-AI Orchestration Framework - Create new projects with 10-stage development workflow",
   "type": "module",
   "bin": {

package/scripts/memory-relay/orchestrator/claude-wrapper.sh

@@ -154,8 +154,9 @@ if [[ -n "${HANDOFF_FILE}" ]] && [[ -f "${HANDOFF_FILE}" ]]; then
 
     show_relay_banner
 
-    # Start Claude with instruction to read handoff
-    exec $(get_claude_cmd) --resume "${HANDOFF_FILE}" 2>/dev/null || exec $(get_claude_cmd)
+    # Start Claude with system prompt to read handoff file and continue work
+    # Using --append-system-prompt to stay in interactive mode (not -p which exits after response)
+    exec $(get_claude_cmd) --append-system-prompt "IMPORTANT: A handoff file has been created at ${HANDOFF_FILE}. You MUST read this file immediately using the Read tool and continue the previous work described within it. This is a session continuation - start by reading the handoff file."
 else
     log_relay "Starting fresh Claude session with relay support"
     show_relay_banner

package/scripts/memory-relay/orchestrator/orchestrator.sh

@@ -143,6 +143,10 @@ handle_relay_signal() {
                 log "INFO" "New Claude session started successfully"
                 send_ack "${source_pane}" "${new_pane}"
                 archive_handoff "${handoff_path}"
+                # Terminate old pane after new session is stable
+                sleep 2
+                log "INFO" "Terminating old pane: ${source_pane}"
+                tmux kill-pane -t "${source_pane}" 2>/dev/null || true
                 return 0
             else
                 log "ERROR" "New pane ${new_pane} not found after creation"

package/scripts/memory-relay/orchestrator/tmux-startup.sh

@@ -23,8 +23,30 @@ ORCHESTRATOR_DIR="${RELAY_BASE}/orchestrator"
 ORCHESTRATOR_SCRIPT="${ORCHESTRATOR_DIR}/orchestrator.sh"
 WRAPPER_SCRIPT="${ORCHESTRATOR_DIR}/claude-wrapper.sh"
 
-# Session name - symphony branding
-SESSION_NAME="symphony-session"
+# Session name prefix - symphony branding
+SESSION_PREFIX="symphony-session"
+
+# Function to find next available session name
+# Returns: symphony-session, symphony-session-2, symphony-session-3, ...
+find_next_session_name() {
+    local base="${SESSION_PREFIX}"
+
+    # Check if base session exists
+    if ! tmux has-session -t "${base}" 2>/dev/null; then
+        echo "${base}"
+        return
+    fi
+
+    # Find next available numbered session
+    local n=2
+    while tmux has-session -t "${base}-${n}" 2>/dev/null; do
+        ((n++))
+    done
+    echo "${base}-${n}"
+}
+
+# Default session name (will be updated if creating new parallel session)
+SESSION_NAME="${SESSION_PREFIX}"
 
 # Colors
 RED='\033[0;31m'
@@ -74,24 +96,31 @@ for script in "${ORCHESTRATOR_SCRIPT}" "${WRAPPER_SCRIPT}"; do
 done
 
 # Check if session already exists
-if tmux has-session -t "${SESSION_NAME}" 2>/dev/null; then
-    echo -e "${YELLOW}Session '${SESSION_NAME}' already exists.${NC}"
+if tmux has-session -t "${SESSION_PREFIX}" 2>/dev/null; then
+    NEXT_SESSION_NAME=$(find_next_session_name)
+    echo -e "${YELLOW}Session '${SESSION_PREFIX}' already exists.${NC}"
     echo ""
     echo "Options:"
     echo "  1. Attach to existing session"
-    echo "  2. Kill and recreate"
-    echo "  3. Cancel"
+    echo "  2. Create new session (${NEXT_SESSION_NAME})"
+    echo "  3. Kill and recreate"
+    echo "  4. Cancel"
     echo ""
-    read -p "Choice [1/2/3]: " choice
+    read -p "Choice [1/2/3/4]: " choice
 
     case "${choice}" in
         1)
             echo "Attaching to existing session..."
-            exec tmux attach-session -t "${SESSION_NAME}"
+            exec tmux attach-session -t "${SESSION_PREFIX}"
             ;;
         2)
+            echo -e "Creating parallel session: ${GREEN}${NEXT_SESSION_NAME}${NC}"
+            SESSION_NAME="${NEXT_SESSION_NAME}"
+            ;;
+        3)
             echo "Killing existing session..."
-            tmux kill-session -t "${SESSION_NAME}"
+            tmux kill-session -t "${SESSION_PREFIX}"
+            SESSION_NAME="${SESSION_PREFIX}"
             ;;
         *)
             echo "Cancelled."