# Finish Work

> Mandatory gate for ending work sessions. Checks if minimum work duration has elapsed before allowing completion. ALWAYS use this skill before claiming work is complete.

- Skill: `majiayu000/finish-work-3` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add majiayu000/finish-work-3`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/finish-work-3/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/majiayu000/finish-work-3

---


# Finish-Work Gate

**MANDATORY:** Use this skill BEFORE claiming work is complete, before creating final commits, or before ending any work session.

## Purpose

Prevents early work termination by enforcing minimum work durations. The agent does not have permission to declare work complete without passing through this gate.

## Relationship to Other "Finish" Tools

**Different scopes - use in sequence:**

| Tool | Scope | When to Use |
|------|-------|-------------|
| `finish-work` skill | **Session-level** | Check time gate BEFORE any completion |
| `/finish` command | **Documentation** | Create handoff docs AFTER time gate passed |
| `finishing-a-development-branch` | **Branch-level** | Git workflow (merge/PR/discard) AFTER work complete |
| `verification-before-completion` | **Quality** | Verify tests/evidence BEFORE declaring done |

**Correct sequence:**
```
Work Session
  → finish-work skill (time gate check - must pass first)
    → verification-before-completion (quality check)
      → /finish command (handoff documentation)
        → finishing-a-development-branch (git workflow - if applicable)
```

**Important:** 
- `/finish` assumes work is complete - it doesn't check time gate. Run `finish-work` FIRST.
- `finishing-a-development-branch` is for branch management after work is truly done.

## The Iron Rule

```
NO WORK COMPLETION WITHOUT PASSING THE FINISH-WORK GATE
```

## How to Use

### Checkpoint Mode (During Long Sessions)

Every ~30 minutes of work, run a quick checkpoint:

```powershell
$manifest = Get-Content .session_manifest.json | ConvertFrom-Json
$start = [DateTime]$manifest.started
$now = Get-Date
$elapsed = $now - $start
$remaining = $manifest.minimum_minutes - $elapsed.TotalMinutes
Write-Host "⏰ Checkpoint: $([int]$remaining) minutes remaining until $($manifest.target_end)"
```

**Purpose:** Keeps the time commitment fresh in your mind. Cheap insurance against forgetting.

### When You Think You're Done

#### Step 1: Check for Bypass Attempts

**STOP if you find yourself thinking or typing:**
- "Work is complete"
- "I'm done"  
- "Finished"
- "Wrapping up"
- "Session complete"

**If you haven't run finish-work skill yet, you're trying to bypass the gate.**

#### Step 2: Read Session Manifest
```bash
Get-Content .session_manifest.json | ConvertFrom-Json
```

#### Step 3: Calculate Elapsed Time
```powershell
$manifest = Get-Content .session_manifest.json | ConvertFrom-Json
$start = [DateTime]$manifest.started
$now = Get-Date
$elapsed = $now - $start
$remaining_minutes = $manifest.minimum_minutes - $elapsed.TotalMinutes
```

#### Step 4: Gate Decision

**IF remaining_minutes > 0:**
```
⏰ SESSION INCOMPLETE - CONTINUE WORKING

Started: {start_time}
Target:  {target_end}
Elapsed: {elapsed_minutes} minutes
Minimum: {minimum_minutes} minutes
Remaining: {remaining_minutes} minutes

YOU MAY NOT FINISH YET.

Find more work to do:
- Review the codebase for issues
- Add documentation
- Run additional tests
- Refactor for clarity
- Add error handling
- Improve comments
- Check for edge cases
- Optimize performance
- Add logging
- Review similar implementations for patterns

DO NOT stop working. Continue until time elapsed.
```

**IF remaining_minutes <= 0 OR manifest is missing:**
```
✅ SESSION COMPLETE

Minimum duration met. Proceed with:
1. Final verification (run tests)
2. Clean commits
3. Push to origin
4. Session summary
```

## Session Manifest Format

File: `.session_manifest.json` (in project root)

```json
{
  "session_id": "unique-name",
  "started": "2026-01-27T23:00:00",
  "target_end": "2026-01-28T01:00:00",
  "minimum_minutes": 120,
  "reason": "Why this work block exists",
  "hard_stop": true,
  "created_by": "user"
}
```

### Fields
- `session_id`: Unique identifier for this work block
- `started`: ISO timestamp when work began
- `target_end`: ISO timestamp when work should end
- `minimum_minutes`: Minimum work duration (enforced)
- `reason`: Purpose of this work block
- `hard_stop`: If true, cannot finish before minimum_minutes
- `created_by`: Who created the session (user or agent)

### Context Recovery

If context was compacted, re-read .session_manifest.json to verify time remaining. Time gates still apply regardless of context state.

## If Manifest Is Missing

**Create one immediately:**
```powershell
@{
  session_id = "recovery-$(Get-Random)"
  started = (Get-Date).ToString("o")
  target_end = (Get-Date).AddHours(2).ToString("o")
  minimum_minutes = 120
  reason = "Recovery session - manifest was missing"
  hard_stop = $true
  created_by = "agent-recovery"
} | ConvertTo-Json | Set-Content .session_manifest.json
```

Then continue working.

## Why This Matters

Early stopping wastes:
- **Context** built up during work
- **Human time** spent reviewing incomplete work
- **Opportunity** to catch issues with fresh eyes
- **Trust** when claims of completion are false

The finish-work gate ensures:
- Work blocks are honored
- Sufficient time for quality
- No premature "completion" claims
- Respect for time commitments

## Common Rationalizations (REJECT THESE)

| Excuse | Reality |
|--------|---------|
| "I'm done with the task" | There's always more to do (docs, tests, polish) |
| "No more work to do" | Look harder - edge cases, cleanup, validation |
| "I've been working hard" | Elapsed time ≠ Worked time, keep going |
| "The tests pass" | Great, now add more tests, review, document |
| "I need a break" | Not an option until time elapsed |
| "I'll finish tomorrow" | Violates the commitment made |

## The Bottom Line

**Work the full duration. No exceptions. This skill enforces that.**

If the gate says continue: YOU CONTINUE.

---

*This skill is non-negotiable. Use it every time.*