onto-mcp 0.3.0

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

@@ -0,0 +1,323 @@
+/**
+ * /draft command orchestration.
+ *
+ * State-dependent behavior:
+ * - align_locked → generate surface + transition to surface_iterating
+ * - surface_iterating → apply feedback or confirm surface
+ * - surface_confirmed → deep constraint discovery + Draft Packet rendering
+ * - constraints_resolved → lock target
+ * - target_locked → compile
+ *
+ * Surface generation and constraint discovery are agent-driven.
+ * This module provides the event recording orchestration.
+ */
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { readEvents } from "../../scope-runtime/event-store.js";
+import { reduce } from "../../scope-runtime/reducer.js";
+import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
+import { renderDraftPacket } from "../renderers/draft-packet.js";
+import { wrapGateError } from "./error-messages.js";
+import { refreshScopeMd } from "./shared.js";
+import { contentHash } from "../../scope-runtime/hash.js";
+import { compile } from "../adapters/code-product/compile/compile.js";
+// ─── Main ───
+export function executeDraft(input) {
+    const { paths, action } = input;
+    const events = readEvents(paths.events);
+    const state = reduce(events);
+    switch (action.type) {
+        case "generate_surface":
+            return handleGenerateSurface(paths, state, action);
+        case "apply_feedback":
+            return handleApplyFeedback(paths, state, action);
+        case "confirm_surface":
+            return handleConfirmSurface(paths, state, action);
+        case "surface_change_required":
+            return handleSurfaceChangeRequired(paths, action);
+        case "record_constraint":
+            return handleRecordConstraint(paths, action);
+        case "record_decision":
+            return handleRecordDecision(paths, action);
+        case "lock_target":
+            return handleLockTarget(paths, state);
+        case "compile":
+            return handleCompile(paths, state, action);
+    }
+}
+// ─── Action Handlers ───
+function handleGenerateSurface(paths, state, action) {
+    if (state.current_state !== "align_locked") {
+        return { success: false, reason: `Surface 생성은 align_locked 상태에서만 가능합니다. 현재: ${state.current_state}` };
+    }
+    const result = appendScopeEvent(paths, {
+        type: "surface.generated",
+        actor: "system",
+        payload: {
+            surface_type: state.entry_mode,
+            surface_path: action.surfacePath,
+            content_hash: action.surfaceHash,
+            based_on_snapshot: action.snapshotRevision,
+        },
+    });
+    if (!result.success)
+        return { success: false, reason: wrapGateError(result.reason) };
+    refreshScopeMd(paths, result.state);
+    const guide = state.entry_mode === "experience"
+        ? "`cd surface/preview && npm run dev`로 mockup을 확인하세요."
+        : "`surface/contract-diff/`의 API 명세를 확인하세요.";
+    return {
+        success: true,
+        nextState: "surface_iterating",
+        message: `Surface가 생성되었습니다. ${guide} 수정이 필요하면 피드백을 주세요. 이 모습이 맞으면 '확정합니다'라고 말씀해 주세요.`,
+    };
+}
+function handleApplyFeedback(paths, state, action) {
+    const classification = action.classification ?? "surface_only";
+    // 1. Record feedback
+    const fbResult = appendScopeEvent(paths, {
+        type: "surface.revision_requested",
+        actor: "user",
+        payload: { feedback_text: action.feedbackText },
+    });
+    if (!fbResult.success)
+        return { success: false, reason: wrapGateError(fbResult.reason) };
+    // 2. Record feedback classification
+    const classifyResult = appendScopeEvent(paths, {
+        type: "feedback.classified",
+        actor: "system",
+        payload: {
+            classification,
+            confidence: action.classification ? 1.0 : 0.8,
+            confirmed_by: action.classification ? "user" : "auto",
+        },
+    });
+    if (!classifyResult.success)
+        return { success: false, reason: wrapGateError(classifyResult.reason) };
+    // 3. direction_change → redirect to align, early return
+    if (classification === "direction_change") {
+        const redirectResult = appendScopeEvent(paths, {
+            type: "redirect.to_align",
+            actor: "system",
+            payload: {
+                from_state: state.current_state,
+                reason: "피드백 분류: direction_change — 방향 재검토가 필요합니다.",
+            },
+        });
+        if (!redirectResult.success)
+            return { success: false, reason: wrapGateError(redirectResult.reason) };
+        refreshScopeMd(paths, redirectResult.state);
+        return {
+            success: true,
+            nextState: "align_proposed",
+            message: "방향 변경 피드백이 감지되었습니다. /align으로 방향을 재검토합니다.",
+        };
+    }
+    // 4. Record revision
+    const revResult = appendScopeEvent(paths, {
+        type: "surface.revision_applied",
+        actor: "system",
+        payload: {
+            revision_count: state.revision_count_surface + 1,
+            surface_path: action.surfacePath,
+            content_hash: action.surfaceHash,
+        },
+    });
+    if (!revResult.success)
+        return { success: false, reason: wrapGateError(revResult.reason) };
+    refreshScopeMd(paths, revResult.state);
+    // 5. target_change → append scope change notice
+    const message = classification === "target_change"
+        ? "피드백이 반영되었습니다. 범위가 변경되었습니다. Surface를 다시 확인해 주세요."
+        : "피드백이 반영되었습니다. Surface를 다시 확인해 주세요.";
+    return {
+        success: true,
+        nextState: "surface_iterating",
+        message,
+    };
+}
+function handleConfirmSurface(paths, state, action) {
+    const result = appendScopeEvent(paths, {
+        type: "surface.confirmed",
+        actor: "user",
+        payload: {
+            final_surface_path: action.surfacePath,
+            final_content_hash: action.surfaceHash,
+            total_revisions: state.revision_count_surface,
+        },
+    });
+    if (!result.success)
+        return { success: false, reason: wrapGateError(result.reason) };
+    refreshScopeMd(paths, result.state);
+    return {
+        success: true,
+        nextState: "surface_confirmed",
+        message: "Surface가 확정되었습니다. 3개 관점에서 정밀 스캔을 수행합니다.",
+    };
+}
+function handleSurfaceChangeRequired(paths, action) {
+    const result = appendScopeEvent(paths, {
+        type: "surface.change_required",
+        actor: "system",
+        payload: {
+            constraint_id: action.constraintId,
+            reason: action.reason,
+        },
+    });
+    if (!result.success)
+        return { success: false, reason: wrapGateError(result.reason) };
+    refreshScopeMd(paths, result.state);
+    return {
+        success: true,
+        nextState: "surface_iterating",
+        message: `${action.constraintId}: 제약 사항으로 인해 Surface 수정이 필요합니다. Surface를 다시 검토해 주세요.`,
+    };
+}
+function handleRecordConstraint(paths, action) {
+    const result = appendScopeEvent(paths, {
+        type: "constraint.discovered",
+        actor: "system",
+        payload: action.constraintPayload,
+    });
+    if (!result.success)
+        return { success: false, reason: wrapGateError(result.reason) };
+    refreshScopeMd(paths, result.state);
+    const cstId = action.constraintPayload.constraint_id ?? "?";
+    return {
+        success: true,
+        nextState: "surface_confirmed",
+        message: `Constraint ${cstId}이 기록되었습니다.`,
+    };
+}
+function handleRecordDecision(paths, action) {
+    const result = appendScopeEvent(paths, {
+        type: "constraint.decision_recorded",
+        actor: "user",
+        payload: action.decisionPayload,
+    });
+    if (!result.success)
+        return { success: false, reason: wrapGateError(result.reason) };
+    const cstId = action.decisionPayload.constraint_id ?? "?";
+    const decision = action.decisionPayload.decision ?? "?";
+    // modify-direction → automatically redirect to Align
+    if (decision === "modify-direction") {
+        const redirectResult = appendScopeEvent(paths, {
+            type: "redirect.to_align",
+            actor: "system",
+            payload: {
+                from_state: result.next_state,
+                reason: `${cstId}: modify-direction 결정으로 방향 재검토 필요`,
+            },
+        });
+        if (!redirectResult.success)
+            return { success: false, reason: wrapGateError(redirectResult.reason) };
+        refreshScopeMd(paths, redirectResult.state);
+        return {
+            success: true,
+            nextState: "align_proposed",
+            message: `${cstId}: modify-direction. 방향을 재검토합니다. /align으로 진행하세요.`,
+        };
+    }
+    refreshScopeMd(paths, result.state);
+    return {
+        success: true,
+        nextState: result.next_state,
+        message: `${cstId}: ${decision} 결정이 기록되었습니다.`,
+    };
+}
+function handleLockTarget(paths, state) {
+    // Filter: decided constraints only (matches gate-guard Rule 6 criteria)
+    const activeConstraints = state.constraint_pool.constraints
+        .filter(c => c.status === "decided")
+        .map(c => ({ constraint_id: c.constraint_id, decision: c.decision }));
+    const result = appendScopeEvent(paths, {
+        type: "target.locked",
+        actor: "system",
+        payload: {
+            surface_hash: state.surface_hash ?? "",
+            constraint_decisions: activeConstraints,
+        },
+    });
+    if (!result.success)
+        return { success: false, reason: wrapGateError(result.reason) };
+    refreshScopeMd(paths, result.state);
+    return {
+        success: true,
+        nextState: "target_locked",
+        message: "모든 결정이 완료되었습니다. compile을 시작합니다.",
+    };
+}
+function handleCompile(paths, state, action) {
+    // Execute compile FIRST (before recording compile.started)
+    // This prevents orphaned compile.started events in the event stream on failure.
+    const compileResult = compile(action.compileInput);
+    if (!compileResult.success) {
+        return {
+            success: false,
+            reason: wrapGateError(`Compile 실패: ${compileResult.reason}`),
+            violations: compileResult.violations,
+        };
+    }
+    // Record compile.started (only after successful compile)
+    const startResult = appendScopeEvent(paths, {
+        type: "compile.started",
+        actor: "system",
+        payload: {
+            snapshot_revision: state.snapshot_revision,
+            surface_hash: state.surface_hash ?? "",
+        },
+    });
+    if (!startResult.success)
+        return { success: false, reason: wrapGateError(startResult.reason) };
+    const success = compileResult;
+    // Save artifacts
+    writeFileSync(join(paths.build, "build-spec.md"), success.buildSpecMd, "utf-8");
+    writeFileSync(join(paths.build, "brownfield-detail.md"), success.brownfieldDetailMd, "utf-8");
+    writeFileSync(join(paths.build, "delta-set.json"), success.deltaSetJson, "utf-8");
+    writeFileSync(join(paths.build, "validation-plan.md"), success.validationPlanMd, "utf-8");
+    // Record compile.completed
+    const completeResult = appendScopeEvent(paths, {
+        type: "compile.completed",
+        actor: "system",
+        payload: {
+            build_spec_path: "build/build-spec.md",
+            build_spec_hash: success.buildSpecHash,
+            brownfield_detail_path: "build/brownfield-detail.md",
+            brownfield_detail_hash: success.brownfieldDetailHash,
+            delta_set_path: "build/delta-set.json",
+            delta_set_hash: success.deltaSetHash,
+            validation_plan_path: "build/validation-plan.md",
+            validation_plan_hash: success.validationPlanHash,
+        },
+    });
+    if (!completeResult.success)
+        return { success: false, reason: wrapGateError(completeResult.reason) };
+    refreshScopeMd(paths, completeResult.state);
+    return {
+        success: true,
+        nextState: "compiled",
+        message: "Build Spec이 생성되었습니다. 구현을 적용하세요.",
+        data: {
+            buildSpecHash: success.buildSpecHash,
+            deltaSetHash: success.deltaSetHash,
+            validationPlanHash: success.validationPlanHash,
+            warnings: success.warnings,
+        },
+    };
+}
+// ─── Packet Rendering (UF-STRUCTURE-PACKET-SEAT) ───
+/**
+ * Render a Draft Packet and write it to `build/draft-packet.md`.
+ *
+ * Called by the agent when it has assembled DraftPacketContent
+ * (after surface confirmation + constraint discovery).
+ * Returns the content hash of the written packet.
+ */
+export function writeDraftPacket(paths, content) {
+    const state = reduce(readEvents(paths.events));
+    const md = renderDraftPacket(state, content);
+    const packetPath = join(paths.build, "draft-packet.md");
+    writeFileSync(packetPath, md, "utf-8");
+    return { packetPath, packetHash: contentHash(md) };
+}
+// refreshScopeMd is imported from ./shared.ts (UF-CONCISENESS-SCOPE-MD consolidated)

package/dist/core-runtime/evolve/commands/draft.test.js

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { executeDraft } from "./draft.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-draft-")); });
+afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
+/** Set up scope through align_locked */
+function setupAlignLocked() {
+    const paths = createScope(tmpDir, "SC-DRAFT-001");
+    appendScopeEvent(paths, { type: "scope.created", actor: "user", payload: { title: "Test", description: "d", 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 } } });
+    appendScopeEvent(paths, { type: "align.proposed", actor: "system", payload: { packet_path: "build/align-packet.md", packet_hash: "h", snapshot_revision: 1 } });
+    appendScopeEvent(paths, { type: "align.locked", actor: "user", payload: { locked_direction: "test", locked_scope_boundaries: { in: ["a"], out: ["b"] }, locked_in_out: true } });
+    return paths;
+}
+/** Set up scope through surface_iterating */
+function setupSurfaceIterating() {
+    const paths = setupAlignLocked();
+    appendScopeEvent(paths, { type: "surface.generated", actor: "system", payload: { surface_type: "experience", surface_path: "surface/preview/", content_hash: "sf1", based_on_snapshot: 1 } });
+    return paths;
+}
+describe("executeDraft", () => {
+    it("generate_surface: align_locked → surface_iterating", () => {
+        const paths = setupAlignLocked();
+        const result = executeDraft({
+            paths,
+            action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf1", snapshotRevision: 1 },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("surface_iterating");
+        const state = reduce(readEvents(paths.events));
+        expect(state.current_state).toBe("surface_iterating");
+    });
+    it("apply_feedback: surface_iterating → surface_iterating", () => {
+        const paths = setupSurfaceIterating();
+        const result = executeDraft({
+            paths,
+            action: { type: "apply_feedback", feedbackText: "버튼 위치 변경", surfacePath: "surface/preview/", surfaceHash: "sf2" },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("surface_iterating");
+    });
+    it("confirm_surface: surface_iterating → surface_confirmed", () => {
+        const paths = setupSurfaceIterating();
+        const result = executeDraft({
+            paths,
+            action: { type: "confirm_surface", surfacePath: "surface/preview/", surfaceHash: "sf_final" },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("surface_confirmed");
+    });
+    it("generate_surface fails when not align_locked", () => {
+        const paths = setupSurfaceIterating(); // already surface_iterating
+        const result = executeDraft({
+            paths,
+            action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf", snapshotRevision: 1 },
+        });
+        expect(result.success).toBe(false);
+    });
+    it("apply_feedback with classification=surface_only records feedback.classified", () => {
+        const paths = setupSurfaceIterating();
+        const result = executeDraft({
+            paths,
+            action: { type: "apply_feedback", feedbackText: "색상 변경", surfacePath: "surface/preview/", surfaceHash: "sf3", classification: "surface_only" },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("surface_iterating");
+        const events = readEvents(paths.events);
+        const classifiedEvents = events.filter(e => e.type === "feedback.classified");
+        expect(classifiedEvents.length).toBe(1);
+        expect(classifiedEvents[0].payload).toEqual({
+            classification: "surface_only",
+            confidence: 1.0,
+            confirmed_by: "user",
+        });
+        // revision_applied should also be recorded
+        const revisionEvents = events.filter(e => e.type === "surface.revision_applied");
+        expect(revisionEvents.length).toBe(1);
+    });
+    it("apply_feedback with classification=direction_change issues redirect.to_align", () => {
+        const paths = setupSurfaceIterating();
+        const result = executeDraft({
+            paths,
+            action: { type: "apply_feedback", feedbackText: "방향을 바꿔야 합니다", surfacePath: "surface/preview/", surfaceHash: "sf4", classification: "direction_change" },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("align_proposed");
+        const events = readEvents(paths.events);
+        const classifiedEvents = events.filter(e => e.type === "feedback.classified");
+        expect(classifiedEvents.length).toBe(1);
+        expect(classifiedEvents[0].payload).toEqual({
+            classification: "direction_change",
+            confidence: 1.0,
+            confirmed_by: "user",
+        });
+        const redirectEvents = events.filter(e => e.type === "redirect.to_align");
+        expect(redirectEvents.length).toBe(1);
+        // revision_applied should NOT be recorded (early return)
+        const revisionEvents = events.filter(e => e.type === "surface.revision_applied");
+        expect(revisionEvents.length).toBe(0);
+        const state = reduce(events);
+        expect(state.current_state).toBe("align_proposed");
+    });
+    it("apply_feedback without classification defaults to surface_only", () => {
+        const paths = setupSurfaceIterating();
+        const result = executeDraft({
+            paths,
+            action: { type: "apply_feedback", feedbackText: "간격 조정", surfacePath: "surface/preview/", surfaceHash: "sf5" },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("surface_iterating");
+        const events = readEvents(paths.events);
+        const classifiedEvents = events.filter(e => e.type === "feedback.classified");
+        expect(classifiedEvents.length).toBe(1);
+        expect(classifiedEvents[0].payload).toEqual({
+            classification: "surface_only",
+            confidence: 0.8,
+            confirmed_by: "auto",
+        });
+    });
+    it("apply_feedback with classification=target_change appends scope change message", () => {
+        const paths = setupSurfaceIterating();
+        const result = executeDraft({
+            paths,
+            action: { type: "apply_feedback", feedbackText: "범위 수정", surfacePath: "surface/preview/", surfaceHash: "sf6", classification: "target_change" },
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.nextState).toBe("surface_iterating");
+        expect(result.message).toContain("범위가 변경되었습니다");
+    });
+    it("full flow: generate → feedback → confirm → constraint → decision → lock", () => {
+        const paths = setupAlignLocked();
+        // Generate surface
+        executeDraft({ paths, action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf1", snapshotRevision: 1 } });
+        // Confirm surface
+        executeDraft({ paths, action: { type: "confirm_surface", surfacePath: "surface/preview/", surfaceHash: "sf1" } });
+        // Discover constraint
+        executeDraft({ paths, action: { type: "record_constraint", constraintPayload: {
+                    constraint_id: "CST-001", perspective: "code", summary: "test", severity: "required",
+                    discovery_stage: "draft_phase2", decision_owner: "product_owner",
+                    impact_if_ignored: "fails", source_refs: [{ source: "test.ts", detail: "d" }],
+                } } });
+        // Record decision
+        executeDraft({ paths, action: { type: "record_decision", decisionPayload: {
+                    constraint_id: "CST-001", decision: "inject", selected_option: "fix",
+                    decision_owner: "product_owner", rationale: "필수",
+                } } });
+        // Lock target
+        const lockResult = executeDraft({ paths, action: { type: "lock_target" } });
+        expect(lockResult.success).toBe(true);
+        if (!lockResult.success)
+            return;
+        expect(lockResult.nextState).toBe("target_locked");
+        const state = reduce(readEvents(paths.events));
+        expect(state.current_state).toBe("target_locked");
+    });
+});