@latysh-development/monolith 0.0.0-stage → 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,28 @@
+/**
+ * @latysh-development/monolith — Public API surface
+ *
+ * This file is the package entrypoint. Exports grow here as Kernel modules
+ * are extracted from project instances into this package.
+ *
+ * Current state: Phase 6 — validate implemented; Scriptorium (Story 1.2) and
+ * Explicit Relationship Graph (Story 1.3) integrated.
+ * See Phase 7+ roadmap for Kernel extraction.
+ *
+ * Webway (the frequency-based "meaning linker" prototype from Story 1.1) was
+ * extracted into its own repository: https://github.com/Demion-L/webway —
+ * it was an independent research track with zero runtime coupling to
+ * Scriptorium/Graph, see docs/webway-v0.md for the historical record.
+ */
+export { MONOLITH_VERSION } from './version.js';
+export { runInit } from './init/index.js';
+export { compileMarkdownArtifact, isStructuralHeadingNoise } from './scriptorium/index.js';
+export { buildGraph, buildObjectIndex, resolveRef, makeRef, parseRef, isValidIdentifier } from './graph/index.js';
+export { createInitialState, CoordinatoriumError, StateCorruptedError, StateSchemaError, LockTimeoutError, MissionNotFoundError, InvalidTransitionError, ValidationError, readState, mutateState, projectTarget, trustedDirectoryTarget, startMission, listMissions, getMission, finishMission, } from './coordinatorium/index.js';
+// Safe writes — explicit write scope and publication states (SEC-001B.2, ADR-012)
+export { SafeWriteError } from './root/index.js';
+// Durable State — domain-neutral, crash-safe execution record for long-running agentic tasks (ADR-017).
+// Namespaced: its error taxonomy deliberately shares names (e.g. ValidationError) with Coordinatorium's.
+// EXPERIMENTAL. Security acceptance pending (see AGENTS.md → Durable State); the API may change in any alpha.
+export * as durable from './durable/index.js';
+// Manual Idea Capture (IDEA-001A) — deferred thoughts saved as Markdown under <monolithRoot>/memory/long-term/ideas/.
+export * as ideas from './ideas/index.js';

package/dist/init/index.d.ts

@@ -0,0 +1,12 @@
+import type { InitOptions } from './types.js';
+/**
+ * Thrown when `monolith init` would overwrite existing tracked files.
+ * Raised strictly before any write — see planScaffoldConflicts. Carries a
+ * non-zero exit via the CLI's top-level main().catch handler.
+ */
+export declare class InitConflictError extends Error {
+    readonly conflicts: string[];
+    constructor(conflicts: string[]);
+}
+export declare function runInit(options?: InitOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/init/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/init/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAK9C;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;gBAEjB,SAAS,EAAE,MAAM,EAAE;CAmBhC;AAED,wBAAsB,OAAO,CAAC,OAAO,GAAE,WAA0C,GAAG,OAAO,CAAC,IAAI,CAAC,CA+DhG"}

package/dist/init/index.js

@@ -0,0 +1,90 @@
+/* eslint-disable no-console */
+import { resolve } from 'path';
+import { promptProjectConfig } from './prompts.js';
+import { scaffoldInstance, planScaffoldConflicts } from './scaffold.js';
+import { reportWriteWarning } from '../root/index.js';
+const CONFLICT_LIST_LIMIT = 20;
+/**
+ * Thrown when `monolith init` would overwrite existing tracked files.
+ * Raised strictly before any write — see planScaffoldConflicts. Carries a
+ * non-zero exit via the CLI's top-level main().catch handler.
+ */
+export class InitConflictError extends Error {
+    conflicts;
+    constructor(conflicts) {
+        const shown = conflicts.slice(0, CONFLICT_LIST_LIMIT);
+        const more = conflicts.length - shown.length;
+        const list = shown.map((c) => `    - ${c}`).join('\n');
+        super(`Refusing to initialize: ${conflicts.length} existing or unsafe path(s) (already present, or a symlink / special file that must not be written through):\n` +
+            `${list}\n` +
+            (more > 0 ? `    ...and ${more} more\n` : '') +
+            '\n' +
+            '  monolith init always scaffolds the current working directory and never\n' +
+            '  overwrites existing tracked files (re-running it is not an upgrade/force\n' +
+            '  mechanism). --yes only skips interactive prompts for a clean directory;\n' +
+            '  it does not authorize overwriting existing data.\n' +
+            '  Remove, rename, or back up the conflicting file(s) yourself, or run init\n' +
+            '  in an empty directory, then re-run.');
+        this.name = 'InitConflictError';
+        this.conflicts = conflicts;
+    }
+}
+export async function runInit(options = { targetDir: process.cwd() }) {
+    const targetDir = resolve(options.targetDir);
+    console.log('  Initializing MONOLITH instance...');
+    console.log('');
+    let config;
+    if (options.yes) {
+        // Non-interactive: use all defaults
+        const { basename } = await import('path');
+        config = {
+            projectName: basename(targetDir),
+            language: 'typescript',
+            packageManager: 'pnpm',
+            aiTool: 'claude',
+            finalizationProtocol: 'finalize-story',
+            protocols: ['finalize-story', 'failure-memory-logging', 'governance-evaluation', 'integrity-verification'],
+            monolithRoot: '.monolith',
+        };
+        console.log(`  Project:  ${config.projectName} (defaults applied)`);
+        console.log('');
+    }
+    else {
+        config = await promptProjectConfig();
+    }
+    // Preflight: must run — and find zero conflicts — before any write, so a
+    // conflict is never discovered after half the instance has already been
+    // scaffolded (see LESSON-2026-0006 / TD-007).
+    const conflicts = planScaffoldConflicts(targetDir, config);
+    if (conflicts.length > 0) {
+        throw new InitConflictError(conflicts);
+    }
+    console.log('  Scaffolding instance...');
+    console.log('');
+    const result = await scaffoldInstance(targetDir, config);
+    for (const w of result.warnings)
+        reportWriteWarning(w);
+    console.log('');
+    console.log('  ✅ MONOLITH instance initialized!');
+    console.log('');
+    console.log(`  Project:       ${config.projectName}`);
+    console.log(`  Root:          ${config.monolithRoot}/`);
+    console.log(`  Files created: ${result.filesCreated}`);
+    console.log('');
+    const instructionFileMap = {
+        claude: 'CLAUDE.md',
+        cursor: '.cursorrules',
+        windsurf: '.windsurfrules',
+    };
+    const instructionFile = instructionFileMap[config.aiTool] ?? 'AGENTS.md';
+    console.log(`  AI tool:       ${config.aiTool} → ${instructionFile}`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    1. Edit ${instructionFile} — verify skill triggers and paths`);
+    console.log('    2. Edit AGENTS.md — add project description');
+    console.log(`    3. Edit ${config.monolithRoot}/context/maps/project-map.md — describe your structure`);
+    console.log(`    4. Edit ${config.monolithRoot}/context/maps/roadmap-index.md — add your phases`);
+    console.log(`    5. Edit ${config.monolithRoot}/protocols/governance/core-invariants.md — set Current Focus`);
+    console.log(`    6. Start first story: edit ${config.monolithRoot}/memory/working/active.md`);
+    console.log('');
+}

package/dist/init/prompts.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectConfig } from './types.js';
+export declare function promptProjectConfig(): Promise<ProjectConfig>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/init/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/init/prompts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA+BhD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,aAAa,CAAC,CAuClE"}

package/dist/init/prompts.js

@@ -0,0 +1,47 @@
+/* eslint-disable no-console */
+import { createInterface } from 'readline';
+import { basename } from 'path';
+function createPrompter() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (question, defaultValue) => new Promise((resolve) => {
+        const hint = defaultValue ? ` (${defaultValue})` : '';
+        rl.question(`  ${question}${hint}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+    const askChoice = (question, choices, defaultChoice) => new Promise((resolve) => {
+        const choiceStr = choices.map((c) => (c === defaultChoice ? `[${c}]` : c)).join(' | ');
+        rl.question(`  ${question} (${choiceStr}): `, (answer) => {
+            const trimmed = answer.trim().toLowerCase();
+            if (!trimmed)
+                return resolve(defaultChoice);
+            const match = choices.find((c) => c.toLowerCase() === trimmed);
+            resolve(match ?? defaultChoice);
+        });
+    });
+    return { ask, askChoice, close: () => rl.close() };
+}
+export async function promptProjectConfig() {
+    const p = createPrompter();
+    console.log('');
+    const projectName = await p.ask('Project name', basename(process.cwd()));
+    const language = await p.askChoice('Primary language', ['typescript', 'javascript', 'python', 'other'], 'typescript');
+    const packageManager = await p.askChoice('Package manager', ['pnpm', 'npm', 'yarn', 'other'], 'pnpm');
+    const aiTool = await p.askChoice('AI assistant tool', ['claude', 'cursor', 'windsurf', 'other'], 'claude');
+    p.close();
+    console.log('');
+    return {
+        projectName,
+        language,
+        packageManager,
+        aiTool,
+        finalizationProtocol: 'finalize-story',
+        protocols: [
+            'finalize-story',
+            'failure-memory-logging',
+            'governance-evaluation',
+            'integrity-verification',
+        ],
+        monolithRoot: '.monolith',
+    };
+}

package/dist/init/scaffold.d.ts

@@ -0,0 +1,29 @@
+import type { ProjectConfig } from './types.js';
+import { type WriteWarning } from '../root/index.js';
+export declare const TEMPLATES_ROOT: string;
+type Vars = Record<string, string>;
+export declare function substitute(content: string, vars: Vars): string;
+export interface ScaffoldResult {
+    filesCreated: number;
+    dirsCreated: string[];
+    /** Non-fatal write findings (e.g. best-effort platform). */
+    warnings: WriteWarning[];
+}
+/**
+ * Preflight: compute every tracked template target path scaffoldInstance
+ * would write, and return the ones that already exist on disk — or that cannot
+ * be written safely (a symlink, including a dangling one, at the target or in
+ * a parent component; a FIFO or other special file). Must be called — and
+ * found empty — before scaffoldInstance runs, so a conflict is caught before
+ * any file is written (no half-scaffolded instance). This is advice for a
+ * clean error message; the exclusive creation in scaffoldInstance is the
+ * authoritative check.
+ *
+ * `state.json` is intentionally excluded when it is a regular file:
+ * scaffoldInstance never overwrites it (mutable Coordinatorium runtime data,
+ * ADR-008), so its presence is not a conflict. A symlink there still is.
+ */
+export declare function planScaffoldConflicts(targetDir: string, config: ProjectConfig): string[];
+export declare function scaffoldInstance(targetDir: string, config: ProjectConfig): Promise<ScaffoldResult>;
+export {};
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/init/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../src/init/scaffold.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAQL,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAY1B,eAAO,MAAM,cAAc,QAAkE,CAAC;AAE9F,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEnC,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAE9D;AAgHD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAqCxF;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,cAAc,CAAC,CA4EzB"}

package/dist/init/scaffold.js

@@ -0,0 +1,208 @@
+/* eslint-disable no-console */
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, dirname, resolve, relative, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { BLOCK_IDS, blockBody, placeholderFor, renderBlock } from '../managed/index.js';
+import { SafeWriteError, createFile, openParent, probeTarget, projectBoundary, resolveMonolithRootValue, } from '../root/index.js';
+const INSTRUCTION_FILE_MAP = {
+    claude: 'CLAUDE.md',
+    cursor: '.cursorrules',
+    windsurf: '.windsurfrules',
+};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Works both from dist/init/ (compiled) and src/init/ (tsx)
+export const TEMPLATES_ROOT = resolve(__dirname, '..', '..', 'templates', 'default-instance');
+export function substitute(content, vars) {
+    return content.replace(/\{\{([A-Z_]+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+function stripTemplateSuffix(p) {
+    return p.endsWith('.template') ? p.slice(0, -'.template'.length) : p;
+}
+/** Documents follow the umask (as before); the runtime state file is owner-only. */
+function writeNew(w, targetPath, content, asState) {
+    const parent = openParent(w.boundary, dirname(targetPath), { create: true });
+    const outcome = createFile(parent, basename(targetPath), content, {
+        ...(asState ? { mode: 0o600 } : { mode: 0o666, exactMode: false }),
+        durability: 'file',
+    });
+    w.warnings.push(...outcome.warnings);
+    w.created++;
+}
+function copyTemplate(w, templatePath, targetPath, vars, asState = false) {
+    writeNew(w, targetPath, substitute(readFileSync(templatePath, 'utf8'), vars), asState);
+    w.templates++;
+}
+function walkDir(dir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            results.push(...walkDir(full));
+        }
+        else {
+            results.push(full);
+        }
+    }
+    return results;
+}
+function buildVars(config) {
+    const r = config.monolithRoot;
+    return {
+        PROJECT_NAME: config.projectName,
+        LANGUAGE: config.language,
+        PACKAGE_MANAGER: config.packageManager,
+        AI_TOOL: config.aiTool,
+        MONOLITH_ROOT: r,
+        FINALIZATION_PROTOCOL: config.finalizationProtocol,
+        PROTOCOLS_JSON: JSON.stringify(config.protocols, null, 2)
+            .split('\n')
+            .join('\n  '),
+        MISTAKE_ROOTS_JSON: JSON.stringify([`${r}/learning/mistakes`, `${r}/memory/errors`], null, 2)
+            .split('\n')
+            .join('\n  '),
+        DRIFT_LOG_PATH: `${r}/enforcement/drift-log.json`,
+        // Same managed blocks `monolith update` writes into existing instances.
+        ...Object.fromEntries(BLOCK_IDS.map((id) => [placeholderFor(id), renderBlock(id, blockBody(id, r)).replace(/\n$/, '')])),
+    };
+}
+// Relative to config.monolithRoot (`r`). Shared between createEmptyDirs
+// (what init writes) and planScaffoldConflicts (what init must refuse to
+// overwrite) so the two can never drift apart — see gitkeepTargets().
+const GITKEEP_DIRS = [
+    'memory/working/phases',
+    'memory/execution/traces',
+    'memory/long-term/ideas',
+    'protocols/engineering',
+    'learning/mistakes/architecture',
+    'learning/mistakes/dependencies',
+    'learning/mistakes/nonexistent-api',
+    'learning/mistakes/context-sync',
+    'learning/mistakes/workflow',
+    'learning/mistakes/typescript',
+    'learning/mistakes/documentation',
+];
+/** `.gitkeep` paths (relative to targetDir) that init creates for `r`. */
+function gitkeepTargets(r) {
+    return GITKEEP_DIRS.map((rel) => `${r}/${rel}/.gitkeep`);
+}
+function createEmptyDirs(w, targetRoot, r) {
+    for (const rel of GITKEEP_DIRS) {
+        const full = join(targetRoot, r, rel);
+        // An existing .gitkeep (possibly user-authored, non-empty) must never be
+        // overwritten. planScaffoldConflicts() is expected to have already
+        // refused the run in this case; this is the authoritative second guard:
+        // creation is exclusive, so an existing entry of any kind is an error.
+        writeNew(w, join(full, '.gitkeep'), '', false);
+    }
+}
+/**
+ * Preflight: compute every tracked template target path scaffoldInstance
+ * would write, and return the ones that already exist on disk — or that cannot
+ * be written safely (a symlink, including a dangling one, at the target or in
+ * a parent component; a FIFO or other special file). Must be called — and
+ * found empty — before scaffoldInstance runs, so a conflict is caught before
+ * any file is written (no half-scaffolded instance). This is advice for a
+ * clean error message; the exclusive creation in scaffoldInstance is the
+ * authoritative check.
+ *
+ * `state.json` is intentionally excluded when it is a regular file:
+ * scaffoldInstance never overwrites it (mutable Coordinatorium runtime data,
+ * ADR-008), so its presence is not a conflict. A symlink there still is.
+ */
+export function planScaffoldConflicts(targetDir, config) {
+    // SEC-001A: the programmatic API enforces the same root policy as the CLI.
+    const r = resolveMonolithRootValue(targetDir, config.monolithRoot).monolithRoot;
+    const conflicts = [];
+    const boundary = projectBoundary(targetDir);
+    const check = (targetPath, regularFileIsFine = false) => {
+        const probe = probeTarget(boundary, targetPath);
+        if (probe.state === 'free')
+            return;
+        if (probe.state === 'exists' && regularFileIsFine)
+            return;
+        const rel = relative(targetDir, probe.path);
+        if (!conflicts.includes(rel))
+            conflicts.push(rel);
+    };
+    const projectrootTemplates = join(TEMPLATES_ROOT, 'projectroot');
+    if (existsSync(projectrootTemplates)) {
+        for (const tplFile of walkDir(projectrootTemplates)) {
+            const relPath = relative(projectrootTemplates, tplFile);
+            check(join(targetDir, stripTemplateSuffix(relPath)));
+        }
+    }
+    const monolithTemplates = join(TEMPLATES_ROOT, 'monolith');
+    if (existsSync(monolithTemplates)) {
+        for (const tplFile of walkDir(monolithTemplates)) {
+            const relPath = relative(monolithTemplates, tplFile);
+            const strippedRelPath = stripTemplateSuffix(relPath);
+            check(join(targetDir, r, strippedRelPath), strippedRelPath === 'state.json');
+        }
+    }
+    const instructionFileName = INSTRUCTION_FILE_MAP[config.aiTool];
+    if (instructionFileName)
+        check(join(targetDir, instructionFileName));
+    for (const rel of gitkeepTargets(r))
+        check(join(targetDir, rel));
+    return conflicts;
+}
+export async function scaffoldInstance(targetDir, config) {
+    // SEC-001A: validate before any write; throws RootContainmentError.
+    const r = resolveMonolithRootValue(targetDir, config.monolithRoot).monolithRoot;
+    const vars = buildVars({ ...config, monolithRoot: r });
+    const dirsCreated = [];
+    // `targetDir` is the project root the user pointed init at (it must exist,
+    // as resolveMonolithRootValue already requires). Everything below it is checked.
+    const w = { boundary: projectBoundary(targetDir), warnings: [], created: 0, templates: 0 };
+    try {
+        // --- Project root files ---
+        const projectrootTemplates = join(TEMPLATES_ROOT, 'projectroot');
+        if (existsSync(projectrootTemplates)) {
+            for (const tplFile of walkDir(projectrootTemplates)) {
+                const relPath = relative(projectrootTemplates, tplFile);
+                copyTemplate(w, tplFile, join(targetDir, stripTemplateSuffix(relPath)), vars);
+            }
+        }
+        // --- Monolith instance files ---
+        const monolithTemplates = join(TEMPLATES_ROOT, 'monolith');
+        if (existsSync(monolithTemplates)) {
+            for (const tplFile of walkDir(monolithTemplates)) {
+                const relPath = relative(monolithTemplates, tplFile);
+                const strippedRelPath = stripTemplateSuffix(relPath);
+                const targetPath = join(targetDir, r, strippedRelPath);
+                const isState = strippedRelPath === 'state.json';
+                // Coordinatorium state (ADR-008) is mutable runtime data, not a
+                // document template — re-running init must never clobber missions
+                // an existing instance has already recorded. Only a regular file is
+                // left alone; a symlink or special file there is still refused.
+                if (isState && probeTarget(w.boundary, targetPath).state === 'exists')
+                    continue;
+                copyTemplate(w, tplFile, targetPath, vars, isState);
+            }
+        }
+        // --- AI tool instruction file (CLAUDE.md / .cursorrules / .windsurfrules) ---
+        const instructionFileName = INSTRUCTION_FILE_MAP[config.aiTool];
+        if (instructionFileName) {
+            const tplPath = join(TEMPLATES_ROOT, 'instruction', instructionFileName);
+            if (existsSync(tplPath))
+                copyTemplate(w, tplPath, join(targetDir, instructionFileName), vars);
+        }
+        // --- Empty dirs + .gitkeep ---
+        createEmptyDirs(w, targetDir, r);
+    }
+    catch (err) {
+        if (err instanceof SafeWriteError && w.created > 0) {
+            throw new SafeWriteError(`${err.message} ${w.created} file(s) had already been created before this failure; ` +
+                'init is not transactional and does not roll them back.', { code: err.code, phase: err.phase, publication: err.publication, path: err.path, tmp: err.tmp, cause: err.cause });
+        }
+        throw err;
+    }
+    // Track dirs created
+    dirsCreated.push(r, `${r}/memory`, `${r}/context`, `${r}/protocols`, `${r}/skills`, `${r}/governance`, `${r}/learning`, `${r}/tests`, `${r}/adr`);
+    console.log(`  ✓ ${w.templates} files generated`);
+    console.log(`  ✓ ${dirsCreated.length + 11} directories created`);
+    return { filesCreated: w.templates, dirsCreated, warnings: w.warnings };
+}

package/dist/init/types.d.ts

@@ -0,0 +1,14 @@
+export interface ProjectConfig {
+    projectName: string;
+    language: 'typescript' | 'javascript' | 'python' | 'other';
+    packageManager: 'pnpm' | 'npm' | 'yarn' | 'other';
+    aiTool: 'claude' | 'cursor' | 'windsurf' | 'other';
+    finalizationProtocol: string;
+    protocols: string[];
+    monolithRoot: string;
+}
+export interface InitOptions {
+    targetDir: string;
+    yes?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/init/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/init/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,YAAY,GAAG,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC3D,cAAc,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAClD,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC;IACnD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf"}

package/dist/init/types.js

@@ -0,0 +1 @@
+export {};

package/dist/managed/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Managed blocks (DX-UPDATE-003): the one mechanism by which `monolith init`
+ * and `monolith update` put MONOLITH-owned text into a file the user also owns
+ * (CLAUDE.md, AGENTS.md, routing-map, skills index) or into a MONOLITH-owned
+ * file the user may extend (`AGENT.md`).
+ *
+ *   <!-- monolith:begin <id> sha256=<16 hex of the body> -->
+ *   ...body...
+ *   <!-- monolith:end <id> -->
+ *
+ * The checksum is what makes a refresh safe without a stored template version:
+ * a block whose body still matches its own checksum was never edited, so it is
+ * ours to refresh; a block that does not match carries a user edit and is left
+ * alone (CONFLICT). Everything outside the markers is never read for meaning
+ * and never changed. Markers inside fenced code blocks are examples, not blocks.
+ * This is not a Markdown parser: it knows lines, fences and these markers.
+ */
+export declare const BLOCK_IDS: readonly ["bootstrap", "agent", "routing-idea", "index-idea"];
+export type BlockId = (typeof BLOCK_IDS)[number];
+/** `{{MANAGED_<ID>}}` placeholder name used by the init templates. */
+export declare function placeholderFor(id: BlockId): string;
+export declare function bodyHash(body: string): string;
+/** The body of a block for a given instance root. */
+export declare function blockBody(id: BlockId, monolithRoot: string): string;
+/** The block as it is written to a file (markers + body), ending in a newline. */
+export declare function renderBlock(id: BlockId, body: string, eol?: string): string;
+export type BlockState = {
+    state: 'absent';
+}
+/** Exactly one well-formed block whose body matches its checksum. `current`: also equals the template. */
+ | {
+    state: 'pristine';
+    current: boolean;
+    from: number;
+    to: number;
+    lines: string[];
+} | {
+    state: 'edited';
+    detail: string;
+} | {
+    state: 'malformed';
+    detail: string;
+};
+/** Classify `id` in `text` against the template body `desired`. */
+export declare function inspectBlock(text: string, id: BlockId, desired: string): BlockState;
+/** `text` plus the block, appended; every existing byte stays in place. */
+export declare function appendBlock(text: string, id: BlockId, body: string): string;
+/** `text` with only the lines of the block replaced. */
+export declare function refreshBlock(text: string, state: Extract<BlockState, {
+    state: 'pristine';
+}>, id: BlockId, body: string): string;
+export type Planned = {
+    ok: true;
+    content: string;
+} | {
+    ok: false;
+    detail: string;
+};
+/**
+ * `text` with the block appended, or the reason that is not safe. Safe means the
+ * result, read back by `inspectBlock`, shows exactly one well-formed, unedited
+ * block that equals the template, and every original byte is still in place.
+ * An unclosed code fence or HTML comment in `text` swallows the new markers (the next run would
+ * not see the block and append another), so it is refused up front.
+ */
+export declare function planAppend(text: string, id: BlockId, body: string): Planned;
+/** `text` with the block refreshed in place, or the reason that is not safe (see `planAppend`). */
+export declare function planRefresh(text: string, state: Extract<BlockState, {
+    state: 'pristine';
+}>, id: BlockId, body: string): Planned;
+/** Text with fenced code blocks and HTML comments removed: what an assistant reads as instructions. */
+export declare function prose(text: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/managed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/managed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAWH,eAAO,MAAM,SAAS,+DAAgE,CAAC;AACvF,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAMD,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,MAAM,CAGzE;AA8FD,MAAM,MAAM,UAAU,GAClB;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE;AACrB,0GAA0G;GACxG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAClF;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CAyBnF;AAMD,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI3E;AAED,wDAAwD;AACxD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAO/H;AAED,MAAM,MAAM,OAAO,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpF;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAW3E;AAED,mGAAmG;AACnG,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAM/H;AAQD,uGAAuG;AACvG,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI1C"}