memhtml 0.5.0 → 0.6.0

package/dist/{dist-D5DlgqH2.mjs → dist-CHoz5uHd.mjs}

@@ -9021,17 +9021,42 @@ const keyMembers = (items, textOf, options) => {
 	};
 };
 /**
+* The offered key a model's answer denotes, or `undefined` when it denotes none.
+*
+* A model shown `<member_m3>` answers `member_m3` at least as readily as `m3`: the wrapper tag is
+* the only place most batch prompts DISPLAY a key, so the label-prefixed form is the one the prompt
+* itself teaches (measured live 2026-08-23: `gpt-5.6-sol` answers the prefixed form on every call,
+* Claude Sonnet 5 on most). So a key that does not match directly is retried once with everything
+* up to its last `_` stripped, and only a suffix the batch actually offered resolves — `member_m9`
+* in a batch of three still denotes nothing, and a path or an invented name still drops. The
+* canonical form is returned so two spellings of one member collapse to one key everywhere a phase
+* keeps per-key state.
+*/
+const offeredKeyFor = (batch, key) => {
+	if (batch.itemForKey.has(key)) return key;
+	const at = key.lastIndexOf("_");
+	if (at === -1) return void 0;
+	const suffix = key.slice(at + 1);
+	return batch.itemForKey.has(suffix) ? suffix : void 0;
+};
+/**
 * Resolve the keys a model named back to items: unknown keys are dropped, repeats collapse.
 *
 * A key the batch never offered is a member the model invented, and every phase on this kernel turns
 * a named member into a write, so an unresolvable key must not reach that write. Dropping it leaves
 * the corresponding file untouched, which is the safe outcome for every one of the five phases.
+* Resolution goes through {@link offeredKeyFor}, so the label-prefixed spelling of an offered key
+* (`member_m3` for `m3`) resolves rather than reading as an invention.
 *
 * The result keeps the order the model named the keys in, and a key named twice appears once.
-* De-duplication is on the KEY rather than on the resolved item, so the count a phase gates on
-* ("at least two members absorbed") counts distinct offered members.
-*/
-const resolveKeys = (batch, keys) => [...new Set(keys)].flatMap((key) => {
+* De-duplication is on the CANONICAL key rather than on the spelling or the resolved item, so `m1`
+* and `member_m1` in one answer count as one member, and the count a phase gates on ("at least two
+* members absorbed") counts distinct offered members.
+*/
+const resolveKeys = (batch, keys) => [...new Set(keys.flatMap((key) => {
+	const canonical = offeredKeyFor(batch, key);
+	return canonical === void 0 ? [] : [canonical];
+}))].flatMap((key) => {
 	const item = batch.itemForKey.get(key);
 	return item === void 0 ? [] : [item];
 });
@@ -9156,21 +9181,31 @@ const batchCall = (model, label, request) => isolate(label, model.generateObject
 * `sleep_phases` row, and in a `--phases` flag, and three copies of the string would drift.
 */
 /**
-* The sixteen phases, in execution order.
+* The seventeen phases, in execution order.
 *
 * The order encodes the predecessor memory system's dependencies (design §6): entity resolution precedes person
 * links so aliases have already merged, confidence decay precedes retention triage so triage
 * scores the decayed value, and dedup-merge precedes compress and retention because both operate
 * on the post-merge set.
 *
-* `task-detection` is sixteenth-in-list and thirteenth-in-order, sitting after `trace-consolidation`
-* and before `integrity`, and both edges are deliberate. It scans the ACTIVE corpus for unresolved
+* `task-detection` sits after `trace-consolidation` and before `integrity`, and both edges are
+* deliberate. It scans the ACTIVE corpus for unresolved
 * commitments, so it has to run after every phase that changes what is active — after dedup's folds,
 * after retention's evictions, after compress's canonicals, and after trace consolidation's newly
 * distilled memories, which are the freshest text of the night and the likeliest to carry one. And it
 * WRITES files, so it must precede `integrity`, which repairs dangling hrefs and regenerates the
 * directory artifacts: a task minted afterwards would be absent from its directory's `index.html`
 * until the next night.
+*
+* `placement-triage` is deep-only (issue #63): on a run without `--deep` it returns immediately,
+* writes nothing, and commits nothing, so the nightly cycle's behavior is unchanged by its presence
+* in this list. Its slot has the same two edges task-detection's does, plus one more on each side:
+* it must run after `compress` (it re-files only what even deep grouping could not fold, so folding
+* has to have had its chance first) and after `task-detection` (a move mid-scan would hand the
+* detector paths that no longer hold files), and it must precede `integrity` because it MOVES files —
+* integrity regenerates each directory's `index.html`, and it rewrites inbound hrefs itself because
+* integrity's dangling-href repair only knows how to chase a target into the ARCHIVE, not into a
+* topic directory.
 */
 const SLEEP_PHASES = [
 	"preflight",
@@ -9186,6 +9221,7 @@ const SLEEP_PHASES = [
 	"reprieve",
 	"trace-consolidation",
 	"task-detection",
+	"placement-triage",
 	"integrity",
 	"state-export",
 	"report"
@@ -9552,7 +9588,8 @@ const DEFAULT_MODELS = {
 	"arc-synthesis": "gpt-5.6-sol",
 	compress: "gpt-5.6-sol",
 	"trace-consolidation": "opus-5",
-	"task-detection": "gpt-5.6-sol"
+	"task-detection": "gpt-5.6-sol",
+	"placement-triage": "gpt-5.6-sol"
 };
 /** The model a phase calls: the caller's override, else {@link DEFAULT_MODELS}, else sonnet. */
 const modelFor = (deps, phase) => deps.models?.[phase] ?? DEFAULT_MODELS[phase] ?? "sonnet-5";
@@ -9562,6 +9599,25 @@ const emptyOutcome = (counts = {}) => ({
 	commitSha: null,
 	llmCalls: 0
 });
+/** A fresh budget. A non-positive or fractional cap clamps to a usable whole number. */
+const makeLlmBudget = (maxCalls) => ({
+	maxCalls: Math.max(0, Math.trunc(maxCalls)),
+	spent: 0
+});
+/**
+* Take one call from the budget, or report exhaustion.
+*
+* `true` means the caller may make the call and the budget has been charged. Charging BEFORE the
+* call rather than after means a crash mid-call cannot under-count, which errs on the side the
+* budget exists for. No budget bound means every call is allowed.
+*/
+const takeLlmCall = (deep) => {
+	const budget = deep?.budget;
+	if (budget === void 0) return true;
+	if (budget.spent >= budget.maxCalls) return false;
+	budget.spent += 1;
+	return true;
+};
 
 //#endregion
 //#region packages/sleep/dist/llm.js
@@ -10029,6 +10085,71 @@ const edgeTypingPrompt = (pairs) => batchPrompt(pairs, EDGE_TYPING_INSTRUCTION,
 const arcTriagePrompt = (arcsText, evidenceText) => `${dataBlock("current_arcs", arcsText)}\n\n${dataBlock("evidence", evidenceText)}\n\nProduce a triage plan. Assign update or skip to every existing arc, and add a create entry for any genuinely new behavioral pattern the existing arcs do not cover.`;
 /** The arc-execute user turn for one arc. `current` is absent on a create. */
 const arcExecutePrompt = (input) => (input.current === void 0 ? `${dataBlock("new_arc_title", input.title)}\n\n` : `${dataBlock("existing_arc", input.current)}\n\n`) + `${dataBlock("evidence", input.evidenceText)}\n\n${dataBlock("triage_rationale", input.rationale)}\n\n` + (input.current === void 0 ? "Synthesize a new behavioral principal from this evidence." : "Update the arc to incorporate the new evidence, preserving existing knowledge that holds.");
+/**
+* One inbox memory's proposed destination, under the opaque key it was offered as (issue #63).
+*
+* `destination` is a STRING the phase validates, never trusts: only `keep-inbox`, a directory the
+* corpus already has, or one of a capped handful of new topic directories survives the code gate.
+* A model-invented path outside those is a refused placement, counted and logged, because a
+* destination is a write target and the model does not choose write targets anywhere in this
+* pipeline.
+*/
+const Placement = Schema.Struct({
+	/** The offered key, e.g. `m3`. A key the batch never held resolves to nothing and is dropped. */
+	memberKey: Schema.String,
+	/**
+	* `keep-inbox`, or a bucket-rooted directory like `areas/deploys` or `resources/sqlite`.
+	* `keep-inbox` is the refusal and the ordinary answer for a memory whose topic is not clear.
+	*/
+	destination: Schema.String,
+	/** Unitless in `[0, 1]`. The move gate is deterministic and reads this, not the prose. */
+	confidence: Schema.Finite.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 1
+	}))
+});
+/** One batch's whole answer: a placement list. An omitted member keeps its inbox path. */
+const PlacementTriage = Schema.Struct({ placements: Schema.Array(Placement) });
+/**
+* The confidence a placement must clear before the phase moves a file. The same 0.7 the edge and
+* entity gates use, for the same reason one number serves them: a second knob would be a threshold
+* nobody could state the meaning of. A move is cheap to reverse (`git mv` back, reviewable on the
+* branch), so the floor matches the mild gates rather than the corroboration-backed ones.
+*/
+const PLACEMENT_CONFIDENCE_FLOOR = .7;
+/** The literal a placement answer uses to decline. */
+const PLACEMENT_KEEP = "keep-inbox";
+/**
+* The placement-triage system prompt (issue #63).
+*
+* The refusal is stated as the ordinary answer, because for a bulk-imported inbox it is: most
+* singletons are distinct facts whose topic directory does not exist yet, and a model that felt
+* obliged to place everything would scatter the inbox across invented directories nobody asked for.
+*/
+const PLACEMENT_SYSTEM = `You file inbox memories into topic directories for an AI agent's long-term memory system. You are
+given the list of directories the corpus already has, and a NUMBERED LIST of memories currently
+sitting in the inbox. For each memory, propose where it belongs.
+
+- destination is one of the existing directories, verbatim from the list, when the memory clearly
+  belongs to that topic.
+- destination may be a NEW directory (areas/<topic> for ongoing concerns, resources/<topic> for
+  reference material) when several of THESE memories share a topic no existing directory covers.
+  Use a short lowercase hyphenated topic name. New directories are rationed, so propose one only
+  when it would hold more than a stray file.
+- destination is keep-inbox when you are unsure, when the memory's topic is ambiguous, or when no
+  directory fits. This is the ordinary answer, not a failure.
+- Never propose archive/, areas/inbox itself, areas/arcs, or resources/people. Those are managed
+  surfaces.
+- Rate confidence honestly. A placement above the floor moves the file on a review branch.
+- Omitting a member means keep-inbox.`;
+/** The instruction that closes a placement batch's user turn, after the member list. */
+const PLACEMENT_INSTRUCTION = "Propose a destination for each memory above: an existing directory from the list, a new areas/<topic> or resources/<topic> directory, or keep-inbox. Name each memory by its offered key and rate your confidence.";
+/**
+* The placement user turn for one batch: the existing directories, then every member under its
+* offered key, then the instruction. The directory list is corpus-derived text, so it is wrapped as
+* data exactly as the member texts are.
+*/
+const placementPrompt = (directories, members) => `${dataBlock("existing_directories", directories.join("\n"))}\n\n` + batchPrompt(members, PLACEMENT_INSTRUCTION, { label: "memory" });
 /** The instruction that closes a compress batch's user turn, after the member list. */
 const COMPRESS_INSTRUCTION = "Fold these memories into one canonical memory. List in absorbedKeys exactly the members whose content the canonical carries forward.";
 /**
@@ -10081,7 +10202,7 @@ const dedupPrompt = (components) => {
 /**
 * The memory type no phase of a sleep cycle touches.
 *
-* A task is live working state, and every one of the sixteen phases is a judgment about REMEMBERED
+* A task is live working state, and every one of the seventeen phases is a judgment about REMEMBERED
 * FACTS: decay says a claim is fading, dedup says two claims are one, edge typing says one claim
 * caused or contradicts another, retention says a claim has stopped earning its place. None of those hold for
 * a thing an agent intends to do, and each would be wrong applied to one. A task the agent has
@@ -10403,6 +10524,16 @@ const peoplePaths = (db) => db.all("SELECT path FROM files WHERE path LIKE ? OR
 * `edge_class = 'memory'` is the firewall. A person or provenance edge cannot enter PageRank, label
 * propagation, or the retention bridge count, and this query is what makes that true. The CHECK
 * constraint alone does not.
+*
+* **The deep grouping band is excluded, and the exclusion is what keeps nightly scoring stable
+* across deep runs (issue #63).** Deep mining writes machine-mined `laterally_related` edges at a
+* floor (0.72) far below the nightly one, purely so label propagation can partition the inbox tail
+* for compress. Those edges persist in the index after the deep run, so without this predicate the
+* FIRST deep run would permanently change every subsequent nightly run's PageRank, communities, and
+* bridge counts — and therefore its eviction decisions — on a corpus whose files did not change.
+* The filter names `derived = 1` as well as the rel, so an AUTHORED `laterally_related` (an agent's
+* own assertion, addable through `memhtml link`) keeps exactly the graph standing it had.
+* {@link deepGroupingEdges} is the one reader of the band.
 */
 const memoryEdges = (db) => db.all(`SELECT e.src_path AS src_path, e.rel AS rel, e.dst_path AS dst_path,
             e.strength AS strength, e.derived AS derived
@@ -10410,6 +10541,24 @@ const memoryEdges = (db) => db.all(`SELECT e.src_path AS src_path, e.rel AS rel,
      JOIN files s ON s.path = e.src_path AND s.archived = 0
      JOIN files d ON d.path = e.dst_path AND d.archived = 0
      WHERE e.edge_class = 'memory'
+       AND NOT (e.derived = 1 AND e.rel = 'laterally_related')
+     ORDER BY e.src_path ASC, e.rel ASC, e.dst_path ASC`);
+/**
+* The deep grouping band: machine-mined `laterally_related` edges over active files (issue #63).
+*
+* The mirror of {@link memoryEdges}' exclusion, and deliberately a separate read instead of a flag on
+* it: the band has exactly one consumer intent — widening label propagation's partition for the deep
+* compress and placement phases — and a parameterized `memoryEdges` would let any caller widen the
+* retention graph by passing a boolean. `provenance = 'sleep'` is implied by `derived = 1` (the
+* table CHECK pins the pair) and stated anyway so the statement reads as what it is.
+*/
+const deepGroupingEdges = (db) => db.all(`SELECT e.src_path AS src_path, e.rel AS rel, e.dst_path AS dst_path,
+            e.strength AS strength, e.derived AS derived
+     FROM edges e
+     JOIN files s ON s.path = e.src_path AND s.archived = 0
+     JOIN files d ON d.path = e.dst_path AND d.archived = 0
+     WHERE e.edge_class = 'memory' AND e.derived = 1 AND e.rel = 'laterally_related'
+       AND e.provenance = 'sleep'
      ORDER BY e.src_path ASC, e.rel ASC, e.dst_path ASC`);
 const retentionEdgeCounts = (db) => db.all(`SELECT f.path AS path,
             sum(CASE WHEN e.rel = 'supports' THEN 1 ELSE 0 END) AS reinforcements,
@@ -10614,6 +10763,19 @@ const markSessionsConsolidated = (db, input) => db.writeAll(input.sessionIds.map
 const linkedSessionCount = (db) => db.get(`SELECT count(DISTINCT t.session_id) AS n FROM traces t
        JOIN memory_session_links l ON l.session_id = t.session_id`).pipe(Effect.map((row) => row?.n ?? 0));
 /**
+* Authored memory-class edges POINTING AT one path: which files hold a `<link>` a move must rewrite.
+*
+* Placement triage's read (issue #63). `derived = 0` because a mined edge lives only in the index
+* and the next re-mine follows the moved vectors on its own; only a file-borne link needs a splice.
+* Both memory and task classes are included — a task may `blocks`-link a memory it waits on, and a
+* move that left that href dangling would break the task surface — but provenance and person edges
+* cannot point at an inbox memory by construction.
+*/
+const inboundAuthoredEdges = (db, dstPath) => db.all(`SELECT e.src_path AS src_path, e.rel AS rel
+     FROM edges e
+     WHERE e.derived = 0 AND e.dst_path = ?
+     ORDER BY e.src_path ASC, e.rel ASC`, [dstPath]);
+/**
 * Authored edges pointing at a path the index does not hold.
 *
 * `derived = 0` only: a mined edge lives in the index and nowhere else, so a dangling one is
@@ -10960,6 +11122,129 @@ const arcSynthesis = (env) => Effect.gen(function* () {
 	};
 });
 
+//#endregion
+//#region packages/sleep/dist/phases/relationship-mining.js
+/**
+* Phase 5, relationship mining. Derived `relates_to` edges in the index only. NO COMMIT.
+*
+* A mined edge is a re-derivable function of the corpus and the embedder. `index rebuild` plus the
+* next night's mining regenerates the identical set, so committing thousands of them would bury every
+* real diff in machine noise for zero recoverable information. The `derived` column is the firewall
+* that makes losing them cheap. The retention penalty counts only `derived = 0`, so an
+* uncorroborated machine suspicion cannot evict a memory.
+*
+* The insert is scoped to `provenance = 'sleep'` and `derived = 1` and the whole replace is one
+* atomic batch, so an authored edge is unreachable from here and the corpus is never left with the
+* old mined set deleted and the new one not yet written. In that window the lateral arm would
+* silently return nothing.
+*
+* **Under `--deep` the phase additionally mines a GROUPING band (issue #63).** On a measured 3,079-file
+* inbox, 8% of files have a neighbor at the 0.85 floor and 84% touch no edge at all — no community, so
+* compress is structurally unable to reach them at any frequency. The deep band mines
+* [{@link DEEP_MINING_COSINE_FLOOR}, {@link MINING_COSINE_FLOOR}) as `laterally_related` edges whose
+* only consumer intent is giving label propagation a partition; the existing compress model then
+* judges the folds, and `absorbedKeys: []` is its refusal, so a looser grouping floor costs calls and
+* never correctness.
+*
+* **The two bands are separate rels, and that is the isolation mechanism.** {@link replaceMinedEdges}
+* scopes its atomic delete by rel, so the deep replace cannot clobber the nightly `relates_to` set and
+* the nightly replace cannot clobber the deep band. The issue sketched a distinct PROVENANCE instead;
+* the `edges` CHECKs pin `derived = 1` to `provenance = 'sleep'` (migration 0008), so that spelling
+* needs a table recreate while a distinct rel needs nothing: `laterally_related` is already in the
+* memory-rel vocabulary with no producer, and edge typing's candidate scan reads `rel = 'relates_to'`
+* alone, so the deep band never spends nightly edge-typing calls. A nightly run never touches the
+* deep rel, so a deep band persists until the next deep run re-mines it or `index rebuild` drops it —
+* both re-derivable, which is the property that makes an index-only edge safe to hold.
+*/
+/** The similarity floor a pair must clear to become a mined `relates_to`. */
+const MINING_COSINE_FLOOR = .85;
+/**
+* The GROUPING-band floor deep mining reaches down to (issue #63). At 0.72, between 43% and 61% of
+* the measured bulk-import inbox has a neighbor (43% at 0.75, 61% at 0.70, median best-neighbor
+* cosine 0.731) — reach enough to partition most of the tail while staying above the ~0.5-0.6
+* cross-topic baseline the fixture corpora measure, so a community is still a topic and not noise.
+* The compress model judging every proposed fold is what makes this floor a cost knob rather than a
+* correctness one.
+*/
+const DEEP_MINING_COSINE_FLOOR = .72;
+/** Nearest neighbors considered per source file. */
+const MINING_PER_SOURCE_K = 5;
+/**
+* Pairs mined per cycle: a cap on what {@link replaceMinedEdges} writes, not on the scan — the
+* kernel's arithmetic is O(n²·d) whatever this says, and it bounds the edge table so one dense
+* neighborhood cannot flood the graph the lateral arm and PageRank read.
+*/
+const MINING_SAMPLE_LIMIT = 2e3;
+/**
+* The deep band's own write cap. Separate from {@link MINING_SAMPLE_LIMIT} because the band is wider
+* by construction — it exists to reach the 84% the nightly band cannot — and sharing the nightly cap
+* would make the deep run's reach a function of how crowded the nightly band happens to be.
+*/
+const DEEP_MINING_SAMPLE_LIMIT = 1e4;
+/** The rel the deep grouping band is written under. The band separator; see the module header. */
+const DEEP_GROUPING_REL = "laterally_related";
+/**
+* Mine every band the run is entitled to and replace the index's mined sets: the whole phase minus
+* its counts. Exported because deep compress re-runs it BETWEEN passes (issue #63's
+* iterate-until-quiet): a fold's canonical is a new neighbor only after it is indexed and re-mined,
+* and a second implementation of the scan here would be free to disagree with the nightly one about
+* floors, caps, and exclusions.
+*/
+const mineAllBands = (env) => Effect.gen(function* () {
+	/**
+	* Tasks are excluded, and here the exclusion is the graph firewall, not a cost guard.
+	* Every mined edge is written with `edge_class = 'memory'`, so a pair with a task endpoint
+	* would put a task INTO the memory graph, reaching PageRank, MMR, and the retention bridge
+	* count. The `edges` CHECK cannot refuse it, because `relates_to` under `memory` is a
+	* well-formed edge whatever files sit at its ends.
+	*/
+	const pairs = yield* neighborPairs(env.deps.db, {
+		floor: MINING_COSINE_FLOOR,
+		perSourceK: 5,
+		limit: MINING_SAMPLE_LIMIT,
+		excludeTypes: SLEEP_EXCLUDED_TYPES
+	});
+	/**
+	* The deep grouping band: everything in [deep floor, nightly floor). Mined only under `--deep`,
+	* so a nightly run's writes — and therefore the graph every nightly consumer reads on a corpus
+	* that has never run deep — are byte-identical to what they were before this branch existed.
+	* The nightly floor is the band's EXCLUSIVE ceiling: a pair at or above it is the nightly
+	* band's, and holding it in both would double its label-propagation weight.
+	*/
+	const deepPairs = env.deep === void 0 ? [] : (yield* neighborPairs(env.deps.db, {
+		floor: DEEP_MINING_COSINE_FLOOR,
+		perSourceK: 5,
+		limit: DEEP_MINING_SAMPLE_LIMIT,
+		excludeTypes: SLEEP_EXCLUDED_TYPES
+	})).filter((pair) => pair.sim < MINING_COSINE_FLOOR);
+	if (!env.dryRun) {
+		yield* replaceMinedEdges(env.deps.db, {
+			runId: env.runId,
+			at: env.at,
+			rel: "relates_to",
+			pairs
+		});
+		if (env.deep !== void 0) yield* replaceMinedEdges(env.deps.db, {
+			runId: env.runId,
+			at: env.at,
+			rel: DEEP_GROUPING_REL,
+			pairs: deepPairs
+		});
+	}
+	return {
+		mined: pairs.length,
+		deepMined: deepPairs.length
+	};
+});
+const relationshipMining = (env) => Effect.gen(function* () {
+	const mined = yield* mineAllBands(env);
+	return emptyOutcome({
+		candidates: mined.mined,
+		mined: mined.mined,
+		...env.deep === void 0 ? {} : { deepMined: mined.deepMined }
+	});
+});
+
 //#endregion
 //#region packages/sleep/dist/phases/compress.js
 /**
@@ -10990,6 +11275,28 @@ const arcSynthesis = (env) => Effect.gen(function* () {
 *
 * `dedup-merge` is a HARD prerequisite. Compressing before duplicates are folded would synthesize a
 * canonical over a pair the merge phase then archives one half of.
+*
+* ## Deep mode (issue #63)
+*
+* Under `--deep` three things change about WHICH memories a fold can reach, and nothing about what
+* happens to a fold:
+*
+* 1. **Communities come from the widened graph.** Label propagation runs over the nightly memory
+*    edges PLUS the deep grouping band (`laterally_related`, mined at 0.72), so inbox files whose
+*    best neighbor sits under the nightly 0.85 floor get a partition. Retention SCORES stay the
+*    nightly function — the band decides grouping, never eviction.
+* 2. **Entity groups are a second community source.** Candidates the widened graph still leaves
+*    communityless are grouped by shared `file_entities` reference under a synthetic
+*    `entity:<type>:<name>` label, because two memories about one subject can share no vocabulary at
+*    all. Hub entities (more than {@link DEEP_ENTITY_HUB_LIMIT} active claimants) are stop-words and
+*    are skipped.
+* 3. **The phase iterates until quiet.** A pass that produced canonicals re-indexes the branch,
+*    re-mines both bands, recomputes retention, and folds again — a canonical is a new neighbor and
+*    a new community member — until a pass folds nothing or {@link DEEP_COMPRESS_MAX_PASSES} hits.
+*
+* Every model call in deep mode is charged against the run's shared `--max-llm-calls` budget first;
+* an exhausted budget skips the batch with reason `budget` and the run stays green, the same
+* degradation posture a model outage has.
 */
 /** Members per model call. Small enough that every member's facts fit the answer's attention. */
 const COMPRESS_BATCH_SIZE = 8;
@@ -11002,6 +11309,83 @@ const COMPRESS_MIN_BATCH = 2;
 const COMPRESS_CANDIDATE_LIMIT = 2e3;
 /** Characters of each member shown. A fold must see the facts, so this is wider than arc evidence. */
 const COMPRESS_MEMBER_CHARS = 1200;
+/**
+* Deep compress passes before the loop stops regardless of yield (issue #63). Each extra pass costs
+* a full re-index, a re-mine, and another round of model calls, and the third pass's yield on any
+* real corpus is folds of folds — past that the loop is spending calls to rename its own output.
+*/
+const DEEP_COMPRESS_MAX_PASSES = 3;
+/**
+* Active files an entity may be claimed by before deep grouping treats it as a stop-word
+* (issue #63). An entity on sixty-plus files ("service:api", a person who appears everywhere) says
+* which corpus this is, not which memories are one topic, and batching its claimants would fold
+* unrelated facts for sharing a byline. Groups under the limit still slice to
+* {@link COMPRESS_BATCH_SIZE} through the same kernel as every other group.
+*/
+const DEEP_ENTITY_HUB_LIMIT = 64;
+/** The synthetic community-label prefix entity groups use. No git path starts with this. */
+const ENTITY_LABEL_PREFIX = "entity:";
+/**
+* The community label of every active path under the WIDENED graph: nightly memory edges plus the
+* deep grouping band, one label-propagation pass (issue #63).
+*
+* Computed here rather than inside `runRetentionPass`, deliberately: retention's partition feeds
+* eviction scoring and must not move when a deep band is present in the index, so the widened
+* partition is a second, compress-only computation over reads this module already owns.
+*/
+const deepCommunityLabels = (env) => Effect.gen(function* () {
+	const corpus = yield* activeCorpus(env.deps.db);
+	const nightly = yield* memoryEdges(env.deps.db);
+	const band = yield* deepGroupingEdges(env.deps.db);
+	return labelPropagation(corpus.map((row) => row.path), [...nightly, ...band].map((edge) => ({
+		src: edge.src_path,
+		dst: edge.dst_path,
+		strength: edge.strength
+	})));
+}).pipe(Effect.orElseSucceed(() => /* @__PURE__ */ new Map()));
+/**
+* Assign an `entity:<type>:<name>` label to every candidate the graph left communityless, greedily,
+* one label per file (issue #63). PURE, so the hub cap and the one-label rule are unit-assertable
+* without a corpus.
+*
+* Entities are walked in lexicographic (type, name) order and each claims its unclaimed candidates,
+* so the assignment is a pure function of the corpus: a file naming two entities lands with the
+* lexicographically first, and the run makes the same batches twice over. A group needs two members
+* to mean anything, matching {@link COMPRESS_MIN_BATCH}.
+*
+* **The hub cap reads the entity's ACTIVE claimant count, not its needing count.** An entity on a
+* hundred files whose tail happens to leave only three in the inbox band is still a stop-word:
+* what those three share is a byline, not a topic.
+*/
+const assignEntityLabels = (claims, needing) => {
+	const byEntity = /* @__PURE__ */ new Map();
+	for (const claim of claims) {
+		const key = `${claim.entity_type}:${claim.entity_name}`;
+		const bucket = byEntity.get(key);
+		if (bucket === void 0) byEntity.set(key, [claim.path]);
+		else bucket.push(claim.path);
+	}
+	const labels = /* @__PURE__ */ new Map();
+	let hubsSkipped = 0;
+	for (const [key, paths] of [...byEntity.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
+		if (paths.length > 64) {
+			hubsSkipped += 1;
+			continue;
+		}
+		const members = paths.filter((path) => needing.has(path) && !labels.has(path));
+		if (members.length < 2) continue;
+		for (const member of members) labels.set(member, `${ENTITY_LABEL_PREFIX}${key}`);
+	}
+	return {
+		labels,
+		hubsSkipped
+	};
+};
+/** {@link assignEntityLabels} over the index's own claim rows. */
+const entityLabelsFor = (env, needing) => entityClaims(env.deps.db).pipe(Effect.map((claims) => assignEntityLabels(claims, needing)), Effect.orElseSucceed(() => ({
+	labels: /* @__PURE__ */ new Map(),
+	hubsSkipped: 0
+})));
 const compress = (env) => Effect.gen(function* () {
 	const model = env.deps.model;
 	if (model === void 0) return {
@@ -11012,121 +11396,187 @@ const compress = (env) => Effect.gen(function* () {
 		}),
 		detail: "no model bound"
 	};
-	const candidates = (yield* runRetentionPass(env.deps.db, env.at)).scored.filter((entry) => entry.score.action === "compress" && entry.row.memory_type !== "arc" && !isSleepExcluded(entry.row.memory_type) && entry.community !== void 0).slice(0, COMPRESS_CANDIDATE_LIMIT);
-	/** Community -> its COMPRESS-band members, both orders fixed so batching is reproducible. */
-	const byCommunity = /* @__PURE__ */ new Map();
-	for (const entry of candidates) {
-		const label = entry.community;
-		if (label === void 0) continue;
-		const bucket = byCommunity.get(label);
-		if (bucket === void 0) byCommunity.set(label, [entry]);
-		else bucket.push(entry);
-	}
-	/**
-	* Both sorts are this phase's, and the kernel keeps the order they produce. Communities are
-	* walked lexicographically by label so a night's call order is fixed, and each community's members
-	* by `row.path` so the `m1`..`mN` keys land on the same files twice over.
-	*/
-	const groups = [...byCommunity.entries()].sort(([left], [right]) => left < right ? -1 : 1).map(([, members]) => [...members].sort((left, right) => left.row.path < right.row.path ? -1 : left.row.path > right.row.path ? 1 : 0));
-	const batches = assembleBatches(groups, {
-		maxMembers: 8,
-		minMembers: 2
-	});
-	const counts = {
-		candidates: candidates.length,
-		communities: byCommunity.size,
-		batches: batches.length,
-		canonicals: 0,
-		archived: 0,
-		skipped: 0
-	};
-	if (batches.length === 0) return emptyOutcome(counts);
-	if (env.dryRun) return emptyOutcome(counts);
 	const modelKey = modelFor(env.deps, "compress");
-	let llmCalls = 0;
-	let canonicals = 0;
-	let archived = 0;
-	let skipped = 0;
+	const passes = [];
 	let lastCommit = null;
-	for (const batch of batches) {
-		/** Opaque keys again, so `absorbedKeys` cannot name a path. */
-		const keyed = keyMembers(batch, (entry) => `${entry.row.title}\n${entry.row.gist}\n${entry.row.body_text}`, { charBudget: COMPRESS_MEMBER_CHARS });
-		llmCalls += 1;
-		const synthesis = yield* batchCall(model, `compress batch of ${batch.length}`, {
-			schema: CompressSynthesis,
-			system: COMPRESS_SYSTEM,
-			prompt: compressPrompt(keyed.keyed),
-			modelKey,
-			effort: "high",
-			toolDescription: "Emit the canonical memory and the members whose content it absorbs."
-		});
-		if (synthesis === void 0) {
-			skipped += 1;
-			continue;
-		}
-		/** A key the batch never offered resolves to nothing, so a fold reaches only offered files. */
-		const absorbed = resolveKeys(keyed, synthesis.absorbedKeys).map((entry) => entry.row.path);
-		if (absorbed.length < 2 || synthesis.title.trim() === "" || synthesis.claim.trim() === "") {
-			skipped += 1;
-			continue;
-		}
+	for (let passAt = 0; passAt < (env.deep === void 0 ? 1 : 3);) {
+		passAt += 1;
+		const banded = (yield* runRetentionPass(env.deps.db, env.at)).scored.filter((entry) => entry.score.action === "compress" && entry.row.memory_type !== "arc" && !isSleepExcluded(entry.row.memory_type));
 		/**
-		* The canonical is placed in the batch's own directory when the members agree on one, and in the
-		* inbox otherwise. Placing it under a member's directory keeps a compressed group where a reader
-		* would look for it, and `memhtml doctor` reports inbox depth so a disagreeing batch is visible.
+		* Which label a candidate folds under. Nightly: the retention pass's own community, and a
+		* memory without one is not a candidate — the exact selection this phase has always made.
+		* Deep: the widened partition first, then an entity label for what the graph still missed.
 		*/
-		const directories = new Set(absorbed.map((path) => path.slice(0, path.lastIndexOf("/"))));
-		const canonicalPath = `${(directories.size === 1 ? [...directories][0] : "areas/inbox") ?? "areas/inbox"}/${slugify(synthesis.title)}.html`;
-		const members = excludeSelfSupersede(canonicalPath, absorbed);
-		if (members.length === 0) {
-			skipped += 1;
-			continue;
+		const widened = env.deep === void 0 ? void 0 : yield* deepCommunityLabels(env);
+		const communityOf = (entry) => widened === void 0 ? entry.community : widened.get(entry.row.path);
+		const graphLabelled = banded.filter((entry) => communityOf(entry) !== void 0);
+		const needing = env.deep === void 0 ? /* @__PURE__ */ new Set() : new Set(banded.filter((entry) => communityOf(entry) === void 0).map((entry) => entry.row.path));
+		const entities = env.deep === void 0 ? {
+			labels: /* @__PURE__ */ new Map(),
+			hubsSkipped: 0
+		} : yield* entityLabelsFor(env, needing);
+		const candidates = [...graphLabelled, ...banded.filter((entry) => entities.labels.has(entry.row.path))].slice(0, COMPRESS_CANDIDATE_LIMIT);
+		/** Community -> its COMPRESS-band members, both orders fixed so batching is reproducible. */
+		const byCommunity = /* @__PURE__ */ new Map();
+		for (const entry of candidates) {
+			const label = communityOf(entry) ?? entities.labels.get(entry.row.path);
+			if (label === void 0) continue;
+			const bucket = byCommunity.get(label);
+			if (bucket === void 0) byCommunity.set(label, [entry]);
+			else bucket.push(entry);
 		}
 		/**
-		* The members are archived FIRST, and the canonical is written only if at least one member was
-		* actually moved. A batch whose members an earlier phase already evicted would otherwise leave a
-		* canonical behind claiming to supersede files it never absorbed.
+		* Both sorts are this phase's, and the kernel keeps the order they produce. Communities are
+		* walked lexicographically by label so a night's call order is fixed, and each community's members
+		* by `row.path` so the `m1`..`mN` keys land on the same files twice over.
 		*/
-		const archivedPaths = [];
-		for (const member of members) {
-			const archivedPath = yield* archiveFile(env, member, [meta("memhtml-superseded-by", hrefFor(canonicalPath))]);
-			if (archivedPath !== null) archivedPaths.push(archivedPath);
-		}
-		if (archivedPaths.length === 0) {
-			skipped += 1;
-			continue;
-		}
-		yield* writeFileBytes(env, canonicalPath, renderTemplate({
-			title: synthesis.title.trim(),
-			claim: synthesis.claim,
-			body: synthesis.paragraphs,
-			memoryType: "semantic",
-			at: env.at,
-			author: "agent:sleep"
-		}));
-		for (const archivedPath of archivedPaths) yield* stampFile(env, canonicalPath, [link("supersedes", hrefFor(archivedPath))]);
-		yield* env.deps.git.add([canonicalPath]);
-		archived += archivedPaths.length;
-		canonicals += 1;
-		const commitSha = yield* commitPhase(env, "compress", `fold ${members.length} memories into ${synthesis.title}`, {
-			...counts,
-			canonicals,
-			archived,
-			skipped
+		const groups = [...byCommunity.entries()].sort(([left], [right]) => left < right ? -1 : 1).map(([, members]) => [...members].sort((left, right) => left.row.path < right.row.path ? -1 : left.row.path > right.row.path ? 1 : 0));
+		const batches = assembleBatches(groups, {
+			maxMembers: 8,
+			minMembers: 2
 		});
-		if (commitSha !== null) lastCommit = commitSha;
+		const tally = {
+			candidates: candidates.length,
+			communities: byCommunity.size,
+			entityGroups: new Set(entities.labels.values()).size,
+			batches: batches.length,
+			canonicals: 0,
+			archived: 0,
+			skipped: 0,
+			failed: 0,
+			refused: 0,
+			budget: 0,
+			llmCalls: 0
+		};
+		passes.push(tally);
+		if (batches.length === 0 || env.dryRun) break;
+		for (const batch of batches) {
+			/** Opaque keys again, so `absorbedKeys` cannot name a path. */
+			const keyed = keyMembers(batch, (entry) => `${entry.row.title}\n${entry.row.gist}\n${entry.row.body_text}`, { charBudget: COMPRESS_MEMBER_CHARS });
+			/**
+			* The deep budget is charged BEFORE the call, and an exhausted budget is its own skip
+			* reason: a night that stopped because the operator's cap ran out and a night whose model
+			* fell over need different mornings-after, and `skipped` alone cannot say which this was.
+			*/
+			if (!takeLlmCall(env.deep)) {
+				tally.skipped += 1;
+				tally.budget += 1;
+				continue;
+			}
+			tally.llmCalls += 1;
+			const synthesis = yield* batchCall(model, `compress batch of ${batch.length}`, {
+				schema: CompressSynthesis,
+				system: COMPRESS_SYSTEM,
+				prompt: compressPrompt(keyed.keyed),
+				modelKey,
+				effort: "high",
+				toolDescription: "Emit the canonical memory and the members whose content it absorbs."
+			});
+			if (synthesis === void 0) {
+				tally.skipped += 1;
+				tally.failed += 1;
+				continue;
+			}
+			/** A key the batch never offered resolves to nothing, so a fold reaches only offered files. */
+			const absorbed = resolveKeys(keyed, synthesis.absorbedKeys).map((entry) => entry.row.path);
+			if (absorbed.length < 2 || synthesis.title.trim() === "" || synthesis.claim.trim() === "") {
+				tally.skipped += 1;
+				tally.refused += 1;
+				yield* Effect.logWarning(`sleep.llm compress batch of ${batch.length} refused: the model absorbed ${absorbed.length} of ${synthesis.absorbedKeys.length} named keys` + (synthesis.absorbedKeys.length > 0 && absorbed.length === 0 ? ` (none of the named keys resolved: ${synthesis.absorbedKeys.slice(0, 3).join(", ")}${synthesis.absorbedKeys.length > 3 ? ", …" : ""})` : ""));
+				continue;
+			}
+			/**
+			* The canonical is placed in the batch's own directory when the members agree on one, and in the
+			* inbox otherwise. Placing it under a member's directory keeps a compressed group where a reader
+			* would look for it, and `memhtml doctor` reports inbox depth so a disagreeing batch is visible.
+			*/
+			const directories = new Set(absorbed.map((path) => path.slice(0, path.lastIndexOf("/"))));
+			const canonicalPath = `${(directories.size === 1 ? [...directories][0] : "areas/inbox") ?? "areas/inbox"}/${slugify(synthesis.title)}.html`;
+			const members = excludeSelfSupersede(canonicalPath, absorbed);
+			if (members.length === 0) {
+				tally.skipped += 1;
+				tally.refused += 1;
+				yield* Effect.logWarning(`sleep.llm compress batch of ${batch.length} refused: every absorbed member was the canonical itself`);
+				continue;
+			}
+			/**
+			* The members are archived FIRST, and the canonical is written only if at least one member was
+			* actually moved. A batch whose members an earlier phase already evicted would otherwise leave a
+			* canonical behind claiming to supersede files it never absorbed.
+			*/
+			const archivedPaths = [];
+			for (const member of members) {
+				const archivedPath = yield* archiveFile(env, member, [meta("memhtml-superseded-by", hrefFor(canonicalPath))]);
+				if (archivedPath !== null) archivedPaths.push(archivedPath);
+			}
+			if (archivedPaths.length === 0) {
+				tally.skipped += 1;
+				tally.refused += 1;
+				yield* Effect.logWarning(`sleep.llm compress batch of ${batch.length} refused: every member was already gone from the tree`);
+				continue;
+			}
+			yield* writeFileBytes(env, canonicalPath, renderTemplate({
+				title: synthesis.title.trim(),
+				claim: synthesis.claim,
+				body: synthesis.paragraphs,
+				memoryType: "semantic",
+				at: env.at,
+				author: "agent:sleep"
+			}));
+			for (const archivedPath of archivedPaths) yield* stampFile(env, canonicalPath, [link("supersedes", hrefFor(archivedPath))]);
+			yield* env.deps.git.add([canonicalPath]);
+			tally.archived += archivedPaths.length;
+			tally.canonicals += 1;
+			const commitSha = yield* commitPhase(env, "compress", `fold ${members.length} memories into ${synthesis.title}`, totalsOf(passes));
+			if (commitSha !== null) lastCommit = commitSha;
+		}
+		/**
+		* Iterate-until-quiet, deep only (issue #63). A pass that folded nothing has reached the
+		* fixed point; one that folded something changed the neighbor structure, so the branch is
+		* re-indexed (renames tracked, new canonicals embedded), both bands are re-mined over the new
+		* vectors, and the next pass sees the canonicals as members. The nightly cycle exits here
+		* unconditionally, which is what keeps its behavior single-pass and byte-identical.
+		*/
+		if (env.deep === void 0 || tally.canonicals === 0) break;
+		if (passAt >= 3) break;
+		yield* env.deps.indexer.update({ embed: true });
+		yield* mineAllBands(env);
 	}
 	return {
-		counts: {
-			...counts,
-			canonicals,
-			archived,
-			skipped
-		},
+		counts: totalsOf(passes),
 		commitSha: lastCommit,
-		llmCalls
+		llmCalls: passes.reduce((total, tally) => total + tally.llmCalls, 0)
 	};
 });
+/**
+* The pass tallies as one counts record. Work counters SUM across passes; `candidates` and
+* `communities` describe the corpus the run STARTED from (the first pass), because a sum of
+* re-scans of one shrinking corpus counts nothing a reviewer can reconcile. On a nightly
+* single-pass run every key and every number is byte-identical to what this phase has always
+* reported — the deep-only keys appear only when a deep quantity is nonzero or a second pass ran,
+* which cannot happen without the flag. Response counts are append-only, so the deep keys are
+* additions and no shipped key changes meaning.
+*/
+const totalsOf = (passes) => {
+	const first = passes[0];
+	const sum = (of) => passes.reduce((total, tally) => total + of(tally), 0);
+	const deepish = passes.length > 1 || (first?.entityGroups ?? 0) > 0 || sum((tally) => tally.budget) > 0;
+	return {
+		candidates: first?.candidates ?? 0,
+		communities: first?.communities ?? 0,
+		batches: sum((tally) => tally.batches),
+		canonicals: sum((tally) => tally.canonicals),
+		archived: sum((tally) => tally.archived),
+		skipped: sum((tally) => tally.skipped),
+		failed: sum((tally) => tally.failed),
+		refused: sum((tally) => tally.refused),
+		...deepish ? {
+			passes: passes.length,
+			entityGroups: first?.entityGroups ?? 0,
+			budgetSkipped: sum((tally) => tally.budget)
+		} : {}
+	};
+};
 
 //#endregion
 //#region packages/sleep/dist/phases/confidence-decay.js
@@ -12032,7 +12482,9 @@ const dedupMerge = (env) => Effect.gen(function* () {
 				candidates: oriented.length,
 				components: 0,
 				llmGroups: 0,
-				vetoed: oriented.length - decisions.length
+				vetoed: oriented.length - decisions.length,
+				skipped: 0,
+				unresolved: 0
 			},
 			/**
 			* Every mined pair on this arm cleared 0.92, so a vetoed one here is a near-certain duplicate
@@ -12103,6 +12555,12 @@ const dedupMerge = (env) => Effect.gen(function* () {
 	let llmCalls = 0;
 	let llmGroups = 0;
 	let skipped = 0;
+	/**
+	* Model-named member keys that resolved to no offered member, dropped unacted. The drop is the
+	* safe outcome and stays; the count makes a systematic naming pattern visible instead of reading
+	* as a night in which the model proposed no merges (issue #58).
+	*/
+	let unresolved = 0;
 	/** Group-implied pairs, in batch then component then group order. */
 	const groupPairs = [];
 	/** Every path a surviving group claimed, so the mined arm cannot re-propose one. */
@@ -12142,11 +12600,17 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			skipped += 1;
 			continue;
 		}
+		/** This batch's unresolvable keys, so the warning below can name the spellings that failed. */
+		const unresolvedKeys = [];
 		for (const group of partition.groups) {
+			const dropped = group.memberKeys.filter((key) => offeredKeyFor(keyed, key) === void 0);
+			unresolved += dropped.length;
+			unresolvedKeys.push(...dropped);
 			const members = resolveKeys(keyed, group.memberKeys);
 			if (members.length < 2) continue;
 			if (new Set(group.memberKeys.flatMap((key) => {
-				const id = componentOfKey.get(key);
+				const canonical = offeredKeyFor(keyed, key);
+				const id = canonical === void 0 ? void 0 : componentOfKey.get(canonical);
 				return id === void 0 ? [] : [id];
 			})).size !== 1) continue;
 			/** The keeper is the OLDEST member: the lowest corpus offset, the same rule a pair uses. */
@@ -12172,6 +12636,7 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			}
 			grouped.add(keeper.path);
 		}
+		if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm dedup batch of ${batch.length} components dropped ${unresolvedKeys.length} member keys naming no offered member (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 	}
 	/**
 	* Groups first, then the mined pairs above the DETERMINISTIC floor that no group claimed. The
@@ -12191,7 +12656,8 @@ const dedupMerge = (env) => Effect.gen(function* () {
 				components: components.length,
 				llmGroups,
 				vetoed: proposed.length - decisions.length,
-				skipped
+				skipped,
+				unresolved
 			},
 			/**
 			* On this arm a vetoed pair is one the MODEL grouped as the same memory, or one that cleared
@@ -12202,11 +12668,13 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			*
 			* `judged` is false when a batch's call failed, because those components were never partitioned:
 			* their pairs reach the veto only through the mined arm, so a night that lost a call cannot say
-			* whether a pair it did not see is still a candidate.
+			* whether a pair it did not see is still a candidate. An unresolved member key is the same
+			* hazard from the answer side — a group the phase could not fully map was not fully judged —
+			* so it holds the sweep back the same way.
 			*/
 			{
 				vetoed: vetoedPairs(proposed),
-				judged: skipped === 0
+				judged: skipped === 0 && unresolved === 0
 			}
 		),
 		llmCalls
@@ -12631,6 +13099,7 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		contradictions: 0,
 		promoted: 0,
 		skipped: 0,
+		unresolved: 0,
 		capped: 0,
 		duplicates: 0,
 		tasksMinted: 0,
@@ -12697,6 +13166,13 @@ const edgeTyping = (env) => Effect.gen(function* () {
 	let capped = 0;
 	/** Second-and-later verdicts naming a key their batch had already answered for. */
 	let duplicates = 0;
+	/**
+	* Verdicts whose key resolved to no offered pair, so they were dropped unacted. Dropping is the
+	* safe outcome and stays; the count is what makes a SYSTEMATIC pattern visible — a model naming
+	* keys in a spelling the resolver refuses drops every verdict of every batch, and a night that
+	* judged nothing looked identical to a night whose model answered nothing (issue #58).
+	*/
+	let unresolved = 0;
 	let llmCalls = 0;
 	/**
 	* Contradictions this night detected for the FIRST time, so below the promotion gate.
@@ -12737,18 +13213,27 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		* rather than silently swallowed, so a model doing this is visible in a night's report.
 		*/
 		const answered = /* @__PURE__ */ new Set();
+		/** This batch's dropped verdicts, so the warning below can name the spellings that failed. */
+		const unresolvedKeys = [];
 		for (const verdict of answer.verdicts) {
 			/**
 			* The key is resolved through the kernel, so an invented key yields no candidate and no
-			* write.
+			* write. The CANONICAL key feeds the repeat guard, so `m1` and its label-prefixed spelling
+			* `pair_m1` in one answer are one pair answered twice, not two pairs.
 			*/
-			const [candidate] = resolveKeys(keyed, [verdict.pairKey]);
+			const pairKey = offeredKeyFor(keyed, verdict.pairKey);
+			if (pairKey === void 0) {
+				unresolved += 1;
+				unresolvedKeys.push(verdict.pairKey);
+				continue;
+			}
+			const [candidate] = resolveKeys(keyed, [pairKey]);
 			if (candidate === void 0) continue;
-			if (answered.has(verdict.pairKey)) {
+			if (answered.has(pairKey)) {
 				duplicates += 1;
 				continue;
 			}
-			answered.add(verdict.pairKey);
+			answered.add(pairKey);
 			judged += 1;
 			if (!assertsEdge(verdict)) continue;
 			if (assertsContradiction(verdict)) {
@@ -12851,14 +13336,18 @@ const edgeTyping = (env) => Effect.gen(function* () {
 			const [subject, object] = verdict.direction === "src_to_dst" ? [candidate.pair.src, candidate.pair.dst] : [candidate.pair.dst, candidate.pair.src];
 			if (yield* stampFile(env, subject, [link(verdict.rel, hrefFor(object)), meta("memhtml-updated", env.at)])) typed += 1;
 		}
+		if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm edge-typing batch of ${batch.length} dropped ${unresolvedKeys.length} verdicts naming no offered pair (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 	}
 	/**
 	* The single-detection contradictions become tasks in the SAME commit as the promotions. The
 	* sweep is gated on a night that judged its whole candidate set: `skipped` counts pairs whose
 	* batch's call failed as well as pairs whose endpoint the tree no longer holds, and a pair the
 	* model was never asked about must not read as a pair the model stopped contradicting.
+	* `unresolved` is the same hazard from the answer side — a verdict the phase could not map to a
+	* pair is a pair that was never judged, so its held-back contradiction must not close as "no
+	* longer detected" over a misspelled key.
 	*/
-	const tasks = yield* mintContradictionTasks(env, deferred, skipped === 0);
+	const tasks = yield* mintContradictionTasks(env, deferred, skipped === 0 && unresolved === 0);
 	const counts = {
 		candidates: candidates.length,
 		judged,
@@ -12866,6 +13355,7 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		contradictions,
 		promoted,
 		skipped,
+		unresolved,
 		capped,
 		duplicates,
 		tasksMinted: tasks.minted,
@@ -13382,6 +13872,12 @@ const entityResolution = (env) => Effect.gen(function* () {
 	/** Model calls that came back malformed. The sweep's precondition reads this; see below. */
 	let callsFailed = 0;
 	/**
+	* Cluster member keys (or canonical keys) resolving to no offered member, dropped unacted. The
+	* drop is the safe outcome and stays; the count makes a systematic naming pattern visible
+	* instead of reading as a night in which the model proposed no merges (issue #58).
+	*/
+	let unresolved = 0;
+	/**
 	* Every pair this night deferred to a human, as a value rather than only a count.
 	*
 	* This is issue #44's motivating case in one variable. The phase used to report
@@ -13493,6 +13989,8 @@ const entityResolution = (env) => Effect.gen(function* () {
 					callsFailed += 1;
 					continue;
 				}
+				/** This shard's unresolvable keys, so the warning below names the spellings that failed. */
+				const unresolvedKeys = [];
 				for (const cluster of clustering.clusters) {
 					/**
 					* A key the batch never offered resolves to nothing, so an invented member cannot become a
@@ -13500,6 +13998,9 @@ const entityResolution = (env) => Effect.gen(function* () {
 					* canonical is outside it contradicts itself, and guessing which half was meant would be
 					* the caller inventing a merge.
 					*/
+					const droppedKeys = [...cluster.memberKeys, cluster.canonicalKey].filter((key) => offeredKeyFor(keyed, key) === void 0);
+					unresolved += droppedKeys.length;
+					unresolvedKeys.push(...droppedKeys);
 					const memberNames = resolveKeys(keyed, cluster.memberKeys).map((centroid) => centroid.name);
 					const [canonicalMember] = resolveKeys(keyed, [cluster.canonicalKey]);
 					if (canonicalMember === void 0 || !memberNames.includes(canonicalMember.name)) continue;
@@ -13558,6 +14059,7 @@ const entityResolution = (env) => Effect.gen(function* () {
 						});
 					}
 				}
+				if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm entity-resolution ${entityType} batch of ${shard.length} dropped ${unresolvedKeys.length} cluster keys naming no offered member (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 			}
 		}
 		/**
@@ -13595,6 +14097,8 @@ const entityResolution = (env) => Effect.gen(function* () {
 		aliasMerges,
 		pendingCorroboration,
 		reviewCandidates,
+		callsFailed,
+		unresolved,
 		tasksMinted: 0,
 		tasksFramed: 0,
 		tasksDismissed: 0,
@@ -13620,7 +14124,12 @@ const entityResolution = (env) => Effect.gen(function* () {
 	* 1. The old early return on `rewrites.size === 0` would have skipped exactly the night this
 	* feature exists for: a night whose only outcome was deferrals is a night with no rewrites.
 	*/
-	const tasks = yield* mintReviewTasks(env, deferred, model !== void 0 && callsFailed === 0);
+	/**
+	* `unresolved === 0` joins the sweep gate for the reason `callsFailed === 0` is already in it: a
+	* cluster key the phase could not map to a member is a name that was never judged, and sweeping
+	* against a night that lost part of an answer closes reviews over a misspelling.
+	*/
+	const tasks = yield* mintReviewTasks(env, deferred, model !== void 0 && callsFailed === 0 && unresolved === 0);
 	let rewritten = 0;
 	for (const [path, pairs] of [...rewrites.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
 		const html = yield* readFileBytes(env, path);
@@ -14023,6 +14532,228 @@ const personLinks = (env) => Effect.gen(function* () {
 	};
 });
 
+//#endregion
+//#region packages/sleep/dist/phases/placement-triage.js
+/**
+* Phase 14, placement triage. DEEP-ONLY (issue #63): propose a topic directory for each inbox
+* memory that even deep grouping left communityless, and `git mv` the ones the model places with
+* confidence. ONE COMMIT.
+*
+* The mechanism this phase exists for: a bulk-imported inbox is mostly NOT compressible — each file
+* is a distinct fact — and what keeps the inbox crowded is that nothing ever re-files them. `doctor`
+* reports `inboxCrowded` and no phase acts on it. This one does, under the same discipline as every
+* other mutation: on the review branch, in its own commit, reversible by discarding the branch.
+*
+* **On a nightly run the phase returns immediately**, before any read, with a reason — the same
+* shape `compress` has for a missing model. That is the whole no-flag contract: a run without
+* `--deep` cannot reach a single line of this phase's work.
+*
+* The deterministic guardrails, each enforced in code after the model answers:
+*
+* - a destination must be an EXISTING directory (as the index knows them) or one of at most
+*   {@link PLACEMENT_NEW_DIR_CAP} new `areas/<topic>` or `resources/<topic>` directories per run —
+*   first proposed, first minted, lexicographic order within one batch;
+* - the managed surfaces refuse: the inbox itself, `areas/arcs`, `resources/people`, anything under
+*   `archive/`, and any path outside the PARA buckets;
+* - tasks never move (excluded from the scan AND re-checked per row, matching the double guard
+*   task-detection carries);
+* - a file another phase already touched this run never moves, read from `git diff --name-only
+*   base..HEAD` — a `mv` of a path compress just archived would fail, and one of a path an earlier
+*   phase stamped would tear that phase's edit out of its own commit's diff;
+* - `keep-inbox`, an unknown key, a below-floor confidence, and an omitted member all leave the
+*   file where it is.
+*
+* **Inbound hrefs are rewritten in the same commit.** Integrity's dangling-href repair chases a
+* target into the ARCHIVE by deriving `archivePathFor`; a placement move is not an archive, so this
+* phase rewrites `<link>` elements in the files that point at each moved path itself, the same
+* remove-then-add splice integrity uses. The indexer tracks the rename (`diff -M` + `movePath`), so
+* chunks and embeddings carry over and nothing re-embeds.
+*/
+/** Inbox memories offered per model call. Placement is a lighter question than a fold, so wider. */
+const PLACEMENT_BATCH_SIZE = 16;
+/** Inbox memories considered per run. The model-cost guard, in the spirit of compress's 2000. */
+const PLACEMENT_CANDIDATE_LIMIT = 2e3;
+/** Characters of each member shown. Placement needs the topic, not every fact. */
+const PLACEMENT_MEMBER_CHARS = 600;
+/**
+* New topic directories one run may mint. Small on purpose: a new directory is a new place every
+* future reader and `placementFor` caller has to know about, and a bulk import that genuinely needs
+* thirty new topics should earn them over several reviewed runs, not one.
+*/
+const PLACEMENT_NEW_DIR_CAP = 5;
+const placementTriage = (env) => Effect.gen(function* () {
+	if (env.deep === void 0) return {
+		...emptyOutcome({ candidates: 0 }),
+		detail: "deep-only phase; run with --deep"
+	};
+	const model = env.deps.model;
+	if (model === void 0) return {
+		...emptyOutcome({ candidates: 0 }),
+		detail: "no model bound"
+	};
+	/**
+	* Candidates: active inbox memories with no community even under the WIDENED graph — nightly
+	* edges plus the deep grouping band, the same partition deep compress groups by. Issue #63's
+	* "true singleton" is exactly this: a file even the 0.72 band could not attach to anything.
+	* A file the widened graph DID reach belongs to compress's pipeline (this run or a later one),
+	* not to placement; an ENTITY-grouped file is deliberately still placeable, because entity
+	* grouping is a compress-band mechanism and a KEEP-band inbox file it cannot fold still needs
+	* a home.
+	*/
+	const widened = yield* deepCommunityLabels(env);
+	const corpus = yield* activeCorpus(env.deps.db);
+	const inInbox = (path) => path.startsWith(`${"areas/inbox"}/`) && !path.startsWith(`${"areas/inbox"}/tasks/`);
+	const candidates = corpus.filter((row) => inInbox(row.path) && !isSleepExcluded(row.memory_type) && row.memory_type !== "arc" && widened.get(row.path) === void 0).sort((left, right) => left.path < right.path ? -1 : 1).slice(0, PLACEMENT_CANDIDATE_LIMIT);
+	/**
+	* The directories the corpus already has, from the index's own path set: every distinct
+	* directory holding an active file under `areas/` or `resources/`, minus the managed surfaces.
+	* Offered to the model verbatim and used as the validation set, so the question and the gate
+	* cannot disagree.
+	*/
+	const managed = /* @__PURE__ */ new Set([
+		INBOX_DIR,
+		`${INBOX_DIR}/tasks`,
+		ARCS_DIR,
+		PEOPLE_DIR
+	]);
+	const existingDirs = [...new Set(corpus.map((row) => row.path.slice(0, row.path.lastIndexOf("/"))).filter((dir) => (dir.startsWith("areas/") || dir.startsWith("resources/")) && !managed.has(dir)))].sort();
+	/** Paths this run already touched. A move of one would cross-contaminate another phase's diff. */
+	const touched = new Set(env.baseSha === "" ? [] : yield* env.deps.git.run([
+		"diff",
+		"--name-only",
+		`${env.baseSha}..HEAD`
+	]).pipe(Effect.map((out) => out.split("\n").map((line) => line.trim()).filter(Boolean)), Effect.orElseSucceed(() => [])));
+	const batches = assembleBatches([candidates], { maxMembers: 16 });
+	const counts = {
+		candidates: candidates.length,
+		batches: batches.length,
+		proposed: 0,
+		applied: 0,
+		refused: 0,
+		keptInbox: 0,
+		newDirs: 0,
+		budgetSkipped: 0,
+		failed: 0
+	};
+	if (batches.length === 0 || env.dryRun) return emptyOutcome(counts);
+	const modelKey = modelFor(env.deps, "placement-triage");
+	const mintedDirs = /* @__PURE__ */ new Set();
+	const movedFrom = /* @__PURE__ */ new Map();
+	let llmCalls = 0;
+	for (const batch of batches) {
+		const keyed = keyMembers(batch, (row) => `${row.title}\n${row.gist}\n${row.body_text}`, { charBudget: 600 });
+		if (!takeLlmCall(env.deep)) {
+			counts["budgetSkipped"] = (counts["budgetSkipped"] ?? 0) + 1;
+			continue;
+		}
+		llmCalls += 1;
+		const answer = yield* batchCall(model, `placement batch of ${batch.length}`, {
+			schema: PlacementTriage,
+			system: PLACEMENT_SYSTEM,
+			prompt: placementPrompt(existingDirs, keyed.keyed),
+			modelKey,
+			effort: "high",
+			toolDescription: "Propose a destination directory (or keep-inbox) per offered memory."
+		});
+		if (answer === void 0) {
+			counts["failed"] = (counts["failed"] ?? 0) + 1;
+			continue;
+		}
+		/**
+		* Placements resolve through the kernel, so an invented key drops. Sorted by (destination,
+		* key) so within one answer the minting order of new directories is a function of the answer's
+		* CONTENT rather than of its field order.
+		*/
+		const resolvedRows = answer.placements.filter((placement) => placement.destination.trim() !== "").sort((left, right) => left.destination < right.destination ? -1 : left.destination > right.destination ? 1 : left.memberKey < right.memberKey ? -1 : 1);
+		for (const placement of resolvedRows) {
+			const row = resolveKeys(keyed, [placement.memberKey])[0];
+			if (row === void 0) continue;
+			counts["proposed"] = (counts["proposed"] ?? 0) + 1;
+			const destination = normalizePath(placement.destination.trim());
+			if (destination === "keep-inbox") {
+				counts["keptInbox"] = (counts["keptInbox"] ?? 0) + 1;
+				continue;
+			}
+			const refuse = (reason) => {
+				counts["refused"] = (counts["refused"] ?? 0) + 1;
+				return Effect.logWarning(`sleep.placement refused ${row.path} -> ${destination}: ${reason}`);
+			};
+			if (placement.confidence < .7) {
+				yield* refuse("below the confidence floor");
+				continue;
+			}
+			const bucket = paraBucketOf(destination);
+			if (bucket !== "areas" && bucket !== "resources" || managed.has(destination) || destination === row.path.slice(0, row.path.lastIndexOf("/")) || destination.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+				yield* refuse("not a placeable directory");
+				continue;
+			}
+			if (isSleepExcluded(row.memory_type)) {
+				yield* refuse("tasks never move");
+				continue;
+			}
+			if (touched.has(row.path) || movedFrom.has(row.path)) {
+				yield* refuse("another phase touched this file this run");
+				continue;
+			}
+			const isNew = !existingDirs.includes(destination) && !mintedDirs.has(destination);
+			if (isNew && mintedDirs.size >= 5) {
+				yield* refuse("the new-directory cap for this run is spent");
+				continue;
+			}
+			const target = `${destination}/${row.path.slice(row.path.lastIndexOf("/") + 1)}`;
+			if (!isValidMemoryPath(target)) {
+				yield* refuse("the destination path is not a valid memory path");
+				continue;
+			}
+			if ((yield* readFileBytes(env, target)) !== void 0) {
+				yield* refuse("the destination already holds a file by that name");
+				continue;
+			}
+			if ((yield* readFileBytes(env, row.path)) === void 0) {
+				yield* refuse("the source file is already gone from the tree");
+				continue;
+			}
+			yield* attemptIo(`sleep.placement.mkdir:${target}`, async () => {
+				const { mkdir } = await import("node:fs/promises");
+				const { dirname } = await import("node:path");
+				await mkdir(dirname(absoluteIn(env, target)), { recursive: true });
+			});
+			yield* env.deps.git.mv(row.path, target);
+			yield* stampFile(env, target, [meta("memhtml-updated", env.at)]);
+			if (isNew) {
+				mintedDirs.add(destination);
+				counts["newDirs"] = (counts["newDirs"] ?? 0) + 1;
+			}
+			movedFrom.set(row.path, target);
+			counts["applied"] = (counts["applied"] ?? 0) + 1;
+		}
+	}
+	/**
+	* Inbound href repair, inside the same commit as the moves. Every authored `<link>` whose
+	* target moved is respliced in ITS OWN file to the new path — remove-then-add, integrity's
+	* idempotent shape — so the branch never carries a commit whose links dangle by construction.
+	*/
+	let rewritten = 0;
+	for (const [from, to] of [...movedFrom.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
+		const inbound = yield* inboundAuthoredEdges(env.deps.db, from);
+		for (const edge of inbound) {
+			if (!isEdgeRel(edge.rel)) continue;
+			const holder = movedFrom.get(edge.src_path) ?? edge.src_path;
+			if (yield* stampFile(env, holder, [
+				unlink(edge.rel, hrefFor(from)),
+				link(edge.rel, hrefFor(to)),
+				meta("memhtml-updated", env.at)
+			])) rewritten += 1;
+		}
+	}
+	counts["hrefsRewritten"] = rewritten;
+	return {
+		counts,
+		commitSha: yield* commitPhase(env, "placement-triage", `re-file ${counts["applied"] ?? 0} inbox memories into topic directories`, counts),
+		llmCalls
+	};
+});
+
 //#endregion
 //#region packages/sleep/dist/phases/preflight.js
 /**
@@ -14059,60 +14790,6 @@ const preflight = (env) => Effect.gen(function* () {
 	}) };
 });
 
-//#endregion
-//#region packages/sleep/dist/phases/relationship-mining.js
-/**
-* Phase 5, relationship mining. Derived `relates_to` edges in the index only. NO COMMIT.
-*
-* A mined edge is a re-derivable function of the corpus and the embedder. `index rebuild` plus the
-* next night's mining regenerates the identical set, so committing thousands of them would bury every
-* real diff in machine noise for zero recoverable information. The `derived` column is the firewall
-* that makes losing them cheap. The retention penalty counts only `derived = 0`, so an
-* uncorroborated machine suspicion cannot evict a memory.
-*
-* The insert is scoped to `provenance = 'sleep'` and `derived = 1` and the whole replace is one
-* atomic batch, so an authored edge is unreachable from here and the corpus is never left with the
-* old mined set deleted and the new one not yet written. In that window the lateral arm would
-* silently return nothing.
-*/
-/** The similarity floor a pair must clear to become a mined `relates_to`. */
-const MINING_COSINE_FLOOR = .85;
-/** Nearest neighbors considered per source file. */
-const MINING_PER_SOURCE_K = 5;
-/**
-* Pairs mined per cycle: a cap on what {@link replaceMinedEdges} writes, not on the scan — the
-* kernel's arithmetic is O(n²·d) whatever this says, and it bounds the edge table so one dense
-* neighborhood cannot flood the graph the lateral arm and PageRank read.
-*/
-const MINING_SAMPLE_LIMIT = 2e3;
-const relationshipMining = (env) => Effect.gen(function* () {
-	/**
-	* Tasks are excluded, and here the exclusion is the graph firewall, not a cost guard.
-	* Every mined edge is written with `edge_class = 'memory'`, so a pair with a task endpoint
-	* would put a task INTO the memory graph, reaching PageRank, MMR, and the retention bridge
-	* count. The `edges` CHECK cannot refuse it, because `relates_to` under `memory` is a
-	* well-formed edge whatever files sit at its ends.
-	*/
-	const pairs = yield* neighborPairs(env.deps.db, {
-		floor: MINING_COSINE_FLOOR,
-		perSourceK: 5,
-		limit: MINING_SAMPLE_LIMIT,
-		excludeTypes: SLEEP_EXCLUDED_TYPES
-	});
-	const counts = {
-		candidates: pairs.length,
-		mined: pairs.length
-	};
-	if (env.dryRun) return emptyOutcome(counts);
-	yield* replaceMinedEdges(env.deps.db, {
-		runId: env.runId,
-		at: env.at,
-		rel: "relates_to",
-		pairs
-	});
-	return emptyOutcome(counts);
-});
-
 //#endregion
 //#region packages/sleep/dist/report.js
 /**
@@ -14617,6 +15294,12 @@ const taskDetection = (env) => Effect.gen(function* () {
 	let dismissed = 0;
 	let skipped = 0;
 	/**
+	* Findings whose key resolved to no offered member, dropped unacted. The drop is the safe
+	* outcome and stays; the count makes a systematic pattern visible, because a night whose every
+	* finding named an unresolvable key otherwise reads as a night with no open work (issue #58).
+	*/
+	let unresolved = 0;
+	/**
 	* Every key this night's scan SAW, whether or not it minted and whether or not it cleared the floor.
 	* The sweep's input; see the `liveKeys.add` below for why the floor is not a filter here.
 	*/
@@ -14644,11 +15327,20 @@ const taskDetection = (env) => Effect.gen(function* () {
 		* because it is called one key at a time here — a finding names one member.
 		*/
 		const answered = /* @__PURE__ */ new Set();
+		/** This batch's dropped findings, so the warning below can name the spellings that failed. */
+		const unresolvedKeys = [];
 		for (const finding of answer.findings) {
-			const [row] = resolveKeys(keyed, [finding.memberKey]);
+			/** The CANONICAL key feeds the repeat guard, same as edge-typing's, and for the same reason. */
+			const memberKey = offeredKeyFor(keyed, finding.memberKey);
+			if (memberKey === void 0) {
+				unresolved += 1;
+				unresolvedKeys.push(finding.memberKey);
+				continue;
+			}
+			const [row] = resolveKeys(keyed, [memberKey]);
 			if (row === void 0) continue;
-			if (answered.has(finding.memberKey)) continue;
-			answered.add(finding.memberKey);
+			if (answered.has(memberKey)) continue;
+			answered.add(memberKey);
 			findings += 1;
 			/**
 			* The key is the SOURCE PATH plus the normalized sentence, so the same commitment found again
@@ -14694,13 +15386,17 @@ const taskDetection = (env) => Effect.gen(function* () {
 			else if (outcome === "framed") framed += 1;
 			else if (outcome === "dismissed") dismissed += 1;
 		}
+		if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm task-detection batch of ${batch.length} dropped ${unresolvedKeys.length} findings naming no offered member (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 	}
 	/**
 	* The sweep, only from a full-strength scan. `skipped > 0` means at least one batch's memories
 	* went unread, so a finding of theirs is missing from `liveKeys` because the phase could not look
-	* rather than because it is gone.
+	* rather than because it is gone. `unresolved > 0` is the same hazard from the answer side: the
+	* model reported a finding the phase could not map to a member, so its detection key was never
+	* constructed, and sweeping against that would close a live task because the model misspelled a
+	* key rather than because the finding vanished.
 	*/
-	const closed = skipped === 0 ? yield* closeVanishedDetections(env, TASK_DETECT_DETECTOR, liveKeys) : 0;
+	const closed = skipped === 0 && unresolved === 0 ? yield* closeVanishedDetections(env, TASK_DETECT_DETECTOR, liveKeys) : 0;
 	const counts = {
 		candidates: candidates.length,
 		batches: batches.length,
@@ -14712,7 +15408,8 @@ const taskDetection = (env) => Effect.gen(function* () {
 		dismissed,
 		closed,
 		capped: budget.overflow,
-		skipped
+		skipped,
+		unresolved
 	};
 	/**
 	* A refresh writes a `memhtml-updated` stamp, which is a staged file, so it commits — the queue's
@@ -14748,7 +15445,8 @@ const ZERO = {
 	dismissed: 0,
 	closed: 0,
 	capped: 0,
-	skipped: 0
+	skipped: 0,
+	unresolved: 0
 };
 
 //#endregion
@@ -15685,6 +16383,7 @@ const PHASE_BODIES = {
 	reprieve,
 	"trace-consolidation": traceConsolidation,
 	"task-detection": taskDetection,
+	"placement-triage": placementTriage,
 	integrity,
 	"state-export": stateExport,
 	report: reportPhase([])
@@ -15745,7 +16444,14 @@ const run = (deps, options) => Effect.gen(function* () {
 		* Created per run rather than held in a module, which is what keeps two runs in one process (and
 		* two tests in one file) from sharing a counter.
 		*/
-		detectionBudget: makeDetectionBudget()
+		detectionBudget: makeDetectionBudget(),
+		/**
+		* The deep switches, shaped once here so every phase reads one field. The LLM budget is the
+		* same created-per-run discipline as the detection budget above, and it exists only when the
+		* caller stated a cap: an uncapped deep run is a valid ask, and a phantom cap of zero (or of
+		* some default nobody chose) would silently skip work the operator paid for the flag to reach.
+		*/
+		...options.deep === true ? { deep: { ...options.maxLlmCalls === void 0 ? {} : { budget: makeLlmBudget(options.maxLlmCalls) } } } : {}
 	};
 	if (!dryRun) yield* deps.git.checkoutBranch(runId, { create: true }).pipe(Effect.orElseSucceed(() => {}));
 	yield* ignoreFailure(recordRun(deps.db, {
@@ -15812,7 +16518,9 @@ const resume = (deps, runId, options = {}) => Effect.gen(function* () {
 		* finishing. The cost of a fresh one is bounded by the cap, and the mints a resume repeats are
 		* refreshes rather than duplicates, which cost no budget at all.
 		*/
-		detectionBudget: makeDetectionBudget()
+		detectionBudget: makeDetectionBudget(),
+		/** A fresh LLM budget too, for the same reason the detection budget above is fresh. */
+		...options.deep === true ? { deep: { ...options.maxLlmCalls === void 0 ? {} : { budget: makeLlmBudget(options.maxLlmCalls) } } } : {}
 	};
 	const remaining = SLEEP_PHASES.filter((phase) => !completed.has(phase));
 	const executed = yield* executePhases(env, remaining, /* @__PURE__ */ new Set());
@@ -15820,7 +16528,7 @@ const resume = (deps, runId, options = {}) => Effect.gen(function* () {
 	const ended = yield* nowIso;
 	/**
 	* Skipped-because-already-done rows are reported explicitly, so a resume's report accounts for all
-	* sixteen phases. A report that showed only the eight it ran would read as a partial run.
+	* seventeen phases. A report that showed only the eight it ran would read as a partial run.
 	*/
 	const priorRows = yield* ignoreFailureWith(readPhases(deps.db, runId), []);
 	const already = [...completed].map((phase) => {
@@ -16861,4 +17569,4 @@ const latest = (left, right) => left === null ? right : right === null ? left :
 
 //#endregion
 export { STATE_DB_PATH as $, IndexRecorder as A, IndexGit as B, ModelClient as C, EmbeddingsLive as D, Embeddings as E, makeRetrieval as F, MIGRATIONS_DIR as G, sanitizeFtsQuery as H, reinforce as I, Store as J, STATE_MIGRATIONS_DIR as K, Indexer as L, persistScanned as M, readWatermark as N, EMBED_DIM as O, Retrieval as P, SLEEP_REPORTS_DIR as Q, makeIndexer as R, runDiscrimination as S, wrapAsData as T, DatabaseService as U, makeGitPort as V, makeDatabase as W, makeStore as X, expandRoot as Y, INDEX_DB_PATH as Z, meta as _, parseSidecar as a, makeGit as at, isSleepPhase as b, generateArtifacts as c, setMeta as ct, allPaths as d, fenceOpeningOf as dt, STATE_SIDECAR_PATH as et, danglingEdges as f, REINFORCE_SIGNALS as ft, link as g, hrefFor as h, makeSleep as i, Git as it, makeIndexRecorder as j, EMBED_WATERMARK as k, DETECTION_PREFIX as l, isValidDatetime as lt, applyHeadEdits as m, scanTraceRoot as n, initRepo as nt, renderSidecar as o, commitSubject as ot, publishRows as p, frameKeyOf as pt, STATE_SCHEMA as q, Sleep as r, readFileOrNull as rt, archivedFormOf as s, checkMemory as st, mergeTailExtract as t, attemptIo as tt, accessRows as u, closesFence as ut, unlink as v, ModelClientLive as w, discriminationGate as x, SLEEP_PHASES as y, readIndexState as z };
-//# sourceMappingURL=dist-D5DlgqH2.mjs.map
+//# sourceMappingURL=dist-CHoz5uHd.mjs.map