an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
<!doctype html>
<html lang="en">
<head>
<!-- Google tag (gtag.js), Google Ads AW-18388216863. Loaded only when Do Not Track is
off, so it follows the same rule as the PostHog block on this site. -->
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){ dataLayer.push(arguments); }
if (navigator.doNotTrack !== '1') {
var gtagScript = document.createElement('script');
gtagScript.async = true;
gtagScript.src = 'https://www.googletagmanager.com/gtag/js?id=AW-18388216863';
document.head.appendChild(gtagScript);
gtag('js', new Date());
gtag('config', 'AW-18388216863');
}
</script>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>The Single-Committer Pattern: Multi-Agent Git Without Corruption — Munder Difflin Blog</title>
<meta name="description" content="Parallel agents corrupt a repo with index.lock races. The single-committer pattern — agents write, one process commits — fixes concurrent git writes." />
<link rel="canonical" href="https://munderdiffl.in/blog/single-committer-git-pattern/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
<meta name="theme-color" content="#F5F2E8" />
<!-- Open Graph -->
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="The Single-Committer Pattern: Multi-Agent Git Without Corruption — Munder Difflin Blog" />
<meta property="og:description" content="Parallel agents corrupt a repo with index.lock races. The single-committer pattern — agents write, one process commits — fixes concurrent git writes." />
<meta property="og:url" content="https://munderdiffl.in/blog/single-committer-git-pattern/" />
<meta property="og:image" content="https://munderdiffl.in/blog/assets/media/single-committer-git-pattern/hero.png" />
<meta property="og:image:width" content="1600" />
<meta property="og:image:height" content="900" />
<meta property="og:image:alt" content="Illustration: The Single-Committer Pattern: Multi-Agent Git Without Corruption" />
<meta property="og:locale" content="en_US" />
<meta property="article:published_time" content="2026-06-02T00:00:00.000Z" />
<meta property="article:author" content="Chaitanya Giri" />
<meta property="article:tag" content="Internals" />
<meta property="article:tag" content="Git" />
<meta property="article:tag" content="Multi-Agent" />
<meta property="article:tag" content="Concurrency" />
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="The Single-Committer Pattern: Multi-Agent Git Without Corruption — Munder Difflin Blog" />
<meta name="twitter:description" content="Parallel agents corrupt a repo with index.lock races. The single-committer pattern — agents write, one process commits — fixes concurrent git writes." />
<meta name="twitter:image" content="https://munderdiffl.in/blog/assets/media/single-committer-git-pattern/hero.png" />
<meta name="twitter:image:alt" content="Illustration: The Single-Committer Pattern: Multi-Agent Git Without Corruption" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
<link href="https://fonts.googleapis.com/css2?family=Fraunces:opsz,[email protected],500;9..144,600;9..144,700;9..144,900&family=Source+Serif+4:opsz,[email protected],400;8..60,600;8..60,700&family=Space+Grotesk:wght@500;600;700&family=JetBrains+Mono:wght@400;600&display=swap" rel="stylesheet" />
<link rel="stylesheet" href="/blog/assets/blog-press.css" />
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "The Single-Committer Pattern: Multi-Agent Git Without Corruption",
"description": "Parallel agents corrupt a repo with index.lock races. The single-committer pattern — agents write, one process commits — fixes concurrent git writes.",
"image": ["https://munderdiffl.in/blog/assets/media/single-committer-git-pattern/hero.png"],
"datePublished": "2026-06-02T00:00:00.000Z",
"dateModified": "2026-06-02T00:00:00.000Z",
"author": { "@type": "Person", "name": "Chaitanya Giri" },
"publisher": {
"@type": "Organization",
"name": "Munder Difflin",
"logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
},
"mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/single-committer-git-pattern/" },
"keywords": "single committer git multi agent, git index.lock, multi-agent git, concurrent git writes",
"articleSection": "Internals",
"inLanguage": "en-US",
"url": "https://munderdiffl.in/blog/single-committer-git-pattern/"
}
</script>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{ "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
{ "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
{ "@type": "ListItem", "position": 3, "name": "The Single-Committer Pattern: Multi-Agent Git Without Corruption", "item": "https://munderdiffl.in/blog/single-committer-git-pattern/" }
]
}
</script>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{ "@type": "Question", "name": "What causes git index.lock errors with multiple agents?", "acceptedAnswer": { "@type": "Answer", "text": "Git takes an exclusive lock on .git/index while staging or committing. If two processes run git at the same time, the second finds the lock held and fails — or worse, a crashed process leaves a stale lock behind that blocks every future commit." } },
{ "@type": "Question", "name": "How do you let many agents share one git repo safely?", "acceptedAnswer": { "@type": "Answer", "text": "Don't let the agents call git at all. Agents write plain files; a single coordinating process owns every commit, serializing them. Concurrency on the repo drops to one writer, so the lock is never contended." } },
{ "@type": "Question", "name": "Do agents lose anything by not running git themselves?", "acceptedAnswer": { "@type": "Answer", "text": "No. They still create, edit, and delete files freely. They just don't stage or commit — that's delegated to one committer, which turns git into a clean, serialized audit log of the team's work." } }
]
}
</script>
<script>
// Anonymous blog analytics (PostHog) — same posture as the main site and the
// app's TELEMETRY.md: public write-only token ('' = inert), anonymous-only
// (person_profiles 'never'), no autocapture/recording, DNT respected.
(function () {
var PH_KEY = 'phc_qJzsokwcbtTGHemnvywR3nSqivNNgMjHeNVEWkZNydFB';
if (!PH_KEY || navigator.doNotTrack === '1') return;
var s = document.createElement('script');
s.async = true;
s.src = 'https://us-assets.i.posthog.com/static/array.js';
s.onload = function () {
if (!window.posthog) return;
window.posthog.init(PH_KEY, {
api_host: 'https://us.i.posthog.com',
person_profiles: 'never',
autocapture: false,
before_send: function (event) {
// PostHog fills $ip from the connection unless the event carries one.
// Null it here and disable the GeoIP lookup so no IP, city, postal
// code or lat/long is ever derived or stored for this page view.
if (event && event.properties) {
event.properties.$ip = null;
event.properties.$geoip_disable = true;
}
return event;
},
disable_session_recording: true,
respect_dnt: true
});
};
document.head.appendChild(s);
})();
</script>
</head>
<body class="theme-press">
<a class="skip-link" href="#main">Skip to content</a>
<nav id="nav">
<a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">
<img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />
</a>
<span class="spacer"></span>
<div class="links">
<a href="/blog/">Latest</a>
<a href="/blog/topics/">Topics</a>
<a href="/blog/about/">About</a>
<a href="https://munderdiffl.in">↗ Product</a>
</div>
<div class="nav-actions">
<a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
<a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
</div>
</nav>
<main id="main">
<article class="t-internals">
<header class="post-head wrap">
<nav class="crumbs" aria-label="Breadcrumb">
<a href="/blog/">Blog</a>
<span>/</span>
<a href="/blog/topics/internals/">Internals</a>
</nav>
<h1>The Single-Committer Pattern: Multi-Agent Git Without Corruption</h1>
<p class="dek">Parallel agents corrupt a repo with index.lock races. The single-committer pattern — agents write, one process commits — fixes concurrent git writes.</p>
<div class="byline">
<span class="av" aria-hidden="true">CG</span>
<strong>Chaitanya Giri</strong>
<span class="dot" aria-hidden="true">·</span>
<time datetime="2026-06-02">Jun 2, 2026</time>
<span class="dot" aria-hidden="true">·</span>
<span>5 min read</span>
<span class="tag kind">Internals</span>
</div>
</header>
<div class="hero-wrap wrap"><figure class="fig fig-hero"><img src="/blog/assets/media/single-committer-git-pattern/hero.png" alt="Illustration: The Single-Committer Pattern: Multi-Agent Git Without Corruption" loading="lazy" decoding="async" /></figure></div>
<div class="post-wrap wrap">
<div class="prose">
<div class="callout tldr"><span class="ic">TL;DR</span><p>Run several agents against one git repo and
they'll race on <code>.git/index.lock</code>, producing failed and half-staged commits. The
<strong>single-committer pattern</strong> fixes it: <strong>agents only write plain files; one process
owns every commit</strong>, serialized, with retry-and-backoff and stale-lock recovery. Concurrency on
the repo drops to exactly one writer, so corruption becomes impossible — and git turns into a tidy
audit log of everything the team did.</p></div>
<p>If you’ve ever pointed two automated agents at the same repository, you’ve probably met this error:</p>
<pre><code>fatal: Unable to create '/path/.git/index.lock': File exists.
</code></pre>
<p>It looks transient. It isn’t a fluke — it’s git telling you that two processes tried to write its index
at once. As you add agents, it goes from occasional to constant, and a crashed agent can leave a stale
lock that blocks <em>every</em> future commit. This post explains why it happens and the pattern that ends it.</p>
<h2 id="why-concurrent-git-writes-corrupt" tabindex="-1">Why concurrent git writes corrupt <a class="anchor" href="#why-concurrent-git-writes-corrupt" aria-hidden="true">#</a></h2>
<p>Git is not designed for concurrent writers. When you stage or commit, git takes an <strong>exclusive lock</strong>
by creating <code>.git/index.lock</code>; it does its work against that file, then atomically renames it over
<code>.git/index</code> and releases the lock. The lock guarantees that only one operation mutates the index at a
time.</p>
<p>That’s fine for a human typing one command. It falls apart with parallel agents:</p>
<ul>
<li><strong>Contention.</strong> Two agents commit at the same instant. One gets the lock; the other finds
<code>index.lock</code> already present and fails outright.</li>
<li><strong>Half-applied state.</strong> Interleaved <code>git add</code>/<code>git commit</code> from different processes can stage a
partial set of changes — a commit that doesn’t reflect any single agent’s intent.</li>
<li><strong>Stale locks.</strong> An agent crashes (or is killed) mid-commit and never removes its <code>index.lock</code>. Now
the lock file is orphaned, and every subsequent commit — by anyone — fails until someone deletes it
by hand.</li>
</ul>
<p>You can’t “be careful” your way out of this. Two well-behaved agents that simply finish at the same
second will collide. The guarantee has to come from the design, not the agents’ manners.</p>
<h2 id="the-pattern-one-writer-for-git" tabindex="-1">The pattern: one writer for git <a class="anchor" href="#the-pattern-one-writer-for-git" aria-hidden="true">#</a></h2>
<p>The single-committer pattern is exactly what it sounds like: <strong>only one process is ever allowed to run
git.</strong> Everything else is downstream of that rule.</p>
<ul>
<li><strong>Agents write plain files.</strong> They create, edit, and delete files in their workspaces freely. They
do <em>not</em> run <code>git add</code>, <code>git commit</code>, or anything else that touches the index. As far as the agents
are concerned, git doesn’t exist.</li>
<li><strong>One coordinating process commits.</strong> A single committer watches the shared state, stages changes,
and commits them — one at a time, in order. Because it’s the only thing calling git, <code>index.lock</code> is
never contended. There is no second writer to race with.</li>
</ul>
<p>This collapses a hard concurrency problem into a trivial one. The repo has many <em>readers</em> and exactly
one <em>writer</em>, which is the configuration git is perfectly happy with.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/single-committer-git-pattern/note-1.png" alt="Hand-drawn sketch from “The Single-Committer Pattern: Multi-Agent Git Without Corruption”" loading="lazy" decoding="async" /></figure>
<h2 id="making-the-single-committer-bulletproof" tabindex="-1">Making the single committer bulletproof <a class="anchor" href="#making-the-single-committer-bulletproof" aria-hidden="true">#</a></h2>
<p>“One committer” removes contention between agents, but the committer still has to handle the messy
real world: a previous run that died, an occasional transient failure. A production-grade committer
does three things.</p>
<h3 id="1-retry-with-backoff" tabindex="-1">1. Retry with backoff <a class="anchor" href="#1-retry-with-backoff" aria-hidden="true">#</a></h3>
<p>Even a lone committer can hit a lock left by something else (a stray <code>git</code> you ran in another terminal,
a hook). So each commit attempt is wrapped in a small retry loop: try to commit; if it fails on a lock,
wait a short, growing interval and try again. A handful of attempts with increasing backoff absorbs any
brief contention without surfacing an error to the user.</p>
<pre class="language-text"><code class="language-text">for attempt in 0..5:
clear stale lock if present
git add -A
git commit -m <message>
→ success? return
→ "nothing to commit"? return # not an error
→ lock error? sleep 50ms * (attempt + 1); retry
→ other failure? give up quietly; the next change retries</code></pre>
<h3 id="2-stale-lock-recovery" tabindex="-1">2. Stale-lock recovery <a class="anchor" href="#2-stale-lock-recovery" aria-hidden="true">#</a></h3>
<p>A lock file that’s been sitting untouched for a while almost certainly belongs to a dead process. The
committer checks the lock’s age before each attempt and, if it’s older than a threshold (say, ten
seconds with no modification), removes it. That single check is what turns “a crashed agent bricked our
commits” into a non-event — the next commit cleans up and proceeds.</p>
<h3 id="3-a-deterministic-git-identity" tabindex="-1">3. A deterministic git identity <a class="anchor" href="#3-a-deterministic-git-identity" aria-hidden="true">#</a></h3>
<p>Because the committer commits on behalf of the whole team, it uses a fixed identity and disables
signing, so commits never block on a GPG prompt or a missing <code>user.name</code>:</p>
<pre class="language-bash"><code class="language-bash"><span class="token function">git</span> <span class="token parameter variable">-c</span> <span class="token assign-left variable">commit.gpgsign</span><span class="token operator">=</span>false <span class="token parameter variable">-c</span> <span class="token assign-left variable">user.name</span><span class="token operator">=</span>Hive <span class="token parameter variable">-c</span> <span class="token assign-left variable">user.email</span><span class="token operator">=</span>hive@local commit <span class="token parameter variable">-m</span> <span class="token string">"…"</span></code></pre>
<p>Now every coordination step is a clean, attributable commit, and nothing can hang waiting for
interactive input.</p>
<h2 id="the-bonus-git-becomes-an-audit-log" tabindex="-1">The bonus: git becomes an audit log <a class="anchor" href="#the-bonus-git-becomes-an-audit-log" aria-hidden="true">#</a></h2>
<p>Here’s the part that turns a workaround into an asset. Once one process owns every commit, the repo
stops being a liability and becomes a <strong>serialized history of everything the team did</strong>. Each routed
message, each task assignment, each memory update lands as its own commit, in order — a natural
companion to the <a href="/blog/append-only-event-log-agents/">append-only event log</a> the hive also keeps. When
a multi-agent run goes sideways, you don’t guess — you read the history.</p>
<p>That pairs naturally with the messaging layer: agents coordinate through files (see
<a href="/blog/atomic-file-mailboxes-for-agents/">atomic file mailboxes</a>), and the single committer commits
those file changes as they happen. The same single-writer discipline runs through both — it’s the
backbone of <a href="/blog/coordinating-ai-coding-agents/">coordinating AI coding agents</a> without collisions.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/single-committer-git-pattern/note-2.png" alt="Hand-drawn sketch from “The Single-Committer Pattern: Multi-Agent Git Without Corruption”" loading="lazy" decoding="async" /></figure>
<h2 id="what-about-the-users-own-repo" tabindex="-1">What about the user’s own repo? <a class="anchor" href="#what-about-the-users-own-repo" aria-hidden="true">#</a></h2>
<p>A fair question: if agents are editing your <em>actual</em> code repository, who commits <em>that</em>? The
single-committer pattern is about the <strong>coordination</strong> repo — the shared state the agents use to talk,
remember, and track tasks. Your source repo is separate, and you stay in control of its commits the way
you always have (or you delegate them deliberately to one agent with that role). The point is that the
machinery the agents rely on to cooperate never corrupts itself, no matter how many of them are running.</p>
<h2 id="when-you-need-this" tabindex="-1">When you need this <a class="anchor" href="#when-you-need-this" aria-hidden="true">#</a></h2>
<p>You need the single-committer pattern the moment <strong>more than one automated process</strong> shares a git repo:</p>
<ul>
<li>multiple coding agents in the same project,</li>
<li>an agent plus a background job that both commit,</li>
<li>any “swarm” or “hive” where coordination state lives in git.</li>
</ul>
<p>If it’s just you and one agent taking turns, you’ll rarely see a lock. Add a second concurrent writer
and the races begin — which is precisely when this pattern stops being optional.</p>
<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
<p><strong>Why not use git worktrees to isolate each agent?</strong> Worktrees give each agent its own working
directory, which helps with <em>file</em> isolation — but each worktree still has its own index, and shared
refs can still contend. Worktrees and single-committer solve different halves of the problem; see
<a href="/blog/claude-code-git-worktrees-vs-hive/">git worktrees vs a hive</a> for when each applies.</p>
<p><strong>Isn’t a lock just a retry-until-it-works situation?</strong> Retrying helps with transient contention, but
it does nothing for a <em>stale</em> lock from a dead process — that one never clears on its own. You need the
age-based cleanup, not just retries.</p>
<hr>
<p>Munder Difflin uses the single-committer pattern across the <a href="https://munderdiffl.in/#what">multi-agent harness</a>: agents write
files, one process commits with retry and stale-lock recovery, and the repo stays a clean audit log.
<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run a hive of Claude Code agents that
never corrupt their own state; it’s free and open source.</p>
<section class="faq" aria-label="Frequently asked questions">
<h2 id="faq">FAQ</h2>
<div class="qa">
<p class="q">What causes git index.lock errors with multiple agents?</p>
<p class="a">Git takes an exclusive lock on .git/index while staging or committing. If two processes run git at the same time, the second finds the lock held and fails — or worse, a crashed process leaves a stale lock behind that blocks every future commit.</p>
</div>
<div class="qa">
<p class="q">How do you let many agents share one git repo safely?</p>
<p class="a">Don't let the agents call git at all. Agents write plain files; a single coordinating process owns every commit, serializing them. Concurrency on the repo drops to one writer, so the lock is never contended.</p>
</div>
<div class="qa">
<p class="q">Do agents lose anything by not running git themselves?</p>
<p class="a">No. They still create, edit, and delete files freely. They just don't stage or commit — that's delegated to one committer, which turns git into a clean, serialized audit log of the team's work.</p>
</div>
</section>
<hr />
<div class="share">
<span class="lbl">Tags</span>
<a class="tag" href="/blog/tags/internals/">Internals</a><a class="tag" href="/blog/tags/git/">Git</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/concurrency/">Concurrency</a>
</div>
</div>
<aside class="toc-rail" aria-label="Table of contents">
<div class="tt">On this page</div>
<ol>
<li class="lvl-2"><a href="#why-concurrent-git-writes-corrupt">Why concurrent git writes corrupt</a></li><li class="lvl-2"><a href="#the-pattern-one-writer-for-git">The pattern: one writer for git</a></li><li class="lvl-2"><a href="#making-the-single-committer-bulletproof">Making the single committer bulletproof</a></li><li class="lvl-3"><a href="#1-retry-with-backoff">1. Retry with backoff</a></li><li class="lvl-3"><a href="#2-stale-lock-recovery">2. Stale-lock recovery</a></li><li class="lvl-3"><a href="#3-a-deterministic-git-identity">3. A deterministic git identity</a></li><li class="lvl-2"><a href="#the-bonus-git-becomes-an-audit-log">The bonus: git becomes an audit log</a></li><li class="lvl-2"><a href="#what-about-the-users-own-repo">What about the user’s own repo?</a></li><li class="lvl-2"><a href="#when-you-need-this">When you need this</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
</ol>
</aside>
</div>
<footer class="post-foot wrap"><div class="prevnext">
<a class="pn prev" href="/blog/visualizing-ai-agents-pixijs/"><span class="k">← Older</span><span class="t">Visualizing AI Agents with Pixi.js: An Office You Can Watch</span></a>
<a class="pn next" href="/blog/run-an-office-of-ai-agents/"><span class="k">Newer →</span><span class="t">Run an Office of AI Agents While You Sleep</span></a>
</div>
<section class="related">
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card t-internals">
<a class="thumb t-internals" href="/blog/the-spend-counter-that-went-back-to-zero/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/the-spend-counter-that-went-back-to-zero/hero.png" alt="" loading="lazy" decoding="async" /></a>
<div class="body">
<div class="meta">
<time datetime="2026-08-22">Aug 22, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>10 min</span>
</div>
<h3><a href="/blog/the-spend-counter-that-went-back-to-zero/">The Spend Counter That Went Back to Zero</a></h3>
<p class="dek">Our own floor was under reporting what it cost by 59 percent. The counter was cumulative since process start, the app restarts, and the session id stayed the same. Here is how a monotonic invariant let us recover the real number from an append-only log.</p>
<div class="foot">
<span class="tag kind">Internals</span>
<a class="more" href="/blog/the-spend-counter-that-went-back-to-zero/" aria-label="Read: The Spend Counter That Went Back to Zero">Read →</a>
</div>
</div>
</article>
<article class="card t-internals">
<a class="thumb t-internals" href="/blog/the-newline-that-silenced-windows-agents/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/the-newline-that-silenced-windows-agents/hero.png" alt="" loading="lazy" decoding="async" /></a>
<div class="body">
<div class="meta">
<time datetime="2026-08-19">Aug 19, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>4 min</span>
</div>
<h3><a href="/blog/the-newline-that-silenced-windows-agents/">The Newline That Silenced Every Windows Agent</a></h3>
<p class="dek">A cmd.exe parsing rule from the 1980s meant Windows agents received exactly one line of their multi-line startup protocol — and nothing errored. The anatomy of our worst silent failure, and the fix.</p>
<div class="foot">
<span class="tag kind">Internals</span>
<a class="more" href="/blog/the-newline-that-silenced-windows-agents/" aria-label="Read: The Newline That Silenced Every Windows Agent">Read →</a>
</div>
</div>
</article>
<article class="card t-internals">
<a class="thumb t-internals" href="/blog/why-our-auto-update-never-ran/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/why-our-auto-update-never-ran/hero.png" alt="" loading="lazy" decoding="async" /></a>
<div class="body">
<div class="meta">
<time datetime="2026-08-08">Aug 8, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
<h3><a href="/blog/why-our-auto-update-never-ran/">Our Auto-Update Never Ran Once: A CommonJS Export That Vanished Into an ESM Namespace</a></h3>
<p class="dek">Munder Difflin shipped auto-update in v0.3.4 and it silently never worked in a single packaged build. The cause was one destructuring assignment across the CommonJS/ESM boundary — and a catch block that threw the evidence away. Here's how we found it, and what v0.3.7 changes.</p>
<div class="foot">
<span class="tag kind">Internals</span>
<a class="more" href="/blog/why-our-auto-update-never-ran/" aria-label="Read: Our Auto-Update Never Ran Once: A CommonJS Export That Vanished Into an ESM Namespace">Read →</a>
</div>
</div>
</article>
</div>
</section>
</footer>
</article>
</main>
<footer class="site-foot">
<div class="wrap">
<div class="foot-top">
<a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">
<img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />
</a>
<div class="foot-links">
<a href="/blog/">Latest</a>
<a href="/blog/topics/">Topics</a>
<a href="/blog/about/">About</a>
<a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
<a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
<a href="https://munderdiffl.in">munderdiffl.in ↗</a>
</div>
</div>
<div class="foot-meta">
© 2026 Munder Difflin · Local-first · MIT-licensed ·
Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & node-pty</a>.
Run an office of agents while you sleep.
</div>
</div>
</footer>
<script>
// sticky-nav border on scroll
(function () {
var nav = document.getElementById('nav');
if (!nav) return;
var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
})();
// YouTube click-to-load: thumbnail button → youtube-nocookie iframe
(function () {
document.addEventListener('click', function (e) {
var btn = e.target.closest('.yt-load');
if (!btn) return;
var box = btn.closest('.yt');
var id = box && box.getAttribute('data-yt');
// Only an 11 character YouTube video id may reach the iframe URL.
if (!id || !/^[A-Za-z0-9_-]{11}$/.test(id)) return;
var frame = document.createElement('iframe');
frame.src = 'https://www.youtube-nocookie.com/embed/' + encodeURIComponent(id) + '?autoplay=1';
frame.title = box.getAttribute('data-title') || 'YouTube video';
frame.allow = 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share';
frame.setAttribute('allowfullscreen', '');
box.replaceChildren(frame);
});
})();
</script>
</body>
</html>