trusty-mpm 0.8.1

trusty-mpm: unified multi-agent orchestration platform (core, daemon, CLI, TUI, Telegram)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

---
name: mpm-session-pause
description: Pause session and save current work state for later resume
user-invocable: true
version: "1.0.0"
category: mpm-command
tags: [mpm-command, session, pm-recommended]
effort: medium
---

# /mpm-session-pause

Pause the current session and save all work state for later resume.

## What This Does

When invoked, this skill:
1. Captures current work state (todos, git status, context summary)
2. Creates session file at `.trusty-mpm/sessions/session-{timestamp}.md` (project-local)
3. Updates `.trusty-mpm/sessions/LATEST-SESSION.txt` pointer
4. Shows user the session file path for later resume

## Usage

```
/mpm-session-pause [optional message describing current work]
```

**Examples:**
```
/mpm-session-pause
/mpm-session-pause Working on authentication refactor, about to test login flow
/mpm-session-pause Need to context switch to urgent bug fix
```

## PM Instructions for Pausing a Session

When invoked, the PM MUST:

1. **Capture current state:**
   ```bash
   git status
   git log --oneline -10
   ```

2. **Create the sessions directory:**
   ```bash
   mkdir -p .trusty-mpm/sessions
   ```

3. **Write session file** to `.trusty-mpm/sessions/session-{YYYYMMDD-HHMMSS}.md`:

   ```markdown
   # Session Pause - {timestamp}

   ## Summary
   {user-provided message or auto-generated from current todos}

   ## Completed
   {list of completed todos/tasks from current session}

   ## In Progress
   {list of in-progress todos with detailed state}

   ## Next Steps
   {list of pending todos and recommended next actions}

   ## Git Context
   Branch: {current branch}
   Last commit: {last commit hash and message}
   Uncommitted changes: {git status summary}

   ## Context
   {any additional context useful for resume}
   ```

4. **Update the pointer file:**
   ```
   .trusty-mpm/sessions/LATEST-SESSION.txt → session-{timestamp}.md
   ```

5. **Report to user:**
   ```
   Session paused successfully!

   Session file: .trusty-mpm/sessions/session-{timestamp}.md

   Quick resume: /mpm-session-resume
   ```

## What Gets Saved

**Session State:**
- Session ID and timestamp
- Current git branch, recent commits, and file status
- Primary task and current phase
- Context message (if provided)
- Current todo/task state (pending/in-progress/completed)

**Resume Instructions:**
- Quick-start summary
- Files to review
- Next recommended actions

## Session File Location

All session files are stored in the **project-local** directory:
```
<project-root>/.trusty-mpm/sessions/
├── LATEST-SESSION.txt          # Pointer to most recent session
└── session-YYYYMMDD-HHMMSS.md
```

Add `.trusty-mpm/sessions/` to `.gitignore` — session state is machine-specific.

## Use Cases

**Context switching:**
```
/mpm-session-pause Switching to urgent production bug
```

**End of work session:**
```
/mpm-session-pause Completed API refactor, ready for testing tomorrow
```

**When approaching context limit:**
```
/mpm-session-pause Hit context limit, starting fresh session
```

## Related Commands

- `/mpm-session-resume` — Resume from most recent paused session