Skip to content
Skills Library
Programming · Planning

start

/start

Start a coding session with full context compilation, GitHub sync, and memory loading. Use for session start, project status check, context restoration, loop state recovery, GitHub issue synchronization, and feature priority review.

Licence
MIT
Last repository change
17.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 17.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Start a coding session with full context compilation, GitHub sync, and memory loading. Use for session start, project status check, context restoration, loop state recovery, GitHub issue synchronization, and feature priority review.

Original author description

Start a coding session with full context compilation, GitHub sync, and memory loading. Use for session start, project status check, context restoration, loop state recovery, GitHub issue synchronization, and feature priority review.

How it works

  1. Current Harness Snapshot (auto-compiled at invocation)
  2. Phase 0: Migration Check
  3. Phase 0.5: Set Paths
  4. Phase 1: Context Compilation (Memory System)
  5. Phase 1.7: Refresh Session Briefing
  6. Phase 2: Local Status
  7. Phase 3: Loop & Orchestration State
  8. Phase 4: GitHub Integration
  9. Phase 5: Recommendations
Original SKILL.md headings · 139 lines, 889 words
SKILL.md preview
---
name: start
description: Start a coding session with full context compilation, GitHub sync, and memory loading. Use for session start, project status check, context restoration, loop state recovery, GitHub issue synchronization, and feature priority review.
allowed-tools: "Bash(git *), Bash(gh *)"
---

# Start - Session Initialization and Context Compilation

Prepare for a new coding session: compile memory context, show status, sync GitHub.

Session ID: ${CLAUDE_SESSION_ID} — session state lives in `.claude-harness/sessions/${CLAUDE_SESSION_ID}/`.

## Current Harness Snapshot (auto-compiled at invocation)

!`python3 "${CLAUDE_PLUGIN_ROOT}/scripts/compile-briefing.py" .claude-harness 2>/dev/null || echo "(harness state not initialized - run /claude-harness:setup)"`

## Phase 0: Migration Check

Migrations are handled by `setup.sh`, which the SessionStart hook runs automatically whenever the plugin version changes. Only act here if legacy files are visible at the project root (`feature-list.json`, `feature-archive.json`, `claude-progress.json`, `working-context.json`, `agent-context.json`, `agent-memory.json`, `init.sh`): run `bash {plugin-root}/setup.sh` once (plugin root is in the session context) and report what it migrated.

## Phase 0.5: Set Paths

1. **Set path variables**:
   - `FEATURES_FILE=".claude-harness/features/active.json"`
   - `ARCHIVE_FILE=".claude-harness/features/archive.json"`
   - `MEMORY_DIR=".claude-harness/memory/"`
   - `SESSION_DIR=".claude-harness/sessions/${CLAUDE_SESSION_ID}/"`

**Important**: All subsequent phases must use these path variables instead of hardcoded paths.

## Phase 1: Context Compilation (Memory System)

The snapshot above already contains the compiled overview (features, recent decisions, failures to avoid, learned rules, last session). Use it directly - do NOT re-read the memory files unless you need detail beyond the snapshot.

1. **Deep-dive reads (only when needed)**: if the active feature requires filtering memory by `relatedFiles`, read IN PARALLEL (single message, multiple Read calls) -- memory layers are OKF concept files (markdown with YAML frontmatter), so read each directory's `index.md` first, then only the relevant concept files:
   - `${FEATURES_FILE}` (full feature entries)
   - `${MEMORY_DIR}/failures/index.md` (then relevant Failure concepts)
   - `${MEMORY_DIR}/successes/index.md` (then relevant Success concepts)
   - `${MEMORY_DIR}/decisions/index.md` (then relevant Decision concepts)
   - `${MEMORY_DIR}/rules/index.md` (then relevant Rule concepts)

2. **Write compiled context** to `${SESSION_DIR}/context.json`:
   ```json
   {
     "version": 3,
     "computedAt": "{ISO timestamp}",
     "sessionId": "${CLAUDE_SESSION_ID}",
     "github": { "owner": "{from session context}", "repo": "{from session context}" },
     "activeFeature": "{feature-id or null}",
     "relevantMemory": {
       "recentDecisions": [{...}],
       "projectPatterns": [{...}],
       "avoidApproaches": [{...}],
       "learnedRules": [{...}]
     },
     "currentTask": {
       "description": "{feature description}",
       "files": ["{relatedFiles}"],
       "acceptanceCriteria": ["{verification}"]
     }
   }
   ```
   - `relevantMemory` filtering: failures/successes where `feature` matches or `files` overlap the active feature's `relatedFiles` (top 5 each); decisions from the last 7 days or last 20 entries; learned rules where `applicability.always` is true, or `applicability.features`/`filePatterns` match the active feature.

3. **Display memory summary**:
   ```
   MEMORY CONTEXT COMPILED
   Recent decisions: {N} loaded
   Success patterns: {N} loaded
   Approaches to AVOID: {N} loaded
   Learned rules: {N} active
   ```
   If `avoidApproaches` or learned rules have entries, list them prominently.

## Phase 1.7: Refresh Session Briefing

**Regenerate persistent session briefing** at `.claude-harness/session-briefing.md` (same format as the snapshot above, keep under 120 lines). This keeps the briefing fresh for the next session start. Report: "Session briefing refreshed".

## Phase 2: Local Status

1. If the compiled context has an `activeFeature`, display prominently:
   ```
   === Resuming Work ===
   Feature: {activeFeature} - {summary}
   Working files: {relatedFiles}
   Next steps: {from briefing}
   ```

2. Read `.claude-harness/claude-progress.json` for last-session summary and blockers.

3. Read `${FEATURES_FILE}` to identify next priority.
   - If the file is too large to read (>25000 tokens), use `grep` for pending features and run `/claude-harness:checkpoint` to archive completed ones.

## Phase 3: Loop & Orchestration State

4. **Check active loop state** (PRIORITY):
   - **Interrupt recovery first**: read `.claude-harness/sessions/.recovery/interrupted.json`. If it exists:
     ```
     INTERRUPTED SESSION DETECTED
     Feature: {feature} | TDD Phase: {tddPhase} | Attempt: {attemptAtInterrupt}
     Resume: /claude-harness:flow {feature}  (recovery options will be presented)
     ```
   - Read `${SESSION_DIR}/loop-state.json` (legacy fallbacks: `.claude-harness/loops/state.json`, `.claude-harness/loop-state.json`)
   - If `status` is "in_progress": display feature/fix, attempt count, last approach and result, and the resume command `/claude-harness:flow {feature}`
   - If `status` is "escalated": show escalation reason and history summary; recommend providing guidance or retrying with a fresh delegation

5. **Check pending fixes**: read `${FEATURES_FILE}` `fixes` array for entries with `status` != "passing" and list them with their linked features.

6. **Check orchestration state**: read `.claude-harness/agents/context.json` if it exists.
   - `currentSession.activeFeature` set -> incomplete orchestration; recommend `/claude-harness:flow {feature-id}` to resume
   - `teamState` non-null -> display the team roster and status. Note: Agent Teams do not survive session restarts; if teammates are gone, flow will offer to spawn fresh ones or fall back to direct implementation.

7. **Check procedural memory hotspots**: read `${MEMORY_DIR}/patterns/index.md` if it exists; report any Pattern concepts affecting current work.

## Phase 4: GitHub Integration

8. **Get GitHub owner/repo**: use the cached values from the session context (injected at SessionStart). Only if absent, parse once from `git remote get-url origin`.

9. **Fetch and display GitHub dashboard** (requires `gh` CLI; on failure check `gh auth status` and skip gracefully):
   - Open feature issues: `gh issue list --label feature --json number,title,labels`
   - Open PRs: `gh pr list --json number,title,headRefName,statusCheckRollup`
   - Cross-reference with `${FEATURES_FILE}`

10. **Sync GitHub Issues with `${FEATURES_FILE}`**:
    - For each GitHub issue with "feature" label NOT in active.json: add new entry with issueNumber linked
    - For each feature in active.json with status="passing" or passes=true: if the linked issue is still open, `gh issue close {number}`
    - Report sync results

## Phase 5: Recommendations

11. Report session summary:
    - Current state and blockers
    - Pending features and fixes prioritized
    - GitHub sync results
    - Recommended next action (in priority order):
      1. **Active loop (fix)**: Resume with `/claude-harness:flow {fix-id}`
      2. **Active loop (feature)**: Resume with `/claude-harness:flow {feature-id}`
      3. **Escalated loop**: Review history and provide guidance
      4. **Pending fixes**: Resume fix with `/claude-harness:flow {fix-id}`
      5. **No features (new project)**: Bootstrap with `/claude-harness:prd-breakdown @./prd.md`
      6. **Pending features**: Start implementation with `/claude-harness:flow {feature-id}`
      7. **No features (existing project)**: Add one with `/claude-harness:flow "description"`
      8. **Create fix for completed feature**: `/claude-harness:flow --fix {feature-id} "bug description"`

Versions

RepositoryScoreLicence
This page · panayiotism/claude-harness100MIT
tilnoteio/tilnote-blog100MIT
dedujeong/gemba100Apache-2.0
nextwork-projects/ai-video-editor-cooked100MIT
wrg32786/aigent-os100MIT
T-X-R/codex-game-studio100MIT
alienfast/claude100MIT
ratomirjovanovic/pandaward100AGPL-3.0
darioabc/massimo100MIT

Database snapshot: 13.11.2026 · package version 4ac8730ba704 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90start-issue
    Start implementation of a GitHub issue: fetch context, prepare worktree flow, implement with TDD, verify, and submit PR. Use for 'start issue #N', issue URLs, or requests to begin issue work. SKIP fully autonomous issue-to-merge requests; use complete-issue.
  • 100session-start
    Use this skill when initializing a session for any project repo. Autonomously analyzes git state, VCS issues, SSOT files, branches, environment, and cross-repo status. Then presents structured findings with recommendations before development wave planning, or an operations…
  • 100phronia-start
    Initializes an AI development session by reading workflow guides, developer identity, git status, active tasks, and project guidelines from .phronia/. Classifies incoming tasks and routes to brainstorm, direct edit, or task workflow. Use when beginning a new coding session,…
  • 100issue
    Start a feature from a GitHub issue — read the issue, extract its acceptance criteria deterministically (or propose and record them on the issue), then run the same pipeline as /concordia:feature. Use when the user gives an issue number.
  • 90start-work
    Begin or resume working on a Jira issue. Gets issue context, creates/checks out feature branch, shows MR feedback if exists, updates Jira status, searches related code, loads project gotchas. Use when user says "start work on AAP-X", "pick up issue", "begin work on AAP-12345".
  • 100pr-review
    PR Code Review (Local): perform a thorough local code review with full project context. Use when: (1) User asks to review a PR, (2) User says "/pr-review", (3) User wants to review code changes before merging.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.