@elvisw/dsh-magic-context 0.0.0-bootstrap.0 → 0.0.0-stage

package/lib/dsh/command-surface.js

@@ -1,376 +0,0 @@
-import { decideConfirmation, listPendingConfirmations } from "../core/profile-confirmation.js";
-import { ORG_DOMAIN_ID, approvalGate, detectGlobalCandidates, promoteMemoryToCandidate, publishGlobalCandidate, } from "../core/global-domains.js";
-import { DEFAULT_DOMAIN_BUDGET_TOKENS, DEFAULT_SHARE_CATEGORIES, defaultDomainCap, isDomainKind, } from "../core/domains.js";
-const PROFILE_USAGE = 'list | show <id> | confirm <id> | reject <id> | retire <id> --yes';
-const GLOBAL_USAGE = 'domains | create <domain> --kind org|machine | members [<domain>] | enable <domain> | disable <domain> --yes | '
-    + 'add <domain> <identity> | remove <domain> <identity> --yes | candidates [<domain>] | '
-    + 'promote <memoryId> [--domain <domain>] | detect | approve <candidateId> --yes | reject-candidate <candidateId> --yes | '
-    + 'review via ctx_memory action=review_global (approval cards)';
-/** Flag value extractor: `--kind org` → 'org'. */
-function flagValue(tokens, name) {
-    const index = tokens.indexOf(name);
-    return index === -1 || index + 1 >= tokens.length ? undefined : tokens[index + 1];
-}
-function tokenize(rawInput) {
-    return (rawInput ?? '').trim().split(/\s+/).filter(token => token.length > 0);
-}
-function wantsApply(tokens) {
-    return tokens.includes('--yes') || tokens.includes('-y');
-}
-function stripFlags(tokens) {
-    return tokens.filter(token => !token.startsWith('-'));
-}
-function parseId(raw) {
-    if (raw === undefined)
-        return undefined;
-    const value = Number(raw);
-    return Number.isInteger(value) && value > 0 ? value : undefined;
-}
-// ── /ctx-profile ───────────────────────────────────────────────────────────
-/**
- * Plan or perform one `/ctx-profile` invocation.
- *
- * `confirm` is intentionally NOT gated behind `--yes`: it is the action the
- * notice asks the human to take, and gating it would make the queue harder to
- * drain than to fill. `reject` IS gated, because a rejection is what makes a
- * candidate disappear from the reviewer's view for good.
- */
-export function planProfileCommand(store, rawInput, now, profileWriter) {
-    const tokens = stripFlags(tokenize(rawInput));
-    const verb = tokens[0] ?? 'list';
-    if (verb === 'list') {
-        const pending = listPendingConfirmations(store);
-        if (pending.length === 0)
-            return { kind: 'success', text: 'Magic Context: no profile candidate is waiting.' };
-        const blocks = pending.map(row => `#${String(row.id)}\n${row.question}`);
-        return {
-            kind: 'success',
-            text: [`${String(pending.length)} candidate(s) waiting:`, ...blocks, `Reply with: /ctx-profile ${PROFILE_USAGE}`].join('\n\n'),
-        };
-    }
-    if (verb === 'show') {
-        const id = parseId(tokens[1]);
-        const row = id === undefined
-            ? undefined
-            : store.listProfileConfirmations().find(candidate => candidate.id === id);
-        if (row === undefined)
-            return { kind: 'error', text: `Magic Context: no confirmation #${tokens[1] ?? '?'}.` };
-        return { kind: 'success', text: `#${String(row.id)} [${row.state}]\n${row.question}` };
-    }
-    if (verb === 'confirm') {
-        const id = parseId(tokens[1]);
-        if (id === undefined)
-            return { kind: 'error', text: `Magic Context: /ctx-profile confirm needs an id. Usage: ${PROFILE_USAGE}` };
-        const decided = decideConfirmation(store, id, 'approved', now);
-        if (decided === undefined)
-            return { kind: 'error', text: `Magic Context: #${String(id)} is not waiting for a decision.` };
-        return {
-            kind: 'success',
-            text: `Magic Context: #${String(id)} confirmed. It is now an approved profile rule and takes effect in every session.\n`
-                + 'Promotion into the shared profile happens on the next maintenance tick; nothing is written from this command.',
-        };
-    }
-    if (verb === 'reject') {
-        const id = parseId(tokens[1]);
-        if (id === undefined)
-            return { kind: 'error', text: `Magic Context: /ctx-profile reject needs an id. Usage: ${PROFILE_USAGE}` };
-        if (!wantsApply(tokenize(rawInput))) {
-            return { kind: 'success', text: `Magic Context: would reject #${String(id)} (add --yes to apply).` };
-        }
-        const decided = decideConfirmation(store, id, 'rejected', now);
-        if (decided === undefined)
-            return { kind: 'error', text: `Magic Context: #${String(id)} is not waiting for a decision.` };
-        return { kind: 'success', text: `Magic Context: #${String(id)} rejected. It will never be promoted.` };
-    }
-    if (verb === 'retire') {
-        const id = parseId(tokens[1]);
-        if (id === undefined)
-            return { kind: 'error', text: `Magic Context: /ctx-profile retire needs a profile id. Usage: ${PROFILE_USAGE}` };
-        if (profileWriter === undefined || profileWriter.status.ok !== true) {
-            return {
-                kind: 'error',
-                text: 'Magic Context: the shared profile is not writable right now, so the row was left as it is.',
-            };
-        }
-        const row = profileWriter.listActiveProfiles().find(profile => profile.id === id);
-        if (row === undefined) {
-            // Distinguishing "not active" from "not writable" matters: an id that is
-            // already dismissed must not look like a failed write.
-            return { kind: 'error', text: `Magic Context: #${String(id)} is not an active profile row.` };
-        }
-        if (!wantsApply(tokenize(rawInput))) {
-            return {
-                kind: 'success',
-                text: `Magic Context: would retire #${String(id)} — "${row.content.slice(0, 120)}".\n`
-                    + 'It would stop being injected in every session, and the removal forces a HARD baseline rebuild '
-                    + '(the profile digest covers active rows). Add --yes to apply.',
-            };
-        }
-        if (!profileWriter.retireProfile(id, now)) {
-            return { kind: 'error', text: `Magic Context: #${String(id)} could not be retired; nothing changed.` };
-        }
-        return {
-            kind: 'success',
-            text: `Magic Context: #${String(id)} retired. It no longer renders in <user-profile>, and every session `
-                + 'that had it folds its baseline on the next pass (the digest covers active rows). The row itself is '
-                + 'kept as dismissed — it is the record of what was once injected.',
-        };
-    }
-    return { kind: 'error', text: `Magic Context: unknown /ctx-profile subcommand '${verb}'. Usage: ${PROFILE_USAGE}` };
-}
-// ── /ctx-global ────────────────────────────────────────────────────────────
-/** Display label for a domain kind (2026-10-25 naming: the axis is AUDIENCE — machine=全局, org=工作). */
-function kindLabel(kind) {
-    if (kind === 'machine')
-        return '全局';
-    if (kind === 'org')
-        return '工作';
-    if (kind === 'user')
-        return '画像';
-    return kind;
-}
-function domainLine(store, domain) {
-    const members = store.listDomainMembers(domain.domainId).length;
-    return `- ${domain.domainId} [${domain.kind}·${kindLabel(domain.kind)}] ${domain.enabled ? 'enabled' : 'disabled'}`
-        + ` · budget ${String(domain.budgetTokens)} tok · cap ${String(domain.cap)}`
-        + ` · shares ${domain.shareCategories.length === 0 ? '(nothing)' : domain.shareCategories.join(', ')}`
-        + ` · ${String(members)} member(s)`;
-}
-export function planGlobalCommand(store, rawInput, now, corpusDbPath, publisher) {
-    // Flags must be read from the RAW tokens: stripFlags removes every
-    // `-`-prefixed token, so any flag looked up in `tokens` is invisible (the
-    // 2026-10-12 promote --domain bug: the flag was always "absent", so every
-    // promotion silently landed in org — even one naming an unknown domain).
-    const rawTokens = tokenize(rawInput);
-    const tokens = stripFlags(rawTokens);
-    const verb = tokens[0] ?? 'domains';
-    if (verb === 'domains') {
-        const domains = store.listDomains();
-        if (domains.length === 0) {
-            return {
-                kind: 'success',
-                text: 'Magic Context: no global domain is defined yet. '
-                    + 'Create one with: /ctx-global create <domain-id> --kind org|machine '
-                    + '(e.g. /ctx-global create dir:global:org --kind org), then add members with: /ctx-global add <domain-id> <identity>',
-            };
-        }
-        return { kind: 'success', text: ['Global domains:', ...domains.map(domain => domainLine(store, domain))].join('\n') };
-    }
-    if (verb === 'create') {
-        const rawTokens = tokenize(rawInput);
-        const domainId = tokens[1];
-        const kind = flagValue(rawTokens, '--kind') ?? 'org';
-        if (domainId === undefined) {
-            return { kind: 'error', text: `Magic Context: /ctx-global create needs <domain>. Usage: ${GLOBAL_USAGE}` };
-        }
-        if (!isDomainKind(kind)) {
-            return { kind: 'error', text: `Magic Context: --kind must be org (工作域, curated work projects) or machine (全局域, every project on this machine) — got '${kind}'. Usage: ${GLOBAL_USAGE}` };
-        }
-        if (store.getDomain(domainId) !== undefined) {
-            return { kind: 'error', text: `Magic Context: domain '${domainId}' already exists.` };
-        }
-        // Born with the derived defaults, exactly like the machine bootstrap
-        // (machine-domain.ts) — the operator can edit budget/cap/allowlist later.
-        store.upsertDomain({
-            domainId,
-            kind,
-            enabled: true,
-            budgetTokens: DEFAULT_DOMAIN_BUDGET_TOKENS[kind],
-            cap: defaultDomainCap(kind),
-            shareCategories: [...DEFAULT_SHARE_CATEGORIES],
-        }, now);
-        return { kind: 'success', text: `Magic Context: domain ${domainId} (kind ${kind}) created and enabled. Add members with: /ctx-global add ${domainId} <identity>` };
-    }
-    if (verb === 'members') {
-        const domainId = tokens[1];
-        const rows = store.listDomainMembers(domainId);
-        if (rows.length === 0) {
-            return { kind: 'success', text: domainId === undefined ? 'Magic Context: no domain members.' : `Magic Context: ${domainId} has no members (it activates nothing).` };
-        }
-        return { kind: 'success', text: rows.map(row => `- ${row.identity} (${row.domainId})`).join('\n') };
-    }
-    if (verb === 'add') {
-        const domainId = tokens[1];
-        const identity = tokens[2];
-        if (domainId === undefined || identity === undefined) {
-            return { kind: 'error', text: `Magic Context: /ctx-global add needs <domain> <identity>. Usage: ${GLOBAL_USAGE}` };
-        }
-        if (store.getDomain(domainId) === undefined) {
-            return { kind: 'error', text: `Magic Context: unknown domain '${domainId}'.` };
-        }
-        store.addDomainMember(domainId, identity, now);
-        return { kind: 'success', text: `Magic Context: ${identity} now activates ${domainId}.` };
-    }
-    if (verb === 'remove') {
-        const domainId = tokens[1];
-        const identity = tokens[2];
-        if (domainId === undefined || identity === undefined) {
-            return { kind: 'error', text: `Magic Context: /ctx-global remove needs <domain> <identity>. Usage: ${GLOBAL_USAGE}` };
-        }
-        if (!wantsApply(tokenize(rawInput))) {
-            return { kind: 'success', text: `Magic Context: would remove ${identity} from ${domainId} (add --yes to apply).` };
-        }
-        store.removeDomainMember(domainId, identity);
-        return { kind: 'success', text: `Magic Context: ${identity} no longer activates ${domainId}.` };
-    }
-    if (verb === 'enable' || verb === 'disable') {
-        const domainId = tokens[1];
-        if (domainId === undefined) {
-            return { kind: 'error', text: `Magic Context: /ctx-global ${verb} needs a domain. Usage: ${GLOBAL_USAGE}` };
-        }
-        const enabled = verb === 'enable';
-        if (!enabled && !wantsApply(tokenize(rawInput))) {
-            return { kind: 'success', text: `Magic Context: would disable ${domainId} (add --yes to apply).` };
-        }
-        if (store.getDomain(domainId) === undefined) {
-            return { kind: 'error', text: `Magic Context: unknown domain '${domainId}'.` };
-        }
-        store.setDomainEnabled(domainId, enabled, now);
-        return {
-            kind: 'success',
-            text: enabled
-                ? `Magic Context: ${domainId} enabled. Its rows become visible to its members on the next pass.`
-                : `Magic Context: ${domainId} disabled. Its rows stop being injected; existing memories stay in the shared store.`,
-        };
-    }
-    if (verb === 'detect') {
-        if (corpusDbPath === undefined) {
-            return { kind: 'error', text: 'Magic Context: the shared store is unavailable, so recurrence cannot be scanned.' };
-        }
-        const scan = detectGlobalCandidates(store, { corpusDbPath, now });
-        if (scan.hashes === 0) {
-            return {
-                kind: 'success',
-                text: 'Magic Context: recurrence scan found 0 cross-project candidates.\n'
-                    + 'That is the expected result on this corpus (measured 2026-10-10: 1292 active rows across 33 projects, '
-                    + 'no normalized hash shared by two projects) — historian facts are project-bound. '
-                    + 'Use /ctx-global promote <memoryId> for human-judged work-domain knowledge.',
-            };
-        }
-        return {
-            kind: 'success',
-            text: `Magic Context: recurrence scan found ${String(scan.hashes)} hash(es); upserted ${String(scan.upserted)}, `
-                + `skipped ${String(scan.blocked)} credential-shaped.`,
-        };
-    }
-    if (verb === 'promote') {
-        const memoryId = parseId(tokens[1]);
-        if (memoryId === undefined) {
-            return { kind: 'error', text: `Magic Context: /ctx-global promote needs a memory id. Usage: ${GLOBAL_USAGE}` };
-        }
-        if (corpusDbPath === undefined) {
-            return { kind: 'error', text: 'Magic Context: the shared store is unavailable, so a memory cannot be read.' };
-        }
-        const domainFlag = rawTokens.indexOf('--domain');
-        const domainValue = domainFlag >= 0 ? rawTokens[domainFlag + 1] : undefined;
-        // A flag without a value (or followed by another flag) must FAIL, not fall
-        // back to org: a silent fallback publishes human-judged knowledge to the
-        // wrong audience, which is the one mistake this flag exists to prevent.
-        if (domainFlag >= 0 && (domainValue === undefined || domainValue.startsWith('-'))) {
-            return { kind: 'error', text: `Magic Context: --domain needs a value. Usage: ${GLOBAL_USAGE}` };
-        }
-        const domainId = domainValue ?? ORG_DOMAIN_ID;
-        const promoted = promoteMemoryToCandidate(store, {
-            corpusDbPath,
-            memoryId,
-            domainId,
-            now,
-        });
-        if (!promoted.ok)
-            return { kind: 'error', text: `Magic Context: ${promoted.error}` };
-        const candidate = promoted.candidate;
-        return {
-            kind: 'success',
-            text: `Magic Context: memory #${String(memoryId)} is now candidate #${String(candidate.id)} for ${domainId}`
-                + `${candidate.category === undefined ? '' : ` (category ${candidate.category})`}.\n`
-                + `It is human-judged, so /ctx-global approve ${String(candidate.id)} does not need the recurrence gate.\n`
-                + `Instant path next time: ctx_memory action=promote (memory_id + domain) enqueues AND raises the card.`,
-        };
-    }
-    if (verb === 'candidates') {
-        const domainId = tokens[1];
-        const rows = store.listGlobalCandidates({ state: 'pending', ...domainId === undefined ? {} : { domainId } });
-        if (rows.length === 0)
-            return { kind: 'success', text: 'Magic Context: no pending global candidate.' };
-        return {
-            kind: 'success',
-            text: rows.map(row => `- #${String(row.id)} [${row.domainId}] observed by ${String(row.distinctIdentities)} project(s), `
-                + `${String(row.observationCount)} time(s): ${row.content.replace(/\s+/g, ' ').slice(0, 100)}`).join('\n'),
-        };
-    }
-    if (verb === 'approve' || verb === 'reject-candidate') {
-        const id = parseId(tokens[1]);
-        if (id === undefined) {
-            return { kind: 'error', text: `Magic Context: /ctx-global ${verb} needs a candidate id. Usage: ${GLOBAL_USAGE}` };
-        }
-        const apply = wantsApply(tokenize(rawInput));
-        const row = store.getGlobalCandidate(id);
-        if (row === undefined)
-            return { kind: 'error', text: `Magic Context: no candidate #${String(id)}.` };
-        if (verb === 'reject-candidate') {
-            if (!apply) {
-                return { kind: 'success', text: `Magic Context: would reject candidate #${String(id)} (add --yes to apply).` };
-            }
-            store.setGlobalCandidateState(id, 'rejected', now);
-            return { kind: 'success', text: `Magic Context: candidate #${String(id)} rejected.` };
-        }
-        // `approve` IS the publish: the state flag alone made a candidate that was
-        // "approved" and visible to nobody. The gate runs before the preview and
-        // before the apply, so the two can never disagree about publishability.
-        const gate = approvalGate(store, row, publisher);
-        if (!gate.ok)
-            return { kind: 'error', text: `Magic Context: ${gate.error}` };
-        if (!apply) {
-            return {
-                kind: 'success',
-                text: `Magic Context: would publish candidate #${String(id)} as ${row.domainId} [${row.category}] `
-                    + `— every peer project would see it. Add --yes to publish.`,
-            };
-        }
-        if (publisher === undefined) {
-            return {
-                kind: 'error',
-                text: 'Magic Context: the shared store is not writable right now (no memory writer), so the candidate '
-                    + 'was left pending rather than marked approved with nothing published.',
-            };
-        }
-        const published = publishGlobalCandidate(store, { candidateId: id, writer: publisher, now });
-        if (!published.ok)
-            return { kind: 'error', text: `Magic Context: ${published.error}` };
-        return {
-            kind: 'success',
-            text: `Magic Context: candidate #${String(id)} ${published.created ? 'published' : 'was already published'} `
-                + `as memory #${String(published.memoryId)} under ${published.identity} [${published.category}]`
-                + `${published.created ? '' : ' (its recurrence counter moved instead of a duplicate row)'}; `
-                + 'every member project sees it now.',
-        };
-    }
-    return { kind: 'error', text: `Magic Context: unknown /ctx-global subcommand '${verb}'. Usage: ${GLOBAL_USAGE}` };
-}
-// ── registration ───────────────────────────────────────────────────────────
-export function registerCtxProfileCommand(ctx, deps) {
-    const commands = ctx.get('commands');
-    if (commands === undefined) {
-        ctx.logger.warn('magic-context dsh adapter: commands service not mounted; /ctx-profile unavailable');
-        return;
-    }
-    commands.register({
-        name: 'ctx-profile',
-        description: 'Magic Context: answer the profile-confirmation queue (directive-shaped candidates need you).',
-        input: { hint: PROFILE_USAGE },
-        handler: invocation => planProfileCommand(deps.stores, invocation.rawInput, Date.now(), deps.profileWriter),
-    });
-}
-export function registerCtxGlobalCommand(ctx, deps) {
-    const commands = ctx.get('commands');
-    if (commands === undefined) {
-        ctx.logger.warn('magic-context dsh adapter: commands service not mounted; /ctx-global unavailable');
-        return;
-    }
-    commands.register({
-        name: 'ctx-global',
-        description: 'Magic Context: global domains — inspect, activate, and manage their membership.',
-        input: { hint: GLOBAL_USAGE },
-        handler: invocation => planGlobalCommand(deps.stores, invocation.rawInput, Date.now(), deps.corpusDbPath, deps.publisher),
-    });
-}

package/lib/dsh/compaction-engine.js

@@ -1,231 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { compactedPlaceholder, estimateTokens } from "../core/compartments.js";
-import { errText } from "../core/types.js";
-import { callHistorian } from "./historian.js";
-import { runManagementPass } from "./management-pass.js";
-import { compactCheckpointSource, enumerateSurfaceNodes, replaceSurfaceRange, syntheticNodeId, } from "./seams.js";
-function digestText(draft) {
-    const lines = [draft.tiers.p1];
-    if (draft.facts.length > 0) {
-        lines.push(`facts: ${draft.facts.map(fact => fact.category.length === 0 ? fact.content : `[${fact.category}] ${fact.content}`).join(' | ')}`);
-    }
-    if (draft.events.length > 0)
-        lines.push(`events: ${draft.events.join(' | ')}`);
-    return lines.join('\n');
-}
-/** Map an explicit surface span (first/last node seqs, either order) to nodes. */
-function regionNodes(nodes, start, end) {
-    const first = nodes.findIndex(node => node.seq === start);
-    const last = nodes.findIndex(node => node.seq === end);
-    if (first === -1 || last === -1)
-        return [];
-    const [from, to] = first <= last ? [first, last] : [last, first];
-    return nodes.slice(from, to + 1);
-}
-/**
- * Create and mount the adapter's CompactionEngine. Awaiting the returned
- * promise settles once the service is provided (or rejects when another
- * engine already owns `ctx.compaction`). The returned handle's `dispose()`
- * unmounts the engine, so the caller can follow a runtime toggle off.
- */
-export async function registerMagicCompactionEngine(ctx, deps) {
-    const base = deps.base;
-    /** The live policy at the use point (snapshot fallback: see deps). */
-    const policyNow = () => deps.activePolicy?.() ?? deps.policy;
-    /** The live generation route at the use point (snapshot fallback: see deps). */
-    const routeNow = () => {
-        const route = deps.activeRoute?.() ?? deps.route;
-        if (route === undefined)
-            return undefined;
-        const effort = deps.activeEffort?.()?.trim();
-        if (effort === undefined || effort === '' || route.reasoningEffort !== undefined)
-            return route;
-        return { ...route, reasoningEffort: effort };
-    };
-    const sessionOf = (agent) => {
-        const session = agent.session;
-        if (session === undefined)
-            throw new Error('compaction agent carries no session');
-        return session;
-    };
-    /** The manual checkpoint: summarize the span, then write the protocol. */
-    const writeCheckpoint = async (input) => {
-        if (deps.llm === undefined)
-            throw new Error('no LLM seam available for a manual compaction');
-        const sessionId = input.session.id;
-        const generationRoute = routeNow();
-        const systemSeq = enumerateSurfaceNodes(input.session).find(node => node.role === 'system')?.seq;
-        const draft = await callHistorian({
-            policy: policyNow(),
-            llm: deps.llm,
-            logger: deps.logger,
-            ...deps.journal === undefined ? {} : { journal: deps.journal },
-            ...generationRoute === undefined ? {} : { route: generationRoute },
-        }, {
-            sessionId,
-            session: input.session,
-            nodes: input.nodes,
-            trigger: 'manual',
-            ...generationRoute === undefined ? {} : { route: generationRoute },
-            ...input.signal === undefined ? {} : { signal: input.signal },
-            ...systemSeq === undefined ? {} : { systemSeq },
-        });
-        const compactionId = `mc-${randomUUID()}`;
-        const summary = [{
-                type: 'text',
-                text: `${compactedPlaceholder(0).replace('§C0§', '§checkpoint§')}\n${digestText(draft)}`,
-            }];
-        const shadowedSeqs = input.nodes.map(node => node.seq);
-        const first = input.nodes[0];
-        const last = input.nodes[input.nodes.length - 1];
-        const shadowedTokenCount = input.nodes.reduce((total, node) => total + estimateTokens(node.text), 0);
-        // `Session.append` accepts an options argument only for *surface* event
-        // types; `compaction/*` are not among them, so these appends take two.
-        const startEvent = input.session.append('compaction/start', {
-            compactionId,
-            ...input.sourceCommandId === undefined ? {} : { sourceCommandId: input.sourceCommandId },
-            turn: null,
-        });
-        const summaryEvent = input.session.append('compaction/summary', {
-            compactionId,
-            ...input.sourceCommandId === undefined ? {} : { sourceCommandId: input.sourceCommandId },
-            summary,
-            shadowedRange: { start: first.seq, end: last.seq },
-            shadowedSeqs,
-            shadowedTokenCount,
-            provider: generationRoute?.provider ?? 'unknown',
-            model: generationRoute?.model ?? 'unknown',
-            maxTokens: policyNow().historianMaxTokens,
-            rawOutput: summary,
-            llmStreamCall: true,
-        });
-        // The replacement is appended synchronously after its metering event —
-        // the shared shadow-price protocol the session documents.
-        replaceSurfaceRange(input.session, first.seq, last.seq, summary, shadowedSeqs, syntheticNodeId('mc-checkpoint'), compactCheckpointSource(compactionId, input.sourceCommandId));
-        const endEvent = input.session.append('compaction/end', {
-            compactionId,
-            ...input.sourceCommandId === undefined ? {} : { sourceCommandId: input.sourceCommandId },
-            turn: null,
-        });
-        deps.logger.info(`magic-context compaction: checkpoint over ${String(input.nodes.length)} nodes `
-            + `(~${String(shadowedTokenCount)} tokens, importance ${String(draft.importance)})`);
-        deps.journal?.info('engine', `manual checkpoint over ${String(input.nodes.length)} nodes (~${String(shadowedTokenCount)} tokens)`, {
-            action: 'checkpoint',
-            compactionId,
-            sourceCommandId: input.sourceCommandId,
-            nodes: input.nodes.length,
-            shadowedTokenCount,
-            importance: draft.importance,
-            startSeq: startEvent.seq,
-            endSeq: endEvent.seq,
-        }, sessionId);
-        return {
-            compactionId,
-            ...input.sourceCommandId === undefined ? {} : { sourceCommandId: input.sourceCommandId },
-            startSeq: startEvent.seq,
-            summarySeq: summaryEvent.seq,
-            endSeq: endEvent.seq,
-            summary,
-            shadowedRange: { start: first.seq, end: last.seq },
-            shadowedSeqs,
-            shadowedTokenCount,
-        };
-    };
-    const EngineClass = class MagicContextCompactionEngine extends base {
-        static inject = [];
-        constructor(engineCtx, config) {
-            super(engineCtx, config);
-        }
-        /** A stale engine (remounted composition) must no-op, never touch closed stores. */
-        usable() {
-            return deps.stores.closed !== true && deps.isDisposed?.() !== true;
-        }
-        /** The pressure path: reclaim, never a checkpoint (Magic Context's promise). */
-        async compactIfNeeded(agent) {
-            if (!this.usable())
-                return null;
-            const session = sessionOf(agent);
-            const sessionId = session.id;
-            try {
-                const generationRoute = routeNow();
-                runManagementPass({
-                    session,
-                    sessionId,
-                    stores: deps.stores,
-                    policy: policyNow(),
-                    logger: deps.logger,
-                    pass: { kind: 'execute', reason: 'execute-threshold' },
-                    pressure: undefined,
-                    ...deps.llm === undefined ? {} : {
-                        historian: {
-                            llm: deps.llm,
-                            ...generationRoute === undefined ? {} : { route: generationRoute },
-                        },
-                    },
-                });
-            }
-            catch (error) {
-                // A failing pass must never escape into the host's step: warn, record,
-                // and let the session continue (the next threshold still retries).
-                const detail = errText(error);
-                deps.logger.warn(`magic-context compaction: management pass failed (${detail}); session continues`);
-                deps.journal?.warn('engine', `management pass failed: ${detail}`, {
-                    action: 'pass-failed',
-                    sessionId,
-                }, sessionId);
-            }
-            return null;
-        }
-        /** `/compact`: the user asked, so a real checkpoint is written. */
-        async compactNow(agent, signal, sourceCommandId) {
-            if (!this.usable())
-                return null;
-            const session = sessionOf(agent);
-            const nodes = enumerateSurfaceNodes(session);
-            const range = selectManualRange(nodes, deps.stores, session.id, policyNow());
-            if (range.length === 0)
-                return null;
-            return writeCheckpoint({
-                session,
-                nodes: range,
-                ...sourceCommandId === undefined ? {} : { sourceCommandId },
-                signal,
-            });
-        }
-        async compactRegion(start, end, agent, signal) {
-            if (!this.usable())
-                throw new Error('compaction engine is shutting down');
-            const session = sessionOf(agent);
-            const nodes = regionNodes(enumerateSurfaceNodes(session), start, end);
-            if (nodes.length === 0)
-                throw new Error('compaction region contains no current surface nodes');
-            return writeCheckpoint({
-                session,
-                nodes,
-                ...signal === undefined ? {} : { signal },
-            });
-        }
-    };
-    return await ctx.plugin(EngineClass, {});
-}
-/** The manual range: the same eligibility rules, without the token gate. */
-function selectManualRange(nodes, stores, sessionId, policy) {
-    const covered = stores.coveredSeqs(sessionId);
-    const baselineNodeSeq = stores.baselineState(sessionId)?.nodeSeq;
-    const skippable = (node) => node.role === 'system'
-        || node.seq === baselineNodeSeq
-        || covered.has(node.seq)
-        || node.isPlaceholder
-        || /^\[(?:dropped|compacted|checkpoint) §/.test(node.text.trim().slice(0, 24))
-        || !node.hasText;
-    let start = 0;
-    while (start < nodes.length && skippable(nodes[start]))
-        start += 1;
-    if (start >= nodes.length)
-        return [];
-    let cut = Math.max(start, nodes.length - Math.max(0, policy.historianProtectedNodes));
-    while (cut > start && nodes[cut]?.role === 'tool')
-        cut -= 1;
-    const slice = nodes.slice(start, cut);
-    return slice.length >= Math.max(2, policy.historianMinNodes) ? slice : [];
-}

package/lib/dsh/config-switches.js

@@ -1,56 +0,0 @@
-import { liveBoolean, liveNumber } from "./volatile.js";
-import { vectorBackfillEnabled } from "./maintenance-wiring.js";
-/** Every tracked switch. Booleans alarm on `went-off`; the rest report changes. */
-export const SWITCH_KEYS = [
-    'write',
-    'autoPromote',
-    'embedBackfill',
-    'vectorBackfill',
-    'scoring',
-    'userRender',
-    'userCollect',
-    'userReview',
-    'machine',
-    'machineAutoStage',
-    'forceWaitMs',
-];
-/** The effective switch values for THIS mount, defaults already applied. */
-export function buildSwitchSnapshot(config) {
-    return {
-        write: liveBoolean(config.memory?.write, true),
-        autoPromote: liveBoolean(config.memory?.autoPromote, true),
-        embedBackfill: liveBoolean(config.memory?.embedBackfill, true),
-        vectorBackfill: vectorBackfillEnabled(config.memory),
-        scoring: liveBoolean(config.memory?.scoring?.enabled, true),
-        userRender: liveBoolean(config.memory?.global?.user?.render, true),
-        userCollect: liveBoolean(config.memory?.global?.user?.collect, true),
-        userReview: liveBoolean(config.memory?.global?.user?.review, true),
-        machine: liveBoolean(config.memory?.global?.machine?.enabled, true),
-        machineAutoStage: liveBoolean(config.memory?.global?.machine?.autoStage, true),
-        // liveNumber unwraps schemastery volatile references — a raw read
-        // serialized the reference object into the boot row (measured 12:31: the
-        // retired guard-mode switch arrived as {"get":"[depth]"}). The unwrapping
-        // rule still applies to every volatile field here.
-        forceWaitMs: liveNumber(config.policy?.forceWaitReadyMs, 0),
-    };
-}
-/** Classify the movement between two snapshots; identical values produce no rows. */
-export function diffSwitches(before, after) {
-    const rows = [];
-    for (const key of SWITCH_KEYS) {
-        // Snapshot values are only boolean | string | number by construction.
-        const was = before[key];
-        const now = after[key];
-        if (was === undefined || now === undefined || was === now)
-            continue;
-        if (typeof was === 'boolean' && typeof now === 'boolean') {
-            rows.push({ key, before: was, after: now, severity: was && !now ? 'went-off' : 'came-on' });
-        }
-        else {
-            rows.push({ key, before: was, after: now, severity: 'changed' });
-        }
-    }
-    return rows;
-}
-/** The meta-table key holding the JSON snapshot of the previous mount. */
-export const SWITCH_SNAPSHOT_META_KEY = 'switch_snapshot';