Advanced Session Management: Power User Guide

If you've been using Tactic Remote for a while, you've likely moved beyond single-session usage. You might run separate Claude Code sessions for different projects, keep a session for code review while another handles implementation, or maintain long-running sessions for monitoring tasks.

This guide covers advanced session management techniques that make multi-session workflows efficient and organized.

Understanding Session Lifecycle

Before diving into techniques, let's clarify how sessions work in Tactic Remote:

A session corresponds to a tmux window on your Mac, running a Claude Code instance scoped to a specific project directory. Sessions have four states:

1. Idle — Claude Code is running but waiting for input. The session is ready for prompts.
2. Active — Claude Code is executing a task. Terminal output is streaming.
3. Awaiting — Claude Code is paused, waiting for approval or user input.
4. Terminated — Claude Code has exited. The tmux window may still exist with terminal history.

Understanding these states helps you manage multiple sessions without confusion. The session selector on your iPhone shows the current state of each session with color-coded indicators.

Technique 1: Project-Based Session Organization

The most effective session organization follows your project structure:

Session: "api-refactor"     → ~/projects/myapp/packages/api
Session: "frontend-v2"      → ~/projects/myapp/packages/web
Session: "infrastructure"   → ~/projects/myapp/infra
Session: "side-project"     → ~/projects/weekend-hack

Why this works: Each session has a clear scope. When you return to a session, the context is immediately obvious — you don't need to remember what you were working on. Claude Code's context within each session remains focused on the relevant codebase.

Naming convention: Use descriptive names that include both the project and the current focus. "api-refactor" is better than "session-3". Tactic Remote preserves session names across reconnections, so invest a few seconds in good naming.

Technique 2: The Review + Implement Pattern

A powerful pattern for code quality is running parallel review and implementation sessions:

Implementation session: You direct Claude Code to build a feature, fix a bug, or perform a refactor. This session does the actual code changes.

Review session: A second Claude Code instance pointed at the same project directory. After the implementation session completes a piece of work, you prompt the review session:

Review the changes made in the last commit. Check for:
- Logic errors or edge cases
- Security issues (input validation, authentication checks)
- Performance concerns (N+1 queries, unnecessary re-renders)
- Missing error handling
- Test coverage gaps

Be specific and honest. Don't just say "looks good."

This gives you an AI-powered code review that catches issues the implementation AI might have introduced. It's not a replacement for human review, but it catches a surprising number of problems.

Pro tip: Keep the review session idle between reviews. It uses minimal resources when not actively executing.

Technique 3: Background Task Monitoring

Some development tasks run for extended periods:

• Full test suite execution (10-30 minutes for large projects)
• Database migrations on large datasets
• Build and deployment pipelines
• Comprehensive linting or type-checking

For these, create a dedicated "monitor" session:

Run the full test suite with verbose output.
After completion, summarize: total tests, passed, failed, skipped.
If any tests failed, show the failure details.
Then run the linter and report any new issues.

Start this session and switch to other work. Tactic Remote will notify you when it completes. The session history contains the full output for later review.

Technique 4: Session Templates

If you start similar sessions frequently, create prompt templates on your Mac that Claude Code can reference. Save a file like .claude-session-templates.md in your project root:

## Daily Standup Prep
 
Review all commits from the last 24 hours.
Summarize what changed, highlight any concerning patterns.
List any failing tests or lint issues introduced.
 
## Pre-PR Checklist
 
Run all tests. Run the linter. Run type-check.
Review the diff against main branch.
Flag any issues that should be addressed before merging.
 
## Dependency Audit
 
Check for outdated dependencies.
List any with known security vulnerabilities.
Suggest an update plan with risk assessment for each.

Then from your phone, you can simply prompt:

Follow the "Pre-PR Checklist" template in .claude-session-templates.md

This reduces typing on your phone while maintaining consistent quality standards.

Technique 5: Session Rotation

Long-running Claude Code sessions accumulate context. After hours of work, the conversation history can become large, potentially impacting response quality. Session rotation addresses this:

1. When a session has been active for several hours or has completed a logical phase of work, create a new session for the same project.
2. In the new session, provide a brief context prompt:

I'm continuing work on the user authentication module.
Completed so far: database schema, user model, password hashing.
Next up: JWT token generation, login/logout endpoints, middleware.
Review the current state of src/auth/ and continue from where the previous session left off.

3. Let the old session remain idle (it retains its terminal history for reference).

This gives Claude Code a fresh context window while preserving the work history in the old session. We recommend rotating every 2-3 hours of active work or at natural project milestones.

Technique 6: Multi-Device Session Access

Tactic Remote sessions are stored on your Mac, not on your iPhone. This means:

• Switch phones freely. If you upgrade your iPhone or use a different device, your sessions are still there. Connect from the new device and they appear immediately.
• iPad as secondary display. Connect your iPad to the same Mac endpoint. Use the iPad for detailed code review (larger screen) and the iPhone for quick approvals and monitoring.
• Multiple simultaneous connections. The Mac companion app supports multiple connected clients. Your iPhone and iPad can monitor different sessions simultaneously.

Managing Session Resources

Each active Claude Code session consumes resources on your Mac:

• Memory: ~200-400MB per active session (Claude Code process + tmux overhead)
• CPU: Near zero when idle, variable when executing tasks
• Disk: Terminal buffer retention uses ~1-5MB per session

For a typical development Mac (16GB+ RAM), running 3-5 concurrent sessions is comfortable. If you regularly run more, monitor your Mac's memory pressure through Activity Monitor or the Tactic Remote companion app's status panel.

Cleanup tip: Terminated sessions that you no longer need can be removed through the session manager. This reclaims the tmux window and associated terminal buffer.

Troubleshooting Multi-Session Issues

Sessions seem slow: If multiple sessions are actively executing simultaneously, they compete for CPU. Stagger your prompts — start one task, wait for it to finish, then start the next. Active AI inference is CPU-intensive.

Wrong session received notification: Tactic Remote notifications include the session name. If you're getting confused, use more distinctive session names.

Session shows stale content: After a long period of inactivity, a session may need a refresh. Pull down on the terminal view to force a reconnection and buffer sync.

Daily Workflow Example

Here's how an experienced Tactic Remote user might structure their day:

Morning (from phone, during commute):

• Check overnight session results
• Start fresh sessions for today's priorities
• Approve any pending requests from overnight tasks

Midday (from phone, during breaks):

• Monitor active sessions
• Review and approve AI-generated code changes
• Start new tasks for the afternoon

Evening (from phone, casually):

• Check final status of day's work
• Start any overnight tasks (test suites, dependency audits)
• Rotate long-running sessions

This pattern maximizes productivity while minimizing time spent at the desk. The Mac does the work; your phone keeps you informed and in control.

For the foundational session workflow, revisit Sessions and Start. For first-time setup, see Getting Started.