onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/evolve/commands/propose-align.js

@@ -1,222 +0,0 @@
-/**
- * Evolve propose-align — transition grounded → align_proposed.
- *
- * Consumes consolidated dialog output (direction, scope, constraints, tensions)
- * from the agent who conducted the Principal dialog, then:
- *   1. Emits constraint.discovered events (pool registration).
- *   2. Renders build/align-packet.md.
- *   3. Emits align.proposed event (state transition to align_proposed).
- *
- * The agent owns UX (selection-based choices, natural-language fallback,
- * inquiry consolidation, convergence judgment); this CLI owns the bounded
- * state machine + event log + packet rendering.
- */
-import { createHash } from "node:crypto";
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { z } from "zod";
-import { readEvents } from "../../scope-runtime/event-store.js";
-import { reduce } from "../../scope-runtime/reducer.js";
-import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
-import { renderAlignPacket } from "../renderers/align-packet.js";
-// ─── Input schema ───
-const constraintInputSchema = z.object({
-    summary: z.string().min(1),
-    perspective: z.enum(["experience", "code", "policy"]),
-    severity: z.enum(["required", "recommended"]),
-    decision_owner: z.enum(["product_owner", "builder"]),
-    impact_if_ignored: z.string().min(1),
-    source_refs: z
-        .array(z.object({ source: z.string(), detail: z.string() }))
-        .default([]),
-    evidence_status: z
-        .enum(["verified", "code_inferred", "brief_claimed", "unverified"])
-        .optional(),
-    evidence_note: z.string().optional(),
-    why_conflict: z.string().min(1),
-    scale: z.string().min(1),
-    options: z
-        .array(z.object({
-        choice: z.string(),
-        pros: z.string(),
-        risk: z.string(),
-        detail: z.string().optional(),
-    }))
-        .optional(),
-    recommendation: z.string().optional(),
-});
-const proposeAlignInputSchema = z.object({
-    interpreted_direction: z.string().min(1),
-    proposed_scope: z.object({
-        in: z.array(z.string()).min(1),
-        out: z.array(z.string()),
-    }),
-    scenarios: z.array(z.string()).default([]),
-    as_is: z.object({
-        experience: z.string().default(""),
-        policy: z.string().default(""),
-        code: z.string().default(""),
-        code_details: z.string().optional(),
-    }),
-    constraints: z.array(constraintInputSchema).default([]),
-    decision_questions: z.array(z.string()).default([]),
-    interface_extras: z
-        .object({
-        api_scope: z.string(),
-        breaking_change: z.string(),
-        version_policy: z.string(),
-    })
-        .optional(),
-});
-// ─── Main ───
-export function executeProposeAlign(paths, jsonInput) {
-    // Step 1: Parse + validate input
-    let parsed;
-    try {
-        const raw = JSON.parse(jsonInput);
-        const result = proposeAlignInputSchema.safeParse(raw);
-        if (!result.success) {
-            const issues = result.error.issues
-                .map((i) => `${i.path.join(".")}: ${i.message}`)
-                .join("; ");
-            return {
-                success: false,
-                reason: `Invalid propose-align input: ${issues}`,
-            };
-        }
-        parsed = result.data;
-    }
-    catch (e) {
-        return {
-            success: false,
-            reason: `Failed to parse JSON: ${e instanceof Error ? e.message : String(e)}`,
-        };
-    }
-    // Step 2: Verify current state is grounded
-    const initialEvents = readEvents(paths.events);
-    const initialState = reduce(initialEvents);
-    if (initialState.current_state !== "grounded") {
-        return {
-            success: false,
-            reason: `현재 상태가 ${initialState.current_state}입니다. propose-align은 grounded 상태에서만 실행할 수 있습니다.`,
-        };
-    }
-    // Step 3: Emit constraint.discovered events
-    const tensions = [];
-    let registeredCount = 0;
-    for (let i = 0; i < parsed.constraints.length; i++) {
-        const c = parsed.constraints[i];
-        const constraintId = `C-${String(i + 1).padStart(3, "0")}`;
-        const payload = {
-            constraint_id: constraintId,
-            perspective: c.perspective,
-            summary: c.summary,
-            severity: c.severity,
-            discovery_stage: "grounding",
-            decision_owner: c.decision_owner,
-            impact_if_ignored: c.impact_if_ignored,
-            source_refs: c.source_refs,
-        };
-        if (c.evidence_status)
-            payload.evidence_status = c.evidence_status;
-        if (c.evidence_note)
-            payload.evidence_note = c.evidence_note;
-        const result = appendScopeEvent(paths, {
-            type: "constraint.discovered",
-            actor: "user",
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            payload: payload,
-        });
-        if (!result.success) {
-            return {
-                success: false,
-                reason: `constraint.discovered[${i}] (${constraintId}) emission 실패: ${result.reason}`,
-            };
-        }
-        registeredCount++;
-        const tension = {
-            constraint_id: constraintId,
-            what: c.summary,
-            why_conflict: c.why_conflict,
-            scale: c.scale,
-        };
-        if (c.options) {
-            tension.options = c.options.map((o) => {
-                const base = {
-                    choice: o.choice,
-                    pros: o.pros,
-                    risk: o.risk,
-                };
-                if (o.detail !== undefined)
-                    base.detail = o.detail;
-                return base;
-            });
-        }
-        if (c.recommendation)
-            tension.recommendation = c.recommendation;
-        tensions.push(tension);
-    }
-    // Step 4: Re-read state after constraint events
-    const stateAfterConstraints = reduce(readEvents(paths.events));
-    // Step 5: Build AlignPacketContent
-    const asIs = {
-        experience: parsed.as_is.experience,
-        policy: parsed.as_is.policy,
-        code: parsed.as_is.code,
-    };
-    if (parsed.as_is.code_details !== undefined) {
-        asIs.code_details = parsed.as_is.code_details;
-    }
-    const content = {
-        user_original_text: stateAfterConstraints.title,
-        interpreted_direction: parsed.interpreted_direction,
-        proposed_scope: parsed.proposed_scope,
-        scenarios: parsed.scenarios,
-        as_is: asIs,
-        tensions,
-        decision_questions: parsed.decision_questions,
-        ...(parsed.interface_extras
-            ? { interface_extras: parsed.interface_extras }
-            : {}),
-    };
-    // Step 6: Render packet
-    let packetMd;
-    try {
-        packetMd = renderAlignPacket(stateAfterConstraints, content);
-    }
-    catch (e) {
-        return {
-            success: false,
-            reason: `renderAlignPacket 실패: ${e instanceof Error ? e.message : String(e)}`,
-        };
-    }
-    const packetPath = join(paths.build, "align-packet.md");
-    writeFileSync(packetPath, packetMd, "utf-8");
-    // Step 7: Compute packet hash
-    const packetHash = createHash("sha256").update(packetMd).digest("hex");
-    // Step 8: Emit align.proposed
-    const proposeResult = appendScopeEvent(paths, {
-        type: "align.proposed",
-        actor: "user",
-        payload: {
-            packet_path: "build/align-packet.md",
-            packet_hash: packetHash,
-            snapshot_revision: stateAfterConstraints.snapshot_revision,
-        },
-    });
-    if (!proposeResult.success) {
-        return {
-            success: false,
-            reason: `align.proposed emission 실패: ${proposeResult.reason}`,
-        };
-    }
-    return {
-        success: true,
-        scope_id: paths.scopeId,
-        constraints_registered: registeredCount,
-        packet_path: packetPath,
-        packet_hash: packetHash,
-        next_state: proposeResult.next_state,
-        next_action: "build/align-packet.md 를 검토하고 bounded evolve align input을 제출하세요 (verdict type: approve/revise/reject/redirect).",
-    };
-}

package/dist/core-runtime/evolve/commands/propose-align.test.js

@@ -1,136 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { executeProposeAlign } from "./propose-align.js";
-import { createScope } from "../../scope-runtime/scope-manager.js";
-import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
-import { readEvents } from "../../scope-runtime/event-store.js";
-import { reduce } from "../../scope-runtime/reducer.js";
-let tmpDir;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "sprint-propose-align-"));
-});
-afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-function setupGrounded() {
-    const paths = createScope(tmpDir, "SC-PA-001");
-    appendScopeEvent(paths, {
-        type: "scope.created",
-        actor: "user",
-        payload: {
-            title: "Propose align test",
-            description: "test scope",
-            entry_mode: "experience",
-        },
-    });
-    appendScopeEvent(paths, {
-        type: "grounding.started",
-        actor: "system",
-        payload: {
-            sources: [{ type: "add-dir", path_or_url: "/test" }],
-        },
-    });
-    appendScopeEvent(paths, {
-        type: "grounding.completed",
-        actor: "system",
-        payload: {
-            snapshot_revision: 1,
-            source_hashes: { "add-dir:/test": "h1" },
-            perspective_summary: { experience: 1, code: 1, policy: 1 },
-        },
-    });
-    return paths;
-}
-const VALID_INPUT = JSON.stringify({
-    interpreted_direction: "test direction",
-    proposed_scope: { in: ["feature X"], out: ["feature Y"] },
-    scenarios: ["scenario 1"],
-    as_is: { experience: "exp-baseline", policy: "policy-baseline", code: "code-baseline" },
-    constraints: [
-        {
-            summary: "constraint 1",
-            perspective: "code",
-            severity: "required",
-            decision_owner: "builder",
-            impact_if_ignored: "breaks flow",
-            source_refs: [{ source: "code", detail: "src/foo.ts" }],
-            why_conflict: "conflict between X and Y",
-            scale: "medium",
-        },
-    ],
-    decision_questions: ["Q1?"],
-});
-describe("executeProposeAlign", () => {
-    it("grounded + valid input → align_proposed + packet + events", () => {
-        const paths = setupGrounded();
-        const result = executeProposeAlign(paths, VALID_INPUT);
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.constraints_registered).toBe(1);
-        expect(result.next_state).toBe("align_proposed");
-        const packet = readFileSync(result.packet_path, "utf-8");
-        expect(packet).toContain("Align Packet");
-        expect(packet).toContain("test direction");
-        expect(packet).toContain("feature X");
-        const events = readEvents(paths.events);
-        const state = reduce(events);
-        expect(state.current_state).toBe("align_proposed");
-        expect(state.constraint_pool.summary.total).toBe(1);
-    });
-    it("rejects when not in grounded state", () => {
-        const paths = createScope(tmpDir, "SC-PA-002");
-        appendScopeEvent(paths, {
-            type: "scope.created",
-            actor: "user",
-            payload: { title: "t", description: "d", entry_mode: "experience" },
-        });
-        const result = executeProposeAlign(paths, VALID_INPUT);
-        expect(result.success).toBe(false);
-        if (result.success)
-            return;
-        expect(result.reason).toContain("grounded");
-    });
-    it("rejects invalid JSON", () => {
-        const paths = setupGrounded();
-        const result = executeProposeAlign(paths, "not-json");
-        expect(result.success).toBe(false);
-        if (result.success)
-            return;
-        expect(result.reason).toContain("Failed to parse JSON");
-    });
-    it("rejects missing required fields", () => {
-        const paths = setupGrounded();
-        const result = executeProposeAlign(paths, JSON.stringify({}));
-        expect(result.success).toBe(false);
-        if (result.success)
-            return;
-        expect(result.reason).toContain("Invalid propose-align input");
-    });
-    it("rejects empty scope_in", () => {
-        const paths = setupGrounded();
-        const bad = JSON.stringify({
-            interpreted_direction: "x",
-            proposed_scope: { in: [], out: [] },
-            as_is: { experience: "", policy: "", code: "" },
-        });
-        const result = executeProposeAlign(paths, bad);
-        expect(result.success).toBe(false);
-    });
-    it("accepts zero-constraints input (empty tensions ok per renderer)", () => {
-        const paths = setupGrounded();
-        const input = JSON.stringify({
-            interpreted_direction: "x",
-            proposed_scope: { in: ["a"], out: [] },
-            as_is: { experience: "e", policy: "p", code: "c" },
-            constraints: [],
-        });
-        const result = executeProposeAlign(paths, input);
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.constraints_registered).toBe(0);
-    });
-});

package/dist/core-runtime/evolve/commands/reconstruct.js

@@ -1,330 +0,0 @@
-/**
- * reconstruct — runtime handler for the reconstruct activity (3-step bounded path).
- *
- * W-A-74 (DL-020 resolution): review 의 3-step bounded path 수준으로 reconstruct 비대칭 해소.
- *
- * Bounded surface:
- *   start    — session 초기화 + gathering_context 상태 기록
- *   explore  — 탐색 loop bounded invocation (현 단계는 placeholder — 실제 Explorer/lens
- *              loop 는 build runtime 확장과 함께 채운다)
- *   complete — ontology 초안 산출 + converted 상태 기록
- *
- * 본 handler 는 reconstruct runtime (.onto/processes/reconstruct.md) 의 bounded adapter 다.
- * Bounded state 는 `{session_root}/reconstruct-state.json` 단일 파일로 관리한다 —
- * 이는 build runtime 의 완전한 state machine (RECONSTRUCT_TRANSITIONS) 과 구별되는
- * **runtime 관찰 가능 minimum surface**.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-// ─── Internal helpers ───
-function nowIso() {
-    return new Date().toISOString();
-}
-function sessionRoot(sessionsDir, sessionId) {
-    return resolve(sessionsDir, sessionId);
-}
-function stateFile(root) {
-    return join(root, "reconstruct-state.json");
-}
-function writeState(root, state) {
-    writeFileSync(stateFile(root), JSON.stringify(state, null, 2) + "\n", "utf-8");
-}
-function readState(root) {
-    const raw = readFileSync(stateFile(root), "utf-8");
-    return JSON.parse(raw);
-}
-function makeSessionId(now) {
-    const iso = now();
-    const date = iso.slice(0, 10).replace(/-/g, "");
-    const rand = Math.random().toString(16).slice(2, 10);
-    return `${date}-${rand}`;
-}
-// ─── Core API ───
-/**
- * Step 1 — start: session 초기화 + gathering_context 상태 진입.
- */
-export function executeReconstructStart(options) {
-    const now = options.now ?? nowIso;
-    const nowStr = now();
-    if (options.source.trim() === "") {
-        throw new Error("[reconstruct] source is required.");
-    }
-    if (options.intent.trim() === "") {
-        throw new Error("[reconstruct] intent is required.");
-    }
-    const sessionId = options.sessionId ?? makeSessionId(now);
-    const root = sessionRoot(options.sessionsDir, sessionId);
-    if (existsSync(root)) {
-        throw new Error(`[reconstruct] session already exists: ${sessionId}`);
-    }
-    mkdirSync(root, { recursive: true });
-    const state = {
-        session_id: sessionId,
-        source: options.source,
-        intent: options.intent,
-        current_state: "gathering_context",
-        created_at: nowStr,
-        last_updated_at: nowStr,
-        started_at: nowStr,
-        explore_invocations: 0,
-        ontology_draft_path: null,
-        principal_review_status: "pending",
-    };
-    writeState(root, state);
-    return { success: true, session_id: sessionId, session_root: root, state };
-}
-/**
- * Step 2 — explore: build runtime 의 탐색 loop 1회 호출.
- *
- * 현 단계는 bounded placeholder — state 만 `exploring` 으로 전이하고 invocations 을 증가.
- * 실제 Explorer/lens loop 실행은 후속 W-ID 에서 build runtime 과 연결한다.
- * 이 분리 자체가 W-A-74 의 증분: runtime 관찰 가능 surface 를 build runtime 구현보다 먼저 확보.
- */
-export function executeReconstructExplore(options) {
-    const root = sessionRoot(options.sessionsDir, options.sessionId);
-    if (!existsSync(stateFile(root))) {
-        throw new Error(`[reconstruct] session not found: ${options.sessionId}`);
-    }
-    const state = readState(root);
-    if (state.current_state === "converted") {
-        throw new Error(`[reconstruct] session already converted. explore is not allowed after completion.`);
-    }
-    const now = (options.now ?? nowIso)();
-    const next = {
-        ...state,
-        current_state: "exploring",
-        last_updated_at: now,
-        explore_invocations: state.explore_invocations + 1,
-    };
-    writeState(root, next);
-    return {
-        success: true,
-        session_id: options.sessionId,
-        state: next,
-        next_action: "Resume reconstruct exploration to continue or complete reconstruct to finalize.",
-    };
-}
-/**
- * Step 3 — complete: ontology 초안 산출 + converted 전이 + Principal 검증 요청.
- *
- * 현 단계는 bounded: state 를 converted 로 바꾸고 ontology_draft_path 를 placeholder 로 기록.
- * Principal 검증 경로는 §1.4 reconstruct 완료 기준 축 — 향후 학습 경로와 연결.
- */
-export function executeReconstructComplete(options) {
-    const root = sessionRoot(options.sessionsDir, options.sessionId);
-    if (!existsSync(stateFile(root))) {
-        throw new Error(`[reconstruct] session not found: ${options.sessionId}`);
-    }
-    const state = readState(root);
-    if (state.current_state === "gathering_context") {
-        throw new Error(`[reconstruct] complete requires at least one explore invocation (current: gathering_context).`);
-    }
-    if (state.current_state === "converted") {
-        throw new Error(`[reconstruct] session already converted: ${options.sessionId}`);
-    }
-    const now = (options.now ?? nowIso)();
-    const draftPath = join(root, "ontology-draft.md");
-    // Minimal placeholder artifact — 실제 ontology 는 build runtime 이 채운다.
-    writeFileSync(draftPath, [
-        `# Ontology draft — ${options.sessionId}`,
-        "",
-        `- source: ${state.source}`,
-        `- intent: ${state.intent}`,
-        `- explore invocations: ${state.explore_invocations}`,
-        "",
-        "> Placeholder draft. build runtime (.onto/processes/reconstruct.md) 이 채울 영역.",
-        "> §1.4 reconstruct 완료 기준 충족 판단은 Principal 검증 경로에서 이뤄진다.",
-        "",
-    ].join("\n"), "utf-8");
-    const next = {
-        ...state,
-        current_state: "converted",
-        last_updated_at: now,
-        ontology_draft_path: draftPath,
-        principal_review_status: "requested",
-    };
-    writeState(root, next);
-    return {
-        success: true,
-        session_id: options.sessionId,
-        state: next,
-        next_action: "Present ontology-draft.md to Principal for verification. Update principal_review_status accordingly.",
-    };
-}
-export function executeReconstructConfirm(options) {
-    const now = (options.now ?? (() => new Date().toISOString()))();
-    const root = resolve(options.sessionsDir, options.sessionId);
-    const state = readState(root);
-    if (state.current_state !== "converted") {
-        throw new Error(`Cannot confirm: session is in "${state.current_state}" state, expected "converted".`);
-    }
-    if (state.principal_review_status !== "requested") {
-        throw new Error(`Cannot confirm: principal_review_status is "${state.principal_review_status}", expected "requested".`);
-    }
-    const next = {
-        ...state,
-        last_updated_at: now,
-        principal_review_status: options.verdict,
-    };
-    writeState(root, next);
-    return {
-        success: true,
-        session_id: options.sessionId,
-        state: next,
-    };
-}
-// ─── Runtime entry ───
-function readOption(argv, name) {
-    const idx = argv.indexOf(`--${name}`);
-    return idx >= 0 && idx + 1 < argv.length ? argv[idx + 1] : undefined;
-}
-function nonFlagArgs(argv) {
-    const out = [];
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (a.startsWith("--")) {
-            // skip the flag and (if present) its value
-            const next = argv[i + 1];
-            if (next !== undefined && !next.startsWith("--"))
-                i++;
-            continue;
-        }
-        out.push(a);
-    }
-    return out;
-}
-function defaultSessionsDir(projectRoot) {
-    return join(projectRoot, ".onto", "reconstruct");
-}
-export async function handleReconstructCli(_ontoHome, argv) {
-    const subcommand = argv[0];
-    const subArgv = argv.slice(1);
-    const projectRoot = readOption(subArgv, "project-root") ?? process.cwd();
-    const sessionsDir = readOption(subArgv, "sessions-dir") ?? defaultSessionsDir(projectRoot);
-    if (!existsSync(sessionsDir)) {
-        mkdirSync(sessionsDir, { recursive: true });
-    }
-    switch (subcommand) {
-        case "start": {
-            const rest = nonFlagArgs(subArgv);
-            const source = rest[0];
-            const intent = rest.slice(1).join(" ").trim();
-            if (!source || !intent) {
-                console.error("[onto] reconstruct start requires <source> and <intent>.");
-                console.error('Example input: target=./src intent="recover domain ontology"');
-                return 1;
-            }
-            const sessionIdOpt = readOption(subArgv, "session-id");
-            try {
-                const result = executeReconstructStart({
-                    source,
-                    intent,
-                    sessionsDir,
-                    ...(sessionIdOpt !== undefined ? { sessionId: sessionIdOpt } : {}),
-                });
-                console.log(JSON.stringify({
-                    status: "started",
-                    session_id: result.session_id,
-                    session_root: result.session_root,
-                    current_state: result.state.current_state,
-                    next_action: "Resume reconstruct exploration with the session id to begin exploration.",
-                }, null, 2));
-                return 0;
-            }
-            catch (error) {
-                console.error(`[onto] reconstruct start error: ${error instanceof Error ? error.message : String(error)}`);
-                return 1;
-            }
-        }
-        case "explore": {
-            const sessionId = readOption(subArgv, "session-id");
-            if (!sessionId) {
-                console.error("[onto] reconstruct explore requires --session-id.");
-                return 1;
-            }
-            try {
-                const result = executeReconstructExplore({ sessionsDir, sessionId });
-                console.log(JSON.stringify({ status: "explored", ...result }, null, 2));
-                return 0;
-            }
-            catch (error) {
-                console.error(`[onto] reconstruct explore error: ${error instanceof Error ? error.message : String(error)}`);
-                return 1;
-            }
-        }
-        case "complete": {
-            const sessionId = readOption(subArgv, "session-id");
-            if (!sessionId) {
-                console.error("[onto] reconstruct complete requires --session-id.");
-                return 1;
-            }
-            try {
-                const result = executeReconstructComplete({ sessionsDir, sessionId });
-                console.log(JSON.stringify({ status: "completed", ...result }, null, 2));
-                return 0;
-            }
-            catch (error) {
-                console.error(`[onto] reconstruct complete error: ${error instanceof Error ? error.message : String(error)}`);
-                return 1;
-            }
-        }
-        case "confirm": {
-            const sessionId = readOption(subArgv, "session-id");
-            const verdict = readOption(subArgv, "verdict");
-            if (!sessionId || !verdict) {
-                console.error("[onto] reconstruct confirm requires --session-id and --verdict (passed|rejected).");
-                return 1;
-            }
-            if (verdict !== "passed" && verdict !== "rejected") {
-                console.error(`[onto] Invalid verdict: "${verdict}". Must be "passed" or "rejected".`);
-                return 1;
-            }
-            try {
-                const result = executeReconstructConfirm({
-                    sessionsDir,
-                    sessionId,
-                    verdict,
-                });
-                console.log(JSON.stringify({
-                    status: "confirmed",
-                    verdict: result.state.principal_review_status,
-                    session_id: result.session_id,
-                }, null, 2));
-                return 0;
-            }
-            catch (error) {
-                console.error(`[onto] reconstruct confirm error: ${error instanceof Error ? error.message : String(error)}`);
-                return 1;
-            }
-        }
-        case "--help":
-        case "-h":
-        case undefined:
-            console.log([
-                "Usage: reconstruct <subcommand> [options]",
-                "",
-                "Subcommands:",
-                "  start <source> <intent>     Initialize a reconstruct session",
-                "  explore --session-id <id>    Run one exploration invocation (bounded)",
-                "  complete --session-id <id>   Finalize ontology draft + request Principal review",
-                "  confirm --session-id <id> --verdict passed|rejected",
-                "                               Record Principal verification result",
-                "",
-                "Options:",
-                "  --project-root <path>        Project root (default: cwd)",
-                "  --sessions-dir <path>         Sessions directory (default: <project-root>/.onto/reconstruct)",
-                "  --session-id <id>            Custom session id (start only)",
-                "",
-                "Bounded path (review 3-step 대응):",
-                "  start → explore (1+ times) → complete → confirm",
-                "",
-                "State is persisted at {session_root}/reconstruct-state.json.",
-                "The process contract is .onto/processes/reconstruct.md (activity=reconstruct, process_name=build).",
-            ].join("\n"));
-            return 0;
-        default:
-            console.error(`[onto] Unknown reconstruct subcommand: ${subcommand}`);
-            console.error("Run reconstruct help for usage.");
-            return 1;
-    }
-}