Claude Cowork Open Threads + Wiki Seed File

gistfile1.txt

# Open Threads + Knowledge Wiki — Cowork Bootstrap

> **What this is:** Drop this file into your Cowork workspace folder and tell Claude: "Read this file and build this system for me." It will ask you a series of calibration questions, then create the entire folder structure, templates, scheduled scans, and a skill file — all tailored to your role, tools, and communication style.
>
> **What you'll get:** A two-layer AI memory system. Layer 1 tracks your active threads — every initiative, escalation, decision, and follow-up you're juggling — with daily automated scans that pull from your actual work tools. Layer 2 is a knowledge wiki that accumulates durable context about the people, systems, patterns, and decisions in your world. When a thread is done, the knowledge graduates to the wiki. Nothing learned is ever lost.
>
> **Requirements:** Claude in Cowork mode with file access and scheduling enabled. At least one connected integration (Slack, email, calendar, Jira, Confluence, Linear, Notion, etc.) for automated scanning. Works without integrations too — you just update journals manually.
>
> **Browsing (optional but recommended):** The system is just a folder of `.md` files. You can browse it with Obsidian, VS Code, or any markdown editor. Obsidian is particularly good because it renders the cross-references between files as a navigable graph.

---

## Phase 1: Calibration

Before building anything, Claude should ask the following questions — one message, multiple choice where possible, free text where needed. Don't skip this. The answers shape every file and routine that follows.

### Questions to ask:

**1. About you**
- What's your name?
- What's your role and title?
- What company/org do you work in?
- How many people do you lead or work with closely? (Rough number is fine)
- What's your timezone?
- What are your typical working hours?

**2. Your communication style**
- How would you describe your writing style? (Options: direct and concise / structured and thorough / casual and conversational / formal and precise / other)
- Any phrases, tones, or patterns you want Claude to match when drafting messages?
- Any phrases or styles you explicitly want to avoid? (e.g., "I hope this message finds you well", corporate jargon, forced enthusiasm)
- Do you adjust style by audience? If yes, describe: e.g., "leadership gets bullet points and data, engineers get technical and specific, peers get casual"

**3. Your tools — what to scan**
Ask which of the following the user has connected (or plans to connect) to Cowork. For each, gather specifics:

| Tool | If connected, ask... |
|------|---------------------|
| **Slack** | Key channels to monitor? Any DMs/group DMs to watch? Want @mention tracking? |
| **Microsoft Teams** | Key channels/chats to monitor? |
| **Email (Outlook/Gmail)** | Key senders or threads to watch? Keywords? |
| **Calendar (Outlook/Google)** | Want upcoming-meeting flagging for tracked topics? |
| **Confluence** | Any recurring meeting pages to scan for new notes? (parent page IDs) |
| **Notion** | Any databases or pages to monitor? |
| **Jira** | Any boards, projects, or saved filters to watch? |
| **Linear** | Any teams or projects to track? |
| **GitHub/GitLab** | Any repos, PRs, or issues to monitor? |
| **Asana** | Any projects or portfolios? |
| **Other** | Free text — any other tools with Cowork connectors? |

For tools not connected: note them as "planned" or "manual" — the system still works, you just add journal entries by hand or by asking Claude.

**4. What you're tracking right now**
- What are the top 3-5 things on your plate right now? (Just names/one-liners — we'll build proper topic files for each)
- Are there any ongoing threads you keep losing track of?
- Any recurring meetings where decisions get made that you need to capture?

**5. Preferences**
- What time should the daily scan run? (Suggest: 30 min before your workday starts)
- Do you want an end-of-day summary as well? (Suggest: yes, lightweight — flags unanswered mentions and stale topics)
- Do you want weekly digests? (Suggest: Friday afternoon — what progressed, what stalled, what to archive)
- Where should draft messages (Slack, email) be saved? (Default: `outputs/` folder with date prefix)

---

## Phase 2: Build the folder structure

After calibration, create the following structure in the user's Cowork workspace folder. Use the calibration answers to fill in the `[bracketed]` values.

```
.claude/
  CLAUDE.md                          ← Session bootstrap instructions
  skills/
    topic-tracker.md                 ← The core skill (generated from template below)
    message-drafter.md               ← Optional: message drafting skill

context/
  about-me.md                        ← Role, reports, stakeholders, tools
  current-priorities.md              ← This week's focus (updated weekly)
  voice-and-style.md                 ← Communication style calibration
  working-rules.md                   ← Rules for Claude (draft-not-send, etc.)

follow-ups/
  REGISTRY.md                        ← Master table of all tracked topics
  topics/
    active/                          ← One .md file per active topic
    archived/                        ← Completed topics (knowledge graduated)

wiki/
  index.md                           ← Catalog of all wiki pages
  log.md                             ← Append-only record of wiki operations
  entities/                          ← People, teams, systems, products
  concepts/                          ← Recurring patterns, frameworks
  decisions/                         ← Major decisions with rationale
  syntheses/                         ← Cross-cutting analyses

outputs/                             ← All generated files (drafts, briefs, etc.)
```

---

## Phase 3: Generate core files

### 3a. `.claude/CLAUDE.md`

This is the session bootstrap file. Claude reads it at the start of every session.

```markdown
# Session Bootstrap

Before starting any task:
1. Read all files in `context/` directory
2. Read `follow-ups/REGISTRY.md` for active topics
3. If the task relates to a specific topic, read its journal in `follow-ups/topics/active/`
4. Check `wiki/index.md` for relevant knowledge wiki pages
5. Acknowledge what you know in one line, then proceed

## System Architecture

Two layers work together:
- **`follow-ups/`** — operational tracker (active threads, actions, deadlines, mentions)
- **`wiki/`** — persistent knowledge base (entity profiles, concepts, decisions, syntheses)

The follow-ups system captures what's happening now.
The wiki captures what you've learned over time.
When topics get archived, their durable knowledge graduates to the wiki.
The wiki compounds — nothing learned is ever lost.

If asked to update, create, or scan topics, read the skill file:
`.claude/skills/topic-tracker.md`
```

### 3b. `context/about-me.md`

Populate from calibration answers (Q1). Include:
- Name, role, company, team size
- Direct reports and key stakeholders (if provided)
- Tools used daily
- Timezone and working hours

### 3c. `context/voice-and-style.md`

Populate from calibration answers (Q2). Include:
- Writing style description
- Audience-specific adjustments
- Phrases/patterns to use
- Phrases/patterns to avoid
- Any examples the user provided

### 3d. `context/working-rules.md`

Generate from calibration answers. Always include these defaults (user can modify later):

```markdown
# Working Rules

## Before Starting Any Task
1. Read all context files first
2. If the task is ambiguous, ask one clarifying question — don't guess
3. Never delete files without explicit confirmation

## Message Drafting
- Always draft — never send without review
- Match the recipient's communication style per voice-and-style.md
- Include recipient name in the output filename

## Follow-Up Tracking
- When [USER] mentions something to follow up on, create or update the relevant topic
- Tag the source in journal entries (Slack, Email, Calendar, etc.)

## Outputs
- Save all generated files to `outputs/`
- Use naming: YYYY-MM-DD_[description].[ext]

## Timezone
- Default to [USER_TIMEZONE] for all time references
```

### 3e. `context/current-priorities.md`

Populate from calibration answers (Q4). Structure:

```markdown
# Current Priorities — Week of [DATE]

> [One-line summary of what this week is about]

## Top Priorities
1. **[Topic name]** — [one-line status + next action]
2. **[Topic name]** — [one-line status + next action]
3. ...

## Waiting On
- **[Person]** — [what you're waiting for]

## Key Meetings This Week
- [Day/time: meeting name — what to prepare]
```

### 3f. `follow-ups/REGISTRY.md`

Initialize with the topics from calibration Q4:

```markdown
# Open Threads Registry

> Last updated: [DATE] (initial setup)
> Active topics: [N] | Archived: 0

## Active Topics

| ID | Topic | File | Status | Priority | Owner | Started | Last Activity | Next Action | Due |
|----|-------|------|--------|----------|-------|---------|---------------|-------------|-----|
| T-001 | [Topic from calibration] | `topics/active/[filename].md` | 🟡 In Progress | #1 | [User] | [TODAY] | [TODAY] | [From calibration] | [If known] |

### Status Key
- 🟢 On Track — progressing as expected
- 🟡 In Progress — active but needs monitoring
- 🔴 Needs Attention — blocked, overdue, or at risk
- ⏸️ Paused — intentionally on hold
- ✅ Done — ready to archive

## Recently Archived
| ID | Topic | File | Resolved | Outcome |
|----|-------|------|----------|---------|

## Topic Naming Convention
- File name: lowercase, hyphenated, descriptive (e.g., `product-launch.md`)
- ID: sequential T-XXX
```

### 3g. Topic journal template

For each topic from calibration, create a file in `topics/active/`:

```markdown
# [Topic Name]

## Meta
- **ID:** T-[XXX]
- **Status:** [emoji + label]
- **Priority:** #[N]
- **Started:** [DATE]
- **Key People:** [names and roles]
- **[Source Type] Channels:** [channels/threads to monitor — one line per connected source]
- **Stakes:** [Why this matters — one or two sentences]

## Current State
[What's happening right now — 2-3 sentences]

## Next Actions
| Action | Owner | Due | Status |
|--------|-------|-----|--------|
| [action] | [who] | [when] | ⬜ Pending |

## Open Questions
- [ ] [question]

## Decision Log
| Date | Decision | Rationale | Decided By |
|------|----------|-----------|------------|

---

## Journal

### [DATE] (initial entry)
**Source:** Setup calibration
[Whatever context the user provided about this topic]
```

### 3h. Wiki initialization

Create minimal wiki files:

**`wiki/index.md`:**
```markdown
# Wiki Index

> Last updated: [DATE] (initial setup)
> Pages: 0 entities, 0 concepts, 0 decisions, 0 syntheses

## Entities
(Pages will be created as topics generate durable knowledge)

## Concepts
(Patterns will be identified as the system accumulates data)

## Decisions
(Major decisions will be captured from topic journals)

## Syntheses
(Cross-cutting analyses will emerge over time)
```

**`wiki/log.md`:**
```markdown
# Wiki Log

Append-only chronological record of all wiki operations.

---

## [DATE] init | Wiki system created
Initial setup. Wiki will be populated as topics generate durable knowledge
through daily scans, archival graduations, and manual ingests.
```

---

## Phase 4: Generate the skill file

Create `.claude/skills/topic-tracker.md` — this is the instruction set that tells Claude how to operate the system. Generate it dynamically based on which tools the user has connected.

The skill file must cover these operations:

### Daily Scan
1. Read `REGISTRY.md` to know what topics exist
2. For each active topic, read its journal file
3. Scan all configured sources for new activity since last journal entry:
   - For each connected tool, include specific scan instructions using the tool's MCP functions
   - Tag sources in journal entries (e.g., `Slack (#channel)`, `Email (from: person)`)
4. For each topic with new activity:
   - Add timestamped journal entry (newest first)
   - Update "Current State" if meaningfully changed
   - Update "Next Actions" — mark completed ✅, add new ones
   - Move answered Open Questions to checked `[x]`
   - Add new decisions to Decision Log
   - Flag upcoming meetings (next 48h) relevant to the topic
5. Update REGISTRY.md rows (Last Activity, Next Action, Due, Status)
6. Flag stale topics (7+ days no activity): "follow up, pause, or archive?"
7. Run wiki ripple (see below)

### Mention tracking (if Slack/Teams connected)
- Search for @mentions of the user since last scan
- Check if user has responded (reply or emoji reaction)
- Track in a Pending Mentions table in REGISTRY.md
- Flag mentions older than 48h without acknowledgment

### Create new topic
- Gather: name, key people, relevant channels/threads, stakes
- Create journal file from template in `topics/active/`
- Assign next T-XXX ID
- Add row to REGISTRY.md

### Archive topic
- Add final journal entry
- Move file from `topics/active/` to `topics/archived/`
- Move REGISTRY.md row to Recently Archived
- Graduate durable knowledge to wiki (see below)

### Context brief ("catch me up on X")
- Read topic journal
- Produce: current state, key timeline (compressed), what's pending, recommended next move
- Keep under 1 page

### Follow-up message drafting
- Read relevant topic journal
- Draft message in appropriate channel (Slack/email/Teams) based on original thread
- Reference specific journal context
- Include clear ask + deadline
- Match recipient style per voice-and-style.md

### Wiki operations

**Ripple (after every daily scan):**
- For topics with new activity, check if wiki pages need updating:
  - Entity pages (people, systems) — new initiatives, feedback, workload changes
  - Concept pages — patterns reinforced, contradicted, or nuanced
  - Decision pages — new decisions made
  - Synthesis pages — underlying data changed
- If a new cross-topic pattern emerges, create a concept page
- Update `wiki/index.md` and append to `wiki/log.md`
- Only ripple when there's durable knowledge — daily status updates stay in journals only

**Graduate (when archiving a topic):**
- Review entire topic journal for durable knowledge
- Update/create: decision records, entity updates, concept pages, lesson-learned captures
- Add "Graduated to wiki" note in archived topic
- Append to `wiki/log.md`

**Lint (weekly — suggest Friday afternoons):**
- Check for: contradictions between pages, stale pages (30+ days), orphan pages (no inbound links), gaps (frequently mentioned entities without pages)
- Suggest new synthesis pages based on cross-topic patterns
- Output brief lint report, fix non-controversial issues

**Ingest (manual — when user provides new source material):**
- Read and extract key information
- Discuss key takeaways with user
- Update relevant wiki pages, create new ones if needed
- Update index, append to log

---

## Phase 5: Create scheduled tasks

After building all files, create the following scheduled tasks using Cowork's scheduler:

### 1. Daily morning scan
- **Schedule:** Every weekday at [USER_SCAN_TIME] (from calibration Q5)
- **Task:** Run the full daily scan as defined in the skill file. Read REGISTRY.md, scan all connected sources, update topic journals, update REGISTRY, flag stale topics and pending mentions, run wiki ripple. Save scan summary to `outputs/[DATE]_morning-scan.md`.

### 2. End-of-day check (if user opted in)
- **Schedule:** Every weekday at [30 min before end of working hours]
- **Task:** Lightweight check. Flag: unanswered @mentions, topics that had activity today but no journal update, any next actions due tomorrow. Save to `outputs/[DATE]_eod-check.md`.

### 3. Weekly wiki lint (if user opted in)
- **Schedule:** Every Friday at [USER_PREFERRED_TIME or 15:00]
- **Task:** Run wiki lint operation. Check contradictions, stale pages, orphans, gaps. Suggest new pages. Save report to `outputs/[DATE]_wiki-lint.md`.

### 4. Weekly digest (if user opted in)
- **Schedule:** Every Friday at [after lint, or USER_PREFERRED_TIME]
- **Task:** Produce weekly summary: topics that progressed, topics that stalled, overdue actions, topics recommended for archiving, new topics created. Save to `outputs/[DATE]_weekly-digest.md`.

---

## Phase 6: Seed initial content

After creating all structure:

1. For each topic from calibration, offer to do an initial scan of connected tools to populate the first journal entries with real context
2. Create entity pages for any key people the user mentioned during calibration
3. Update `wiki/index.md` with whatever was created
4. Show the user a summary: "Here's what I built — [N] files across [structure]. Your first scan will run at [time] tomorrow. You can also say 'scan now' anytime."

---

## Post-Setup Tips (show to user after completion)

**Getting started:**
- Say "scan now" or "run a scan" to trigger a manual scan anytime
- Say "catch me up on [topic]" for a context brief
- Say "new topic: [name]" to start tracking something new
- Say "archive [topic]" when something is resolved

**Building the wiki over time:**
- The wiki starts empty and that's fine — it populates organically through daily scans and topic archival
- After 2-3 weeks of daily scans, you'll start seeing entity pages with real accumulated context
- After your first few topic archivals, concept pages will begin forming around patterns you didn't know you had
- The wiki lint (Fridays) will suggest new pages when it spots gaps

**If you use Obsidian:**
- Point an Obsidian vault at the workspace folder
- Enable backlinks and graph view
- The cross-references between topic journals, entity pages, and concept pages will render as a navigable knowledge graph
- Install the "Dataview" plugin for queryable views of your REGISTRY

**Maintaining the system:**
- The system is self-maintaining through scheduled scans — your main job is to review scan outputs and act on what matters
- Periodically review concept pages — they reflect your patterns back at you, which can be confronting but useful
- If a topic goes stale and you don't care, archive or delete it. A 30-row registry with 20 stale topics is worse than a 10-row registry where everything is alive