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

package/dist/init/scaffold.js

@@ -0,0 +1,204 @@
+/* eslint-disable no-console */
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, dirname, resolve, relative, basename } from 'path';
+import { fileURLToPath } from 'url';
+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)
+const TEMPLATES_ROOT = resolve(__dirname, '..', '..', 'templates', 'default-instance');
+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`,
+    };
+}
+// 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',
+    '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/readmodel/dashboard.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `readDashboardModel(projectRoot)` — builds the DashboardReadModel.
+ *
+ * Contract:
+ *  - `projectRoot` is supplied by the embedding process (fixed at startup),
+ *    never by a request. The set of files read is closed (see SourceId).
+ *  - Strictly read-only and synchronous: no write, no lock, no `mutateState`,
+ *    no `validate`, no `import()` of project code, no network. Nothing is
+ *    cached; every call re-reads.
+ *  - Never throws. Failures become SourceReport / ReadNote data.
+ *  - Deterministic: same files ⇒ deep-equal result; no timestamps.
+ *
+ * Containment (G1): the instance root is resolved with `resolveMonolithRoot`
+ * (ADR-009) and every file is read with `readProjectFile`, which realpath-checks
+ * each path component against the real project root and then performs the
+ * bounded, non-blocking read of SEC-001B.1. `readState` is deliberately NOT
+ * used: it does not check containment. Check-then-use races are NOT closed by
+ * Core (SEC-001B) and are therefore not closed here.
+ *
+ * Every source goes through `readProjectFile` (ADR-014): no symlink in any
+ * component, one hard link, regular file, absolute boundary, never the cwd.
+ * This module adds no filesystem checks of its own; it only interprets Core's
+ * typed result (`FILE_CODE_MAP`). Threat model (ADR-013): TM-A supported with
+ * limitations, TM-B partially supported, TM-C (concurrent mutation) NOT supported.
+ */
+import { type ProjectFileErrorCode } from '../root/index.js';
+import type { DashboardReadModel, SourceErrorCode, SourceStatus } from './types.js';
+export declare const ROADMAP_REL = "context/maps/roadmap-index.md";
+/** Protective ceiling, like the other SEC-001B.1 limits — not a content policy. */
+export declare const MAX_ROADMAP_BYTES: number;
+/**
+ * Exhaustive over Core's `ProjectFileErrorCode`: a new Core code is a compile
+ * error here until it is mapped. The status of a security violation is NOT
+ * decided here — `sourceFailure` takes it from Core's `isReadSecurityViolation`,
+ * so the UI keeps no second classification of filesystem security. The
+ * 'forbidden' entries only document that and are checked against Core in tests.
+ */
+export declare const FILE_CODE_MAP: Readonly<Record<ProjectFileErrorCode, readonly [SourceStatus, SourceErrorCode]>>;
+export declare function readDashboardModel(projectRoot: string): DashboardReadModel;
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/readmodel/dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard.d.ts","sourceRoot":"","sources":["../../src/readmodel/dashboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAQL,KAAK,oBAAoB,EAE1B,MAAM,kBAAkB,CAAC;AAS1B,OAAO,KAAK,EAGV,kBAAkB,EAKlB,eAAe,EAGf,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,WAAW,kCAAkC,CAAC;AAC3D,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,QAAa,CAAC;AAS5C;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,oBAAoB,EAAE,SAAS,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC,CAa1G,CAAC;AA+LF,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,CAQ1E"}

package/dist/readmodel/dashboard.js

@@ -0,0 +1,236 @@
+/**
+ * `readDashboardModel(projectRoot)` — builds the DashboardReadModel.
+ *
+ * Contract:
+ *  - `projectRoot` is supplied by the embedding process (fixed at startup),
+ *    never by a request. The set of files read is closed (see SourceId).
+ *  - Strictly read-only and synchronous: no write, no lock, no `mutateState`,
+ *    no `validate`, no `import()` of project code, no network. Nothing is
+ *    cached; every call re-reads.
+ *  - Never throws. Failures become SourceReport / ReadNote data.
+ *  - Deterministic: same files ⇒ deep-equal result; no timestamps.
+ *
+ * Containment (G1): the instance root is resolved with `resolveMonolithRoot`
+ * (ADR-009) and every file is read with `readProjectFile`, which realpath-checks
+ * each path component against the real project root and then performs the
+ * bounded, non-blocking read of SEC-001B.1. `readState` is deliberately NOT
+ * used: it does not check containment. Check-then-use races are NOT closed by
+ * Core (SEC-001B) and are therefore not closed here.
+ *
+ * Every source goes through `readProjectFile` (ADR-014): no symlink in any
+ * component, one hard link, regular file, absolute boundary, never the cwd.
+ * This module adds no filesystem checks of its own; it only interprets Core's
+ * typed result (`FILE_CODE_MAP`). Threat model (ADR-013): TM-A supported with
+ * limitations, TM-B partially supported, TM-C (concurrent mutation) NOT supported.
+ */
+import { MAX_STATE_BYTES, validateState } from '../coordinatorium/index.js';
+import { CONFIG_FILE_NAME, MAX_PROJECT_FILE_BYTES, isReadSecurityViolation, RootContainmentError, readProjectFile, resolveMonolithRoot, } from '../root/index.js';
+import { MAX_ACTIVE_CONTEXT_BYTES } from '../brief/collect.js';
+import { ACTIVE_MD_REL } from '../brief/constants.js';
+import { extractCurrentStory } from '../brief/story.js';
+import { hasCheckpointOrderMismatch, selectActiveMissions, selectLatestCheckpoint, } from '../brief/selectors.js';
+export const ROADMAP_REL = 'context/maps/roadmap-index.md';
+/** Protective ceiling, like the other SEC-001B.1 limits — not a content policy. */
+export const MAX_ROADMAP_BYTES = 256 * 1024;
+const CHANGED_RETRIES = 3;
+/**
+ * Exhaustive over Core's `ProjectFileErrorCode`: a new Core code is a compile
+ * error here until it is mapped. The status of a security violation is NOT
+ * decided here — `sourceFailure` takes it from Core's `isReadSecurityViolation`,
+ * so the UI keeps no second classification of filesystem security. The
+ * 'forbidden' entries only document that and are checked against Core in tests.
+ */
+export const FILE_CODE_MAP = {
+    FILE_MISSING: ['absent', 'SOURCE_ABSENT'],
+    FILE_OUTSIDE_PROJECT: ['forbidden', 'SOURCE_OUTSIDE_PROJECT'],
+    FILE_UNRESOLVABLE: ['unreadable', 'SOURCE_UNRESOLVABLE'],
+    FILE_NOT_REGULAR: ['forbidden', 'SOURCE_NOT_REGULAR'],
+    FILE_EMPTY: ['corrupt', 'SOURCE_EMPTY'],
+    FILE_TOO_LARGE: ['unreadable', 'SOURCE_TOO_LARGE'],
+    FILE_CHANGED: ['unreadable', 'SOURCE_CHANGED'],
+    FILE_UNREADABLE: ['unreadable', 'SOURCE_UNREADABLE'],
+    FILE_SYMLINK: ['forbidden', 'SOURCE_SYMLINK'],
+    FILE_HARDLINKED: ['forbidden', 'SOURCE_HARDLINKED'],
+    READ_BOUNDARY_INVALID: ['forbidden', 'SOURCE_BOUNDARY_INVALID'],
+    READ_UNSUPPORTED_PLATFORM: ['forbidden', 'SOURCE_UNSUPPORTED_PLATFORM'],
+};
+/** Never maps a security violation to anything but 'forbidden'; no default for unknown codes. */
+function sourceFailure(code) {
+    const [status, sourceCode] = FILE_CODE_MAP[code];
+    return [isReadSecurityViolation(code) ? 'forbidden' : status, sourceCode];
+}
+function report(id, path, status, code) {
+    return { id, path, status, code };
+}
+function withStatus(r, status, code) {
+    return { ...r, status, code };
+}
+/** One contained, bounded read of a fixed project-relative path. */
+function load(projectRoot, id, relPath, maxBytes) {
+    try {
+        let read = readProjectFile(projectRoot, relPath, { maxBytes, allowEmpty: true });
+        // A rename-based writer replacing the file under us is normal, not a fault.
+        for (let i = 1; i < CHANGED_RETRIES && !read.ok && read.code === 'FILE_CHANGED'; i++) {
+            read = readProjectFile(projectRoot, relPath, { maxBytes, allowEmpty: true });
+        }
+        if (read.ok)
+            return { report: report(id, relPath, 'available', null), content: read.content };
+        const [status, code] = sourceFailure(read.code);
+        return { report: report(id, relPath, status, code), content: null };
+    }
+    catch {
+        return { report: report(id, relPath, 'unreadable', 'INTERNAL'), content: null };
+    }
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function loadConfig(projectRoot) {
+    const loaded = load(projectRoot, 'config', CONFIG_FILE_NAME, MAX_PROJECT_FILE_BYTES);
+    if (loaded.report.status === 'absent')
+        return { report: loaded.report, read: { status: 'absent' }, name: null };
+    if (loaded.content === null) {
+        return { report: loaded.report, read: null, name: null };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(loaded.content);
+    }
+    catch {
+        return { report: withStatus(loaded.report, 'corrupt', 'CONFIG_INVALID'), read: null, name: null };
+    }
+    if (!isPlainObject(parsed)) {
+        return { report: withStatus(loaded.report, 'corrupt', 'CONFIG_INVALID'), read: null, name: null };
+    }
+    const project = parsed.project;
+    const rawName = isPlainObject(project) ? project.name : undefined;
+    const name = typeof rawName === 'string' && rawName.length > 0 ? rawName : null;
+    return { report: loaded.report, read: { status: 'ok', cfg: parsed }, name };
+}
+function loadState(projectRoot, root) {
+    const loaded = load(projectRoot, 'state', `${root.monolithRoot}/state.json`, MAX_STATE_BYTES);
+    if (loaded.content === null)
+        return { report: loaded.report, state: null, schemaVersionOnDisk: null };
+    const corrupt = (code) => ({
+        report: withStatus(loaded.report, 'corrupt', code),
+        state: null,
+        schemaVersionOnDisk: null,
+    });
+    if (loaded.content.trim() === '')
+        return corrupt('SOURCE_EMPTY');
+    let parsed;
+    try {
+        parsed = JSON.parse(loaded.content);
+    }
+    catch {
+        return corrupt('PARSE_ERROR');
+    }
+    try {
+        const state = validateState(parsed);
+        const onDisk = isPlainObject(parsed) && typeof parsed.schemaVersion === 'number' ? parsed.schemaVersion : null;
+        return { report: loaded.report, state, schemaVersionOnDisk: onDisk };
+    }
+    catch {
+        return corrupt('SCHEMA_INVALID');
+    }
+}
+function section(data, sources) {
+    return { data, sources };
+}
+/** Root could not be trusted: nothing below it is read (fail closed, never a default fallback). */
+function unreadableModel(config, rootCode = 'ROOT_INVALID') {
+    const refused = (id) => report(id, null, 'forbidden', rootCode);
+    const state = refused('state');
+    const story = refused('activeStory');
+    const roadmap = refused('roadmap');
+    return {
+        projectOverview: section(null, [config, state, story]),
+        currentMissions: section(null, [state]),
+        checkpoints: section(null, [state]),
+        roadmap: section(null, [roadmap]),
+        diagnostics: { validation: 'NOT_PERFORMED', sources: [config, state, story, roadmap], notes: [] },
+    };
+}
+function buildModel(projectRoot) {
+    const config = loadConfig(projectRoot);
+    if (config.read === null)
+        return unreadableModel(config.report);
+    let root;
+    try {
+        root = resolveMonolithRoot(projectRoot, config.read);
+    }
+    catch (err) {
+        if (err instanceof RootContainmentError)
+            return unreadableModel(config.report);
+        throw err;
+    }
+    const notes = [];
+    const stateResult = loadState(projectRoot, root);
+    const storyLoaded = load(projectRoot, 'activeStory', `${root.monolithRoot}/${ACTIVE_MD_REL}`, MAX_ACTIVE_CONTEXT_BYTES);
+    const roadmapLoaded = load(projectRoot, 'roadmap', `${root.monolithRoot}/${ROADMAP_REL}`, MAX_ROADMAP_BYTES);
+    // An absent state.json means "no missions ever recorded", exactly like `brief`.
+    const stateUsable = stateResult.report.status === 'available' || stateResult.report.status === 'absent';
+    const state = stateResult.state;
+    const missions = state ? Object.values(state.tactical.missions) : [];
+    const active = state ? selectActiveMissions(state) : [];
+    if (stateResult.schemaVersionOnDisk === 1)
+        notes.push({ code: 'STATE_LEGACY_SCHEMA_MIGRATED', severity: 'info' });
+    if (active.length > 1)
+        notes.push({ code: 'MULTIPLE_ACTIVE_MISSIONS', severity: 'info' });
+    let currentStory = null;
+    if (storyLoaded.content !== null) {
+        const extraction = extractCurrentStory(storyLoaded.content);
+        if (extraction.hasCurrentStorySection && extraction.excerpt !== null && extraction.lineRange !== null) {
+            currentStory = { excerpt: extraction.excerpt, lineRange: extraction.lineRange };
+        }
+        else {
+            notes.push({ code: 'ACTIVE_MD_NO_CURRENT_STORY', severity: 'info' });
+        }
+    }
+    const overview = {
+        name: config.name,
+        monolithRoot: root.monolithRoot,
+        monolithRootSource: root.source,
+        stateSchemaVersionOnDisk: stateResult.schemaVersionOnDisk,
+        stateRevision: state && stateResult.report.status === 'available' ? state.revision : null,
+        activeMissionCount: stateUsable ? active.length : null,
+        finishedMissionCount: stateUsable ? missions.length - active.length : null,
+        currentStory,
+    };
+    const currentMissions = stateUsable ? { active } : null;
+    let checkpoints = null;
+    if (state !== null || stateResult.report.status === 'absent') {
+        const all = state ? Object.values(state.tactical.checkpoints) : [];
+        checkpoints = {
+            byActiveMission: active.map((m) => {
+                const latest = state ? selectLatestCheckpoint(state, m.id) : null;
+                if (state && latest && hasCheckpointOrderMismatch(state, m.id, latest)) {
+                    notes.push({ code: 'CHECKPOINT_ORDER_MISMATCH', severity: 'info' });
+                }
+                return { missionId: m.id, count: all.filter((c) => c.missionId === m.id).length, latest };
+            }),
+        };
+    }
+    const roadmap = roadmapLoaded.content === null ? null : { text: roadmapLoaded.content };
+    return {
+        projectOverview: section(overview, [config.report, stateResult.report, storyLoaded.report]),
+        currentMissions: section(currentMissions, [stateResult.report]),
+        checkpoints: section(checkpoints, [stateResult.report]),
+        roadmap: section(roadmap, [roadmapLoaded.report]),
+        diagnostics: {
+            validation: 'NOT_PERFORMED',
+            sources: [config.report, stateResult.report, storyLoaded.report, roadmapLoaded.report],
+            notes,
+        },
+    };
+}
+export function readDashboardModel(projectRoot) {
+    try {
+        return buildModel(projectRoot);
+    }
+    catch {
+        // Unexpected fault: report it as data, without any message or path.
+        const internal = report('config', null, 'unreadable', 'INTERNAL');
+        return unreadableModel(internal, 'INTERNAL');
+    }
+}

package/dist/readmodel/index.d.ts

@@ -0,0 +1,3 @@
+export { readDashboardModel, ROADMAP_REL, MAX_ROADMAP_BYTES } from './dashboard.js';
+export type { CheckpointsData, CurrentMissions, DashboardReadModel, MissionCheckpoints, NoteCode, ProjectOverview, ReadDiagnostics, ReadNote, RoadmapData, Section, SourceErrorCode, SourceId, SourceReport, SourceStatus, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/readmodel/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACpF,YAAY,EACV,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,QAAQ,EACR,WAAW,EACX,OAAO,EACP,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/readmodel/index.js

@@ -0,0 +1 @@
+export { readDashboardModel, ROADMAP_REL, MAX_ROADMAP_BYTES } from './dashboard.js';

package/dist/readmodel/types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Typed Read Model for Mission Control (UI-001B.1, ADR-010).
+ *
+ * A pure, read-only projection of data MONOLITH Core already owns. It adds no
+ * persistent schema and no source of truth: every field is copied from, or
+ * counted over, an existing artifact (`monolith.config.json`, `state.json`,
+ * `active.md`, `roadmap-index.md`).
+ *
+ * Errors are DATA, not text: only fixed enum codes and project-relative paths
+ * cross this boundary. No absolute path, no exception message and no file
+ * excerpt other than the explicit content fields below ever appears in a
+ * diagnostic, so the DTO is safe to serialize over HTTP later (G2 still gates
+ * that).
+ */
+import type { Checkpoint, Mission } from '../coordinatorium/types.js';
+/** The fixed, closed set of files this model reads. */
+export type SourceId = 'config' | 'state' | 'activeStory' | 'roadmap';
+/**
+ * - available: read and (where applicable) parsed successfully
+ * - absent:    the file does not exist (a legitimate state for a fresh project)
+ * - corrupt:   the file was read but its content is unusable
+ * - forbidden: reading was refused by a security boundary
+ * - unreadable: the file exists inside the boundary but could not be read
+ */
+export type SourceStatus = 'available' | 'absent' | 'corrupt' | 'forbidden' | 'unreadable';
+export type SourceErrorCode = 'SOURCE_ABSENT' | 'SOURCE_OUTSIDE_PROJECT' | 'SOURCE_UNRESOLVABLE' | 'SOURCE_NOT_REGULAR' | 'SOURCE_EMPTY' | 'SOURCE_TOO_LARGE' | 'SOURCE_CHANGED' | 'SOURCE_UNREADABLE' | 'SOURCE_SYMLINK' | 'SOURCE_HARDLINKED' | 'SOURCE_BOUNDARY_INVALID' | 'SOURCE_UNSUPPORTED_PLATFORM' | 'PARSE_ERROR' | 'SCHEMA_INVALID' | 'CONFIG_INVALID' | 'ROOT_INVALID' | 'INTERNAL';
+export interface SourceReport {
+    id: SourceId;
+    /** Project-relative, `/`-separated; null when the instance root could not be trusted. */
+    path: string | null;
+    status: SourceStatus;
+    /** null iff status === 'available'. */
+    code: SourceErrorCode | null;
+}
+/** `data` is null only when the sections' sources could not supply it. */
+export interface Section<T> {
+    data: T | null;
+    /** The sources this section depends on, in fixed order. */
+    sources: SourceReport[];
+}
+export interface ProjectOverview {
+    /** `project.name` from `monolith.config.json`; null when absent or not a non-empty string. */
+    name: string | null;
+    /** Validated relative instance root (ADR-009), `/`-separated. */
+    monolithRoot: string;
+    monolithRootSource: 'config' | 'default';
+    /** `schemaVersion` as found on disk (1 is migrated in memory); null unless state is available. */
+    stateSchemaVersionOnDisk: number | null;
+    stateRevision: number | null;
+    /** Counts over `tactical.missions`; null unless state is available or absent (absent ⇒ 0). */
+    activeMissionCount: number | null;
+    finishedMissionCount: number | null;
+    /** Verbatim `## Current Story` section of `active.md`; null when the section cannot be shown. */
+    currentStory: {
+        excerpt: string;
+        lineRange: string;
+    } | null;
+}
+export interface CurrentMissions {
+    /** Every `in_progress` mission, ordered by (startedAt, id). More than one is reported, never collapsed. */
+    active: Mission[];
+}
+export interface MissionCheckpoints {
+    missionId: string;
+    /** Number of checkpoints recorded for the mission. */
+    count: number;
+    /**
+     * Highest-ordinal checkpoint (ID order is authoritative, as in `brief`).
+     * Its `remainingSteps` are a HISTORICAL record at that checkpoint, not the
+     * project's current plan.
+     */
+    latest: Checkpoint | null;
+}
+export interface CheckpointsData {
+    /** One entry per active mission, same order as `CurrentMissions.active`. */
+    byActiveMission: MissionCheckpoints[];
+}
+export interface RoadmapData {
+    /** Raw, unparsed text of `roadmap-index.md`. Untrusted: must be shown escaped, never rendered or executed. */
+    text: string;
+}
+export type NoteCode = 'STATE_LEGACY_SCHEMA_MIGRATED' | 'MULTIPLE_ACTIVE_MISSIONS' | 'CHECKPOINT_ORDER_MISMATCH' | 'ACTIVE_MD_NO_CURRENT_STORY';
+export interface ReadNote {
+    code: NoteCode;
+    severity: 'info' | 'warn';
+}
+export interface ReadDiagnostics {
+    /**
+     * This reports availability of the fixed sources only. `monolith validate`
+     * is never run, so a clean report is NOT a statement that the project is valid.
+     */
+    validation: 'NOT_PERFORMED';
+    /** Every source, in fixed order: config, state, activeStory, roadmap. */
+    sources: SourceReport[];
+    notes: ReadNote[];
+}
+export interface DashboardReadModel {
+    projectOverview: Section<ProjectOverview>;
+    currentMissions: Section<CurrentMissions>;
+    checkpoints: Section<CheckpointsData>;
+    roadmap: Section<RoadmapData>;
+    diagnostics: ReadDiagnostics;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/readmodel/types.ts"],"names":[],"mappings":"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"}

package/dist/readmodel/types.js

@@ -0,0 +1,15 @@
+/**
+ * Typed Read Model for Mission Control (UI-001B.1, ADR-010).
+ *
+ * A pure, read-only projection of data MONOLITH Core already owns. It adds no
+ * persistent schema and no source of truth: every field is copied from, or
+ * counted over, an existing artifact (`monolith.config.json`, `state.json`,
+ * `active.md`, `roadmap-index.md`).
+ *
+ * Errors are DATA, not text: only fixed enum codes and project-relative paths
+ * cross this boundary. No absolute path, no exception message and no file
+ * excerpt other than the explicit content fields below ever appears in a
+ * diagnostic, so the DTO is safe to serialize over HTTP later (G2 still gates
+ * that).
+ */
+export {};