Map Munder Difflin Architecture

Use a local agent team to create an evidence-backed map of its codebase.

Introduction

30 Second Summary

A large software project often explains itself across design notes, source files, logs, and memory records. A quick read can sound convincing while leaving important connections hidden.

text span with marks requires non-empty texttext span with marks requires non-empty texttext span with marks requires non-empty texttext span with marks requires non-empty texttext span with marks requires non-empty texttext span with marks requires non-empty textIn this project, you will use to coordinate and as repository specialists. Michael will combine their findings into an evidence-backed REPO-MAP.md that explains how the application works.

What You'll Build

You will watch Michael coordinate two live before opening a finished REPO-MAP.md in with its architecture claims tied to real repository files.

By the end of this project, you'll have:

A working Free Classic office where you can watch Claude Code and Codex research the same repository through separate agent terminals.
A delegated research workflow where one brief to Michael becomes two focused assignments with visible specialist reports.
An evidence-backed architecture map in REPO-MAP.md that lets you trace both data planes, the renderer bridge, message routing, and memory back to HIVE.md, docs/ARCHITECTURE.md, and the hive’s plain-file trail.
Secret Mission: A restart test that checks whether Michael recovers both specialist assignments plus one verified finding from each through .

Are there any prerequisites?

Before We Start

Before the hands-on work begins, lock in the result you want to create. This goal keeps every agent assignment focused on producing evidence you can verify.

Install the Office and Open the Repository

Your written goal needs an office where the agent team can work. Munder Difflin provides that local coordination space.

The maintained desktop build keeps this first session focused on orchestration. You can connect Claude Code with Codex without compiling the application from source.

Why the DMG?

The DMG contains the signed and notarized v0.5.2 release used throughout this project. The public source currently reports 0.4.6 in package.json because v0.5.2 is a binaries-only release.

Building from source also requires Node.js, npm, and a C/C++ toolchain for node-pty. The DMG keeps this project focused on agent orchestration, while the repository cloned later supplies the source files the agents investigate.

In this step, get ready to:

Install Munder Difflin 0.5.2 in /Applications.
Configure a Free Classic office with Michael as its Claude Code orchestrator.
Prepare the local repository for research in Visual Studio Code.

Install Munder Difflin 0.5.2

Version 0.5.2 provides the maintained desktop experience used throughout this project. Choose the tab that matches the Munder Difflin installation currently on your Mac.

✔️ I see version 0.5.2

Your Mac already has the required release. Confirm the installed version before continuing.

Open Finder from the Dock.
Select Applications in the Finder sidebar.
Select Munder Difflin in /Applications.
Press Cmd+I to view the app information.
Confirm the app information shows 0.5.2.
Close the app information window.
Double-click Munder Difflin in /Applications.

ⓧ I see an older version

An older release does not match the interface used in this project. Install the maintained release over the existing copy.

Open the official release page for v0.5.2.
Download Munder-Difflin-0.5.2-mac-universal.dmg from the release assets.
Open Munder-Difflin-0.5.2-mac-universal.dmg from your Downloads folder.
Drag Munder Difflin into the Applications folder shown in the installer window.
Approve the replacement when macOS asks.
Double-click Munder Difflin in /Applications.

ⓧ Munder Difflin is not installed

The universal macOS installer contains the complete desktop application. Installation only copies the app into your Applications folder.

Open the official release page for v0.5.2.
Download Munder-Difflin-0.5.2-mac-universal.dmg from the release assets.
Open Munder-Difflin-0.5.2-mac-universal.dmg from your Downloads folder.
Drag Munder Difflin into the Applications folder shown in the installer window.
Double-click Munder Difflin in /Applications.

Munder Difflin now opens to its first-launch onboarding. The next screens connect the local office to your account.

App Does Not Open?

Confirm that you dragged Munder Difflin into /Applications instead of running it from the disk image.

If the app information shows an older version, repeat the installation with Munder-Difflin-0.5.2-mac-universal.dmg.

Still stuck? Help me troubleshoot why Munder Difflin does not open on my Mac. You can also compare your setup with the official release page.

Set up Michael and check the agent engines

Your harnessMD account connects the desktop app to its onboarding flow. The browser handles your credentials without placing them in the project workspace.

Select On my own on the onboarding screen.
Complete the browser sign-in or account creation.
Return to Munder Difflin after the browser confirms your account.

Your account is now connected to the local app. The remaining choices define who coordinates the office and where its persistent files live.

Enter Michael as the orchestrator name.
Select Claude Code as the orchestrator engine.
Create a local folder from the workspace picker.
Select that folder as the Munder Difflin workspace.
Record the selected workspace path here: MUNDER_WORKSPACE.
Select Continue with the free version.

You should now see the Classic office floor with Michael as the orchestrator. The selected workspace stores the hive state that later records agent identities and messages.

What Does Free Classic Use?

Free Classic runs the office locally. Munder Difflin wraps the Claude Code and Codex terminal agents through the subscriptions or credentials you already use.

Closing the app or putting your Mac to sleep stops the local agents. Your workspace files remain available for the next session.

The office depends on both agent engines being available to the app. The prerequisite check verifies each integration before you create the research team.

Click Settings in Munder Difflin.
Select Prerequisites.
Click Check now.
Confirm Claude Code is shown as available.
Confirm Codex is shown as available.

Each prerequisite status now tells you whether Munder Difflin can start that agent engine. An unavailable status needs to be resolved before the repository research begins.

Allow Munder Difflin to install any missing CLI in that agent's terminal.
Complete the provider sign-in inside the agent terminal when requested.
Return to Prerequisites.
Click Check now again.

Both Claude Code and Codex should now appear as available. That clears the agent-engine setup for the rest of the project.

Agent Engine Still Unavailable?

Make sure the installation finishes inside the affected agent terminal. Complete that provider's sign-in before checking the status again.

Need help? Help me diagnose why an agent engine remains unavailable in Munder Difflin. You can also report installation details through the Munder Difflin issue tracker.

Clone the repository and verify the research files

A local Git clone gives the specialists a shared source tree. The clone contains the architecture documents that later anchor every claim in the map.

Press Cmd+Space to open Spotlight.

You should see the Spotlight search field on your screen.

Type Terminal into Spotlight.
Press Enter to open macOS Terminal.

You should now see a Terminal window with a command prompt.

Move to your Desktop by running this command:

cd ~/Desktop

What Does This Command Do?

The cd command sets your Desktop as the current folder. The repository will appear somewhere predictable after the clone finishes.

Clone the Munder Difflin repository by running:

git clone https://github.com/chaitanyagiri/munder-difflin.git

What Does This Command Do?

The git command downloads the public repository into a new munder-difflin folder on your Desktop. This local copy becomes the specialists' research workspace.

Wait for the clone operation to finish.
Confirm Terminal returns to a command prompt.

The completed command means the repository files now exist inside ~/Desktop/munder-difflin.

Repository Did Not Clone?

Check that your Mac still has an internet connection. Confirm that the clone command matches the official repository URL exactly.

If a previous attempt created a munder-difflin folder, inspect that folder before running the clone again.

Still blocked? Help me troubleshoot the Munder Difflin repository clone. You can also check the repository issue tracker.

Press Cmd+Space to open Spotlight.

Spotlight is ready to find the editor already installed on your Mac.

Type Visual Studio Code into Spotlight.
Press Enter to open Visual Studio Code.
Click File in the top menu bar.
Click Open Folder.
Select the munder-difflin folder on your Desktop.
Click Open.

Why These Research Files Matter

The repository overview lives in README.md. The deeper collaboration model lives in HIVE.md.

The Electron process boundaries live in docs/ARCHITECTURE.md. Together these files provide the evidence needed for the later architecture map.

Before the final check, which window should show the office floor and which should show the three research files?

Switch back to Munder Difflin.
Arrange the Munder Difflin window beside Visual Studio Code.
Confirm the Classic office floor is visible.
Confirm README.md is listed in the Visual Studio Code Explorer.
Confirm HIVE.md is listed in the Visual Studio Code Explorer.
Expand the docs folder in the Visual Studio Code Explorer.
Confirm ARCHITECTURE.md is listed inside docs.

That is the setup hurdle cleared. You should see the Classic office floor beside a repository containing README.md, HIVE.md, and docs/ARCHITECTURE.md.

Your office and source material are ready. Next, one Claude Code agent will attempt the first constrained repository map.

Test a Single-Agent Repository Map

Your Free Classic Munder Difflin office is ready. The cloned repository is still open in Visual Studio Code.

A single Claude Code researcher gives you a baseline before you build a team. Its evidence comes only from README.md.

The baseline gives you a fast architecture sketch from one source. A completeness test then shows what that source can support.

In this step, get ready to:

Add a Claude Code agent named README Scout.
Generate a five-bullet architecture map using only README.md.
Compare the map against a completeness test.

Add the README Scout agent

A terminal agent needs a named role plus a working folder. The folder keeps its repository access focused on the files you want researched.

Switch back to Munder Difflin from earlier.
Click add agent on the Classic office floor.
Select Claude Code as the agent engine.
Enter README Scout as the agent name.
Choose the local munder-difflin folder from the folder picker.
Use the setup panel's final control to add the agent to the Classic floor.
Confirm that README Scout is visible in the office.

You should now see README Scout as a Claude Code agent with the cloned repository as its working folder.

Why limit the working folder?

The working folder defines the repository that README Scout can research. This keeps the task focused on the cloned munder-difflin codebase.

🙋‍♀️ README Scout missing from the floor?

Check that you selected Claude Code as the agent engine.
Check that the selected folder is the local munder-difflin repository.
Repeat the agent setup if the panel closed before adding README Scout.

Still stuck? Help me add a Claude Code agent to my Munder Difflin Classic office.

Run the README-only assignment

A strict source boundary makes the report easy to evaluate. Every claim must come from one visible file.

Before you send the assignment, do you think one file can support every requested architecture connection?

Send the constrained research assignment by pasting this text into README Scout's terminal:

Read only `README.md`. Produce a five-bullet architecture map. Explain how terminal execution, agent coordination, routing, and memory connect. Do not open any other file and do not edit the repository.

Why these constraints matter

The first sentence creates a hard evidence boundary around README.md.
The five-bullet format makes the response quick to compare.
The final sentence protects the repository from changes during research.

Press Enter to send the assignment.
Approve repository access only if the request names your local munder-difflin folder.
Give README Scout time to finish its five-bullet response.

You should receive a short architecture summary containing five bullets based only on README.md.

Switch back to the repository in Visual Studio Code.
Confirm that no repository file is marked as changed.

That's your first live research result: README Scout has produced a visible baseline without changing the repository.

Did the agent leave the assignment boundary?

Stop the research run if README Scout requests access outside the local munder-difflin folder.
Send the same assignment again if the response cites files other than README.md.
Repeat the assignment if README Scout reports that it changed a repository file.

Need help checking the result? Help me verify that my agent used only README.md and did not edit the repository.

Score the map for completeness

A polished summary can still lack the evidence needed for a repository map. This checklist tests whether the report explains both structure and collaboration.

Architecture Completeness Test

The summary separates the two data planes.
The summary explains the renderer bridge.
The summary traces the exact mailbox message path.
The summary identifies persistent memory artifacts.
The summary names the responsible source files.

Before you compare the result, do you expect the README-only map to satisfy every criterion?

Read each bullet in README Scout's response.
Label each completeness criterion as strong, weak, or absent.

You should find useful product-level coverage. You should also find weak or absent evidence for the two data planes, the renderer bridge, the exact message lifecycle, the persistent-memory layout, or the responsible source files.

The on-disk mailbox flow is the clearest limitation. README.md alone cannot fully trace that lifecycle.

You now have a useful baseline with clearly recorded evidence gaps. Next, Michael can turn those gaps into focused assignments for complementary specialists.

Delegate to Specialist Agents

The earlier README.md pass gave you a useful baseline. Its missing source evidence makes the architecture map too broad to verify.

Inside Munder Difflin, Michael now uses agent orchestration to split the repository at an architecture boundary. This keeps each report focused on one authoritative source.

A Claude Code specialist investigates the hive. A Codex specialist maps the runtime path.

In This Step, Get Ready To:

Retain the existing researcher as Hive Mapper.
Add Runtime Mapper as a Codex specialist.
Have Michael collect two source-grounded reports.

Build the Specialist Team

The existing Claude Code agent already has permission to read the cloned repository. Retaining that agent preserves your baseline while giving it a narrower research boundary.

Why Split the Repository Research?

The hive design explains coordination through messages plus persistent files. The runtime architecture explains how the desktop application connects terminals to the renderer.

Giving each specialist one source reduces overlap. It also makes every finding easier to check.

Switch back to the Free Classic office in Munder Difflin.
Select the existing README Scout agent.

You should see the controls for the original Claude Code researcher. Its approved working folder remains the local repository.

Use the agent's name control to replace README Scout with Hive Mapper.

The Claude Code researcher now appears as Hive Mapper. Its repository access remains unchanged.

Click add agent on the Classic office floor.
Select Codex as the agent engine.

The new agent setup should now show Codex as the selected engine.

Enter Runtime Mapper as the agent name.
Select the same local munder-difflin repository as its approved working folder.

The setup should now pair Runtime Mapper with the same repository used by Hive Mapper.

Complete the agent setup.

Your specialist team is ready. The office now shows Hive Mapper on Claude Code plus Runtime Mapper on Codex.

Cannot See Both Specialists?

Return to the original agent's controls to confirm its name is Hive Mapper.
Check Runtime Mapper's controls to confirm its engine is Codex.
Check Runtime Mapper's working folder to confirm it uses the local munder-difflin repository.

Still stuck? Help me check why both specialists are not visible.

Brief Michael With Source Boundaries

A delegation brief gives each specialist a research contract. It defines the allowed source plus the evidence that must come back to Michael.

Select Michael on the Classic office floor.
Send the delegation brief by pasting this exact assignment:

Correct the incomplete architecture map by delegating two source-grounded assignments. Hive Mapper must read HIVE.md and trace message routing, the blackboard, the task ledger, and persistent memory. Runtime Mapper must read docs/ARCHITECTURE.md and trace the terminal plane, renderer, typed preload bridge, filesystem, and git responsibilities. Require exact file-path evidence, do not modify source code, and return both reports to you.

What Does This Brief Control?

The HIVE.md boundary keeps Hive Mapper focused on coordination plus persistent state.
The docs/ARCHITECTURE.md boundary keeps Runtime Mapper focused on application responsibilities.
The file-path requirement makes every technical claim auditable.
The no-edit constraint protects the repository during research.

Watch Hive Mapper's terminal until its assignment names HIVE.md.
Watch Runtime Mapper's terminal until its assignment names docs/ARCHITECTURE.md.

You should see Michael route one focused assignment to each specialist. This visible split confirms that both agents received the brief.

Did Michael Route Only One Assignment?

Check whether both specialists are active on the office floor.
Confirm each displayed agent name matches the delegation brief.
Send the same delegation brief to Michael again if one assignment is absent.

Need help? Help me diagnose the missing assignment.

Observe the Reports Return

Each specialist may spend several minutes reading its assigned document. The terminal streams let you distinguish active research from a pending permission request.

Repository permission prompts deserve a careful pause. Approving only the cloned repository keeps this research inside the workspace you already chose.

Monitor Hive Mapper's terminal for source-reading activity.
Approve access if Hive Mapper requests permission for the cloned munder-difflin repository.
Monitor Runtime Mapper's terminal for source-reading activity.
Approve access if Runtime Mapper requests permission for the cloned munder-difflin repository.
Decline any request that expands access beyond the cloned repository.

Both terminals should show research activity against their assigned files. Neither specialist should edit the repository.

Continue watching Hive Mapper until it reports completion.
Continue watching Runtime Mapper until it reports completion.

Before you return to Michael, do you expect one merged answer or two separate source-grounded reports?

Return to Michael in the Classic office.
Confirm Michael received two completed reports.

You should see one completed report from each specialist. The separate reports preserve the architecture boundary you assigned.

Check Hive Mapper's report for message-routing evidence.
Check Hive Mapper's report for blackboard evidence.
Check Hive Mapper's report for task-ledger evidence.
Check Hive Mapper's report for persistent-memory evidence.

Hive Mapper's findings should cite exact repository paths from HIVE.md. The report should make the coordination mechanisms traceable to files.

Check Runtime Mapper's report for terminal-plane evidence.
Check Runtime Mapper's report for renderer evidence.
Check Runtime Mapper's report for typed preload bridge evidence.
Check Runtime Mapper's report for filesystem responsibilities.
Check Runtime Mapper's report for Git responsibilities.
Confirm Runtime Mapper cites exact repository file paths.
Confirm neither specialist modified a source file.

That specialist split has closed the evidence gap. Michael now holds two reports whose claims can be checked directly against the repository.

Missing a Completed Report?

Check the unfinished specialist's terminal for a pending repository permission request.
Approve the request only when it targets the local munder-difflin repository.
Send Michael the original delegation brief again if the assignment was never routed.

Need another pair of eyes? Help me find why the specialist has not returned its report.

Michael now has complementary evidence from both sides of the architecture. Next, those reports become one repository map with a traceable source trail.

Synthesize the Architecture Map

Your Munder Difflin specialists have returned source-grounded reports from opposite sides of the repository. Michael now has the evidence needed to connect those findings.

Two accurate reports are still fragmented. This step turns them into one architecture map whose claims you can check against the repository.

In this step, get ready to:

Synthesize both specialist reports into REPO-MAP.md.
Verify the map against HIVE.md plus docs/ARCHITECTURE.md.
Finish the map with all seven sections plus the five required source paths.

Create the architecture map

Michael can now act as an editor across both specialist reports. A precise assignment gives the final document a predictable structure plus an evidence rule.

Switch back to the Munder Difflin office from earlier.
Select Michael on the Classic office floor.
Ask Michael to synthesize the reports by sending this prompt:

Synthesize the two reports into REPO-MAP.md at the repository root. Use the sections Product Model, Terminal Plane, Hive and Event Plane, Renderer Bridge, Collaboration Lifecycle, Source Trail, and Open Questions. Every technical claim must cite a repository file path. Do not alter any other file.

What does this request enforce?

The seven sections separate the product model from its runtime responsibilities.
The evidence rule ties every technical claim to a file that you can inspect.
The final instruction protects the rest of the repository from unrelated edits.

Wait for Michael to report that REPO-MAP.md has been created.
Return to the munder-difflin repository in Visual Studio Code.
Select REPO-MAP.md from the repository file sidebar.

You should see the seven headings requested in Michael's assignment. Each technical section should contain repository-path evidence.

Select the branch-shaped changes icon in the left sidebar.

The changed-files view should list REPO-MAP.md as the only repository change.

Map missing or incomplete?

Confirm that Michael received both completed specialist reports before you resend the synthesis request.

If the document appears outside the repository, remind Michael that it belongs beside README.md at the repository root.

Still stuck? Help me diagnose why Michael did not create REPO-MAP.md from the two specialist reports.

Check the map against its sources

A source-grounded map earns trust when its claims match the cited files. You will test the runtime claims against docs/ARCHITECTURE.md before testing the collaboration claims against HIVE.md.

In REPO-MAP.md, find the Terminal Plane heading.
Select docs/ARCHITECTURE.md from the repository file sidebar.
Compare every terminal-plane claim with the architecture document.
Compare every renderer-bridge claim with the architecture document.

Each supported claim should point to a real repository path. The cited file should carry the responsibility described in the map.

Return to REPO-MAP.md.
Find the Collaboration Lifecycle heading.
Select HIVE.md from the repository file sidebar.
Compare every collaboration-lifecycle claim with the hive design.
Return to REPO-MAP.md.
Choose one claim whose evidence is unsupported or unclear.
Record the claim you want Michael to correct here: CORRECTION_TARGET.

Correct and verify the source trail

A targeted correction closes the gap you found without replacing the whole document. The final audit then proves that each required implementation path appears in the right architectural context.

Switch back to the Munder Difflin office.
Select Michael on the Classic office floor.
Send this correction request:

Correct this issue in REPO-MAP.md: [[CORRECTION_TARGET="the claim that needs correction"]]

Check the revision against HIVE.md and docs/ARCHITECTURE.md. Keep every technical claim tied to a repository file path. Make sure the appropriate sections clearly name src/main/pty.ts, src/main/hive.ts, src/main/hooks.ts, src/main/memory.ts, and src/preload/index.ts. Do not alter any other file.

How does this correction work?

The first line directs Michael to the exact weakness you found.
The source check keeps the revision anchored to the two approved architecture documents.
The five required paths cover the terminal plane plus the hive and event plane.
The final instruction keeps the correction limited to REPO-MAP.md.

Wait for Michael to confirm that the correction is complete.

Before you inspect the revision, do you expect the evidence trail to be complete without any extra changed files?

Return to the munder-difflin repository in Visual Studio Code.
Select the revised REPO-MAP.md.
Confirm that all seven headings from the original assignment remain.

Now audit the implementation paths that connect the map to the repository.

Use the editor's find control to search for src/main/pty.ts.
Use the editor's find control to search for src/main/hive.ts.
Use the editor's find control to search for src/main/hooks.ts.
Use the editor's find control to search for src/main/memory.ts.
Use the editor's find control to search for src/preload/index.ts.
Select the branch-shaped changes icon in the left sidebar.

The map should use src/main/pty.ts to support the Terminal Plane. It should use src/preload/index.ts to support the Renderer Bridge.

The three required src/main/ paths should support the hive or collaboration sections. The changed-files view should still list only REPO-MAP.md.

That is a major step complete. Your architecture map now connects the product's major boundaries to evidence in the repository.

Required path missing or misplaced?

Search the source document for the missing path before asking Michael to revise the claim again.

If another repository file appears in the changed-files view, ask Michael to revert that unrelated edit without changing REPO-MAP.md.

Need help? Help me verify whether each required source path appears in the correct REPO-MAP.md section.

Your evidence-backed architecture map is ready. Next, you will inspect the hive files that recorded how the specialists coordinated this result.

Audit the Hive Trail

Your source-grounded REPO-MAP.md now explains Munder Difflin's architecture with evidence from the repository.

A polished document can hide the agent orchestration that produced it. This audit follows one collaboration through the on-disk hive so you can prove how a specialist's work reached Michael.

In this step, get ready to:

Inspect the hive roster, task ledger, activity log, agent directories, mailboxes, and persistent memory.
Trace one specialist record through its routing metadata and related result.
Add a source-safe coordination section to REPO-MAP.md.

Inspect the hive's core records

The hive is the on-disk multi-agent layer behind the office floor. A second Visual Studio Code window keeps the repository open while you inspect the separate workspace.

Select File in the Visual Studio Code menu bar.
Select New Window.
Select File in the new window.
Select Open Folder....
Choose the same local Munder Difflin workspace you selected during onboarding.
Click Open.

You should see the selected workspace in the Explorer sidebar. Your munder-difflin repository remains available in its original window.

Expand hive/ in the Explorer sidebar.
Inspect hive/registry.json to identify entries for Michael and the specialist agents.
Inspect hive/tasks.json to find the delegated architecture work.
Inspect hive/log.jsonl to locate activity associated with an assignment or completion.
Expand hive/agents/ to reveal the per-agent directories.

You should now see the roster, task ledger, activity log, and agent directories in one workspace. These files prove that the visible office has a persistent coordination trail.

What does the hive preserve?

The registry.json file records the agent roster.
The tasks.json file holds the task ledger.
The log.jsonl file provides a chronological activity trail.
The agents/ directory holds each agent's identity, memory, and mailboxes.

🙋‍♀️ Can't find the hive folder?

Return to the Munder Difflin office from earlier to confirm which local workspace is selected.
Reopen that exact workspace folder in the second Visual Studio Code window.

Still missing the hive records? Help me locate the selected Munder Difflin workspace and its hive folder.

Trace one specialist's route

Mailbox routing leaves a chain from an agent's outbox to a recipient's inbox. The shared log preserves another view of that movement.

The selected record may sit beside private prompts or credentials. Your audit only needs its routing metadata and a short result summary.

Select one specialist directory under hive/agents/.
Inspect its identity.md to confirm that it belongs to Hive Mapper or Runtime Mapper.
Inspect its memory.md to find retained context from the architecture research.
Expand its inbox/ directory to find received records.
Expand its inbox/.done/ directory to find processed records.
Expand its outbox/ directory to find sent records.

You should see an identity file, a memory file, and the specialist's mailbox directories. Together they show who the agent was, what it retained, and how work moved through the hive.

Choose one request or completion record associated with the architecture map.
Capture its sender here: TRACE_SENDER.
Capture its recipient here: TRACE_RECIPIENT.
Capture its action here: TRACE_ACTION.
Capture its subject here: TRACE_SUBJECT.
Capture its related result here: TRACE_RESULT.

Your captured route

Sender: TRACE_SENDER. Recipient: TRACE_RECIPIENT.

Action: TRACE_ACTION. Subject: TRACE_SUBJECT.

Record difficult to follow?

Check inbox/.done/ when the original inbox no longer contains the processed request.
Use hive/log.jsonl to confirm the order of related activity.
Compare the record's subject with the specialist report that Michael used.

Need help connecting the records? Help me trace this hive request or completion without exposing private content.

Document the coordination trail

The architecture map now needs a compact account of how its evidence moved through the team. This closes the gap between the finished artifact and the collaboration that produced it.

Add the heading ## How This Map Was Coordinated after the Open Questions section in REPO-MAP.md.
Write a short paragraph using the five captured values to explain the observed route.

Keep the audit shareable

The route proves how work moved without exposing the conversation behind it. Keep private prompts, credentials, and unrelated transcript content out of the document.

Review the new paragraph for sensitive or unrelated material.
Save REPO-MAP.md.

Before you compare the document with the hive record, which routing details do you expect to match?

Switch back to the selected Munder Difflin workspace window.
Compare the new coordination section with the chosen request or completion record.
Return to the repository window from earlier.
Confirm that REPO-MAP.md contains the How This Map Was Coordinated section.
Confirm that the section's related result supports a claim in the architecture map.

You should see the same sender, recipient, action, subject, and related result reflected in the hive record and your new section. That is the hidden coordination layer made visible.

You have now proved how one specialist's work moved through the hive and into the final architecture map.

Does the section disagree with the record?

Recheck whether you selected a request record or its corresponding completion record.
Use hive/log.jsonl to confirm the sender and recipient.
Revise only the unsupported statement in the coordination section.

Still seeing a mismatch? Help me reconcile my coordination section with the hive evidence.

Secret mission

Prove the Memory Survives a Restart

Restart the same Free Classic office to test whether Michael can recover the earlier research split from persistent memory. Verify the recall against saved agent memory. Record the result in REPO-MAP.md.

Clean Up Your Resources

Munder Difflin's Free Classic mode adds no subscription charge. Choose whether to keep, pause, or delete the local setup based on whether you want more agent activity against your existing Claude Code or Codex plan.

Resources you used:

Munder Difflin version 0.5.2 in /Applications. Its Free Classic configuration restores Michael as the orchestrator.
The local munder-difflin clone open in Visual Studio Code. It contains the repository sources plus REPO-MAP.md.
The learner-selected Munder Difflin workspace. It contains hive/registry.json, hive/tasks.json, hive/log.jsonl, hive/agents/, agent messages, task records, identities, plus persistent memory.

Keep everything running

This option keeps the office ready for more repository research. Existing Claude Code or Codex limits still apply whenever agents work.

Keep Munder Difflin installed in /Applications.
Retain the local munder-difflin clone for future source research.
Retain the selected Munder Difflin workspace so its hive history remains available.
Start agent work when you want to use your existing Claude Code or Codex allowance.

Pause - I'll come back to this later

This option stops local agent activity without removing files. Your repository plus workspace remain ready for another session.

Quit Munder Difflin to stop the local agents.
Keep the local munder-difflin repository on your Mac.
Keep the selected Munder Difflin workspace on your Mac.

Delete - I don't want to use this again

This option removes Munder Difflin plus both local project folders. A copy outside those folders preserves REPO-MAP.md if you still want the finished map.

Quit Munder Difflin to stop the local agents.
Copy REPO-MAP.md to a folder outside the repository if you want to keep it.
Use Finder to locate the munder-difflin clone that remains open in Visual Studio Code.
Confirm that the clone contains README.md, HIVE.md, docs/ARCHITECTURE.md, plus REPO-MAP.md.
Move the confirmed munder-difflin clone to the Trash.
Locate the same Munder Difflin workspace folder you selected during onboarding in Finder.
Confirm that the workspace contains hive/registry.json, hive/tasks.json, hive/log.jsonl, plus hive/agents/.
Move the confirmed workspace folder to the Trash.
Open /Applications in Finder.
Move Munder Difflin to the Trash.
Empty the Trash to remove the app plus both local folders.

Nice Work!

That's a wrap! Your Munder Difflin office now turns one research brief into coordinated specialist work. The resulting REPO-MAP.md explains the repository with evidence you can trace back to its sources.

You've learned how to:

Run a visible agent orchestration workflow through Michael. You delegated focused research to Claude Code and Codex. The local hive returned both reports to Michael.
Turn the weak spots in a README-only pass into an evidence-backed architecture map. REPO-MAP.md now grounds its architecture claims in HIVE.md, docs/ARCHITECTURE.md, and named source files.
Trace a plain-file collaboration trail through mailbox records, hive/tasks.json, hive/log.jsonl, agent identity, and persistent memory. You matched one completed specialist result to a claim in REPO-MAP.md.
Secret Mission: Proved that persistent memory survives a clean restart. The Persistence Check records what Michael recovered. It also identifies the findings that needed a source recheck.

Ready to quiz yourself?