# Session start Human Guide

## What This Is For
Start-of-session planning and prioritization. It gives the agent a clearer input/output frame for session start: what context to ask for, what decisions to make, and what usable artifact to return.

Use this as a human-readable version of the Session start agent skill. It is meant for marketers, operators, founders, and other non-coders who want the workflow without reading agent-specific implementation instructions.

## When To Use This
- Use this when you need a repeatable process for session start.
- Use this when the task needs judgment, examples, constraints, or a clear output format rather than a one-off prompt.
- Use this when you want to hand an AI assistant enough context to produce a usable marketing artifact.

## When Not To Use This
- Do not use this when you only need a quick factual answer.
- Do not use this when the work depends on private data you cannot share with the assistant.
- Do not use this as a replacement for legal, compliance, financial, or medical review.

## What You Need Before Starting
- The goal or business outcome you want.
- The audience, customer segment, or market context.
- Any source material the assistant should respect, such as notes, briefs, examples, URLs, or brand guidance.
- Constraints such as tone, length, channel, deadline, region, or approval requirements.
- A clear definition of what a good final answer should look like.

## Step-By-Step Workflow
1. State the job clearly: "Use the Session start guide to help me with..."
2. Add context: audience, goal, offer, channel, source material, and constraints.
3. Ask the assistant to identify missing inputs before producing the final output.
4. Have the assistant follow the skill-specific guidance below.
5. Review the result against the final checklist and ask for revisions where needed.

## Skill-Specific Guidance
- The shared state file, `company.*` (ICPs, messaging, quarterly_goals, key_metrics) and shared `recurring_tasks` (e.g. company-context-refresh, team-routing-refresh)
- The per-user state file, `user.*`, `current_focus`, `last_session`, `last_session_note`, `active_goals`, personal `recurring_tasks` (e.g. voice-guide-refresh), `preferences`, `reminders`
- `current_focus.initiative` and `session_goal` (from personal)
- `last_session.open_items` and `next_steps` (from personal)
- `recurring_tasks` from BOTH files, flag any whose `next_due` ≤ today
- `reminders` from personal, surface any whose `surface_when` matches today AND whose `surface_trigger` includes `session-start`
- `company` TODO placeholders (from shared), flag if company context is still unpopulated
- **In Progress**, currently active
- `current_focus.initiative` and `session_goal`
- If the memory injection mentions a concept, and a state file or memory file contradicts it, flag the specific conflict.
- If the user asks about a topic where the memory might be stale, verify the current state before answering.
- If the user explicitly asks "is my memory current," then spot-check. Otherwise defer to session-end's learning capture.

## Decision Points And Nuance
The original skill emphasizes: How this skill relates to a memory plugin, Step 1: Read structured state, Step 2: Pull open tickets, Step 3: Analyze and prioritize, Step 4: Set due dates (with permission), Step 5: Set session focus, Memory staleness: reactive only, Output format, Good morning, Carried forward from last session.

Use these questions to steer the work:
- What is the intended audience or buyer?
- What source material must be preserved?
- What should the assistant optimize for: clarity, persuasion, accuracy, speed, creativity, or conversion?
- What examples represent the desired quality bar?
- What should the assistant avoid?

## Common Mistakes
- If you keep a spaced-repetition review file, check it too: if any cards are due (`next_review <= today`), add a one-line mention to the summary. Do not auto-run the review.
- **Never write personal session state to the shared state file**, that file is the shared company source of truth. Each user owns their own session state in their per-user file.
- Do NOT proactively scan every memory entry on every session start, that's wasteful. Instead:
- Do not read local session-log files. The memory plugin's injection covers session history.
- Do not proactively scan all memory entries on every session start.
- Do not summarize memory observations back to the user, they already see them.

## Copy-And-Paste Prompt
```text
Use the Session start human guide.

My goal:
[Describe the business outcome]

Audience:
[Describe who this is for]

Context and source material:
[Paste notes, examples, links, or existing copy]

Constraints:
[Tone, length, channel, timeline, must-include items, must-avoid items]

Before producing the final output, ask me for any missing information that would materially improve the result.
```

## Final Checklist
- [ ] The output matches the original goal.
- [ ] The audience and context are reflected in the answer.
- [ ] Important constraints and source material were preserved.
- [ ] The assistant made the relevant decisions explicit.
- [ ] The final artifact is ready to use, review, or hand to the next person.

## Source
This guide was generated from the Marketing Engineering Podcast skill entry for `wispr-flow-session-start`.

## Source Skill Notes
These notes preserve the nuance from the original skill. Use them as supporting reference when the workflow above feels too generic.

# Session Start: Daily Planning

Initializes your session with structured state, open tickets, and a prioritized plan. Relies on a memory plugin's automatic session-start injection for observation history, so it does not re-read local session logs.

> Adapt the file paths and tool names below to your own setup. This skill assumes two state files (a shared one and a per-user one), an issue tracker, and an optional memory plugin. Swap in whatever you use.

## How this skill relates to a memory plugin

If you run a memory plugin (for example, Claude Mem), it already injects recent observations and session summaries into context at session start (you see a "recent context" table with session IDs, timestamps, and types at the top of the session). **This skill does not duplicate that.** It adds what the memory layer doesn't track: structured current focus, recurring tasks, open tickets, and prioritization.

## Step 1: Read structured state

Resolve the current user (most setups map the logged-in OS user to a profile name).

Read **two files**:
1. The shared state file, `company.*` (ICPs, messaging, quarterly_goals, key_metrics) and shared `recurring_tasks` (e.g. company-context-refresh, team-routing-refresh)
2. The per-user state file, `user.*`, `current_focus`, `last_session`, `last_session_note`, `active_goals`, personal `recurring_tasks` (e.g. voice-guide-refresh), `preferences`, `reminders`

Extract:

- `current_focus.initiative` and `session_goal` (from personal)
- `last_session.open_items` and `next_steps` (from personal)
- `recurring_tasks` from BOTH files, flag any whose `next_due` ≤ today
- `reminders` from personal, surface any whose `surface_when` matches today AND whose `surface_trigger` includes `session-start`
- `company` TODO placeholders (from shared), flag if company context is still unpopulated

If you keep a spaced-repetition review file, check it too: if any cards are due (`next_review <= today`), add a one-line mention to the summary. Do not auto-run the review.

Do NOT re-read local session-log files. The memory plugin's injection at the top of context already tells you what happened last session. If the injection is missing or empty, ask: "What did we do last time?" then use the memory plugin's search tool to pull it.

Output a brief summary:

```
**Last session:** [from the memory injection, cite session IDs]
**Carried forward:** [from per-user state last_session.open_items]
**Recurring task due:** [Task name], [how to run] (if any)
**Reminders surfacing:** [Reminder title, if any matched today]
**Review:** [N cards due, only if any are due]
```

## Step 2: Pull open tickets

Query your issue tracker for issues assigned to the current user, in statuses Todo, In Progress, and Backlog (read the assignee from the per-user state file).

Filter and categorize:
- **In Progress**, currently active
- **Todo**, ready to work on
- **Backlog**, needs triage

## Step 3: Analyze and prioritize

| Factor | Weight |
|--------|--------|
| Due date < 3 days | High |
| High priority in tracker | High |
| Blocking others | High |
| Quick win (< 30 min) | Medium |
| No due date set | Flag for setting |

Create a prioritized list with clear reasoning.

## Step 4: Set due dates (with permission)

For tasks without due dates, suggest dates based on complexity and current workload.

> "These tasks need due dates. Should I set them?
> - [Task 1] → Suggested: [Date]
> - [Task 2] → Suggested: [Date]"

On approval, update the tickets.

## Step 5: Set session focus

> "What's your main focus for today?
> 1. [Top priority]
> 2. [Second priority]
> 3. Something else (specify)"

Update the per-user state file (NOT the shared one):
- `current_focus.initiative` and `session_goal`