home / skills / madappgang / claude-code / session-isolation

session-isolation skill

/plugins/orchestration/skills/session-isolation

This skill helps orchestrate multi-file workflows by isolating artifacts in unique session folders to prevent collisions.

npx playbooks add skill madappgang/claude-code --skill session-isolation

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
5.8 KB
---
name: session-isolation
description: Use when orchestrating workflows that generate multiple files (designs, reviews, reports) to prevent file collisions across concurrent or sequential sessions with unique session directories.
keywords: [session-isolation, artifact-isolation, file-collision, concurrent-sessions, sequential-workflows, session-directory, multi-artifact, session-metadata]
plugin: orchestration
updated: 2026-01-20
---

# Session Isolation Pattern

Session-based artifact isolation for multi-artifact workflows. Use when orchestrating workflows that generate multiple files (designs, reviews, reports) to prevent file collisions across concurrent or sequential sessions.

## Problem

When multiple workflows run (even sequentially), artifacts with the same name collide:

```
Session 1 (SEO): writes ai-docs/plan-review-grok.md
Session 2 (API): writes ai-docs/plan-review-grok.md  <-- OVERWRITES!
```

## Solution

Use unique session folders to isolate artifacts:

```
ai-docs/sessions/agentdev-seo-20260105-143022-a3f2/
├── session-meta.json      # Session tracking
├── design.md              # Primary artifact
├── reviews/
│   ├── plan-review/       # Plan review phase
│   │   ├── internal.md
│   │   ├── grok.md
│   │   └── consolidated.md
│   └── impl-review/       # Implementation review phase
│       ├── internal.md
│       └── consolidated.md
└── report.md              # Final report
```

## Implementation Pattern

### 1. Session Initialization (Orchestrator)

Add to Phase 0 of your orchestrator command:

```bash
# Generate unique session path
TARGET_SLUG=$(echo "${TARGET_NAME:-workflow}" | tr '[:upper:] ' '[:lower:]-' | sed 's/[^a-z0-9-]//g' | head -c20)
SESSION_BASE="${WORKFLOW_TYPE}-${TARGET_SLUG}-$(date +%Y%m%d-%H%M%S)-$(head -c4 /dev/urandom | xxd -p | head -c4)"
SESSION_PATH="ai-docs/sessions/${SESSION_BASE}"

# Create directory structure
mkdir -p "${SESSION_PATH}/reviews/plan-review" \
         "${SESSION_PATH}/reviews/impl-review" || {
  echo "Warning: Cannot create session directory, using legacy mode"
  SESSION_PATH="ai-docs"
}

# Create session metadata (if not legacy mode)
if [[ "$SESSION_PATH" != "ai-docs" ]]; then
  cat > "${SESSION_PATH}/session-meta.json" << EOF
{
  "session_id": "${SESSION_BASE}",
  "type": "${WORKFLOW_TYPE}",
  "target": "${USER_REQUEST}",
  "started_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "status": "in_progress"
}
EOF
fi
```

### 2. Pass SESSION_PATH to Sub-Agents

Include in all agent prompts:

```
SESSION_PATH: ${SESSION_PATH}

{actual task description}

Save output to: ${SESSION_PATH}/{artifact_path}
```

### 3. Sub-Agent SESSION_PATH Detection

Add to agent `<critical_constraints>`:

```xml
<session_path_support>
  **Check for Session Path Directive**

  If prompt contains `SESSION_PATH: {path}`:
  1. Extract the session path
  2. Use it for all output file paths
  3. Primary artifact: `${SESSION_PATH}/{type}.md`
  4. Reviews: `${SESSION_PATH}/reviews/{phase}/{model}.md`

  **If NO SESSION_PATH**: Use legacy paths (ai-docs/)
</session_path_support>
```

### 4. Session Completion

Update metadata when workflow completes:

```bash
if [[ -f "${SESSION_PATH}/session-meta.json" ]]; then
  jq '.status = "completed" | .completed_at = (now | strftime("%Y-%m-%dT%H:%M:%SZ"))' \
    "${SESSION_PATH}/session-meta.json" > "${SESSION_PATH}/session-meta.json.tmp" && \
  mv "${SESSION_PATH}/session-meta.json.tmp" "${SESSION_PATH}/session-meta.json"
fi
```

## Artifact Path Mapping

| Artifact Type | SESSION_PATH Format | Legacy Format |
|---------------|---------------------|---------------|
| Design/Context | `${SESSION_PATH}/design.md` | `ai-docs/agent-design-{name}.md` |
| Plan Review | `${SESSION_PATH}/reviews/plan-review/{model}.md` | `ai-docs/plan-review-{model}.md` |
| Impl Review | `${SESSION_PATH}/reviews/impl-review/{model}.md` | `ai-docs/impl-review-{model}.md` |
| Consolidated | `${SESSION_PATH}/reviews/{phase}/consolidated.md` | `ai-docs/{phase}-consolidated.md` |
| Final Report | `${SESSION_PATH}/report.md` | `ai-docs/{workflow}-report-{name}.md` |

## Backward Compatibility

**Legacy Mode Triggers:**
1. `SESSION_PATH` not provided in prompt
2. Directory creation fails (permissions)
3. Explicit `LEGACY_MODE: true` in prompt

**Behavior:**
- Fall back to flat `ai-docs/` paths
- Log warning about legacy mode
- All features still work, just without isolation

## Session Metadata Schema

```json
{
  "session_id": "agentdev-seo-20260105-143022-a3f2",
  "type": "agentdev",
  "target": "SEO agent improvements",
  "started_at": "2026-01-05T14:30:22Z",
  "completed_at": "2026-01-05T15:45:30Z",
  "status": "completed",
  "phases_completed": ["init", "design", "plan-review", "implementation", "quality-review"],
  "models_used": ["claude-embedded", "x-ai/grok-code-fast-1", "google/gemini-3-pro"],
  "artifacts": {
    "design": "design.md",
    "plan_reviews": ["reviews/plan-review/internal.md", "reviews/plan-review/grok.md"],
    "impl_reviews": ["reviews/impl-review/internal.md", "reviews/impl-review/gemini.md"],
    "report": "report.md"
  }
}
```

## Plugins Using Session Isolation

| Plugin | Command | Session Pattern |
|--------|---------|-----------------|
| **agentdev** | `/develop` | `agentdev-{target}-{timestamp}-{random}` |
| **frontend** | `/review`, `/implement` | `review-{timestamp}-{random}` |
| **seo** | `/review`, `/alternatives` | `seo-review-{timestamp}-{random}` |

## Best Practices

1. **Always initialize early**: Session creation should happen in Phase 0
2. **Include SESSION_PATH in all prompts**: Sub-agents need it for output paths
3. **Use descriptive slugs**: Include workflow type and target in folder name
4. **Update metadata on completion**: Track status changes
5. **Fallback gracefully**: Never fail the workflow due to session creation issues

Overview

This skill enforces session-based artifact isolation for multi-file workflows to prevent file collisions across concurrent or sequential runs. It creates unique session directories, writes session metadata, and routes all agent outputs into the session folder instead of shared paths. The result is repeatable, auditable runs where artifacts from different sessions never overwrite each other.

How this skill works

On orchestrator startup the skill generates a deterministic, sanitized session slug and creates a session directory tree (including review subfolders) and a session-meta.json file. The orchestrator injects SESSION_PATH into every sub-agent prompt so agents write artifacts into ${SESSION_PATH}/... instead of global paths. Agents detect the SESSION_PATH directive and map artifacts (design, reviews, report) into the session layout; on completion the orchestrator updates metadata.status and timestamps.

When to use it

  • Orchestrating workflows that produce multiple files (designs, reviews, reports) concurrently.
  • Running repeated or parallel agent runs where artifact name collisions are likely.
  • When you need per-run traceability, auditing, or reproducible artifact sets.
  • Integrating multiple sub-agents that must coordinate where to save outputs.
  • When you want graceful fallback to legacy flat paths if directory creation fails.

Best practices

  • Initialize the session early (Phase 0) so all sub-agents receive SESSION_PATH.
  • Pass SESSION_PATH in every agent prompt and require agents to honor it.
  • Use descriptive slugs (workflow type + target) and timestamp + random suffix for uniqueness.
  • Always write a session-meta.json and update status/completion timestamps at the end.
  • Implement a legacy-mode fallback and log a warning rather than failing the workflow.

Example use cases

  • A multi-model design pipeline where separate models produce plan-review artifacts without overwriting each other.
  • A CI workflow that runs repeated integration reviews for different targets and needs separate artifact folders per run.
  • A team review process that consolidates model-specific reviews into a session-scoped consolidated.md for audit.
  • A plugin that triggers /develop or /review commands and needs to store all outputs for a single session for later inspection.

FAQ

What happens if directory creation fails due to permissions?

The skill falls back to legacy flat ai-docs/ paths, logs a warning about legacy mode, and continues the workflow.

How do agents know where to save files?

The orchestrator injects SESSION_PATH into prompts; agents must detect SESSION_PATH and map artifact outputs into the session folder structure.