@vibecodetown/mcp-server 2.1.4 → 2.2.1

package/build/tools/vibe_pm/advisory_review.js

@@ -1,10 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/advisory_review.ts
 // vibe_pm.advisory_review - Advisory review (triage/quick/thorough) with routing + cache
-import { runEngine } from "../../engine.js";
+import { runPythonCli } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { validateToolInput } from "../../security/input-validator.js";
 import { resolveProjectId } from "./context.js";
 import { AdvisoryReviewOutputSchema } from "../../generated/advisory_review_output.js";
+import { classifyPythonError } from "./python_error.js";
 function clipArg(value, maxChars) {
     const v = value.trim();
     if (v.length <= maxChars)
@@ -65,9 +66,10 @@ export async function advisoryReview(input) {
         args.push("--product-intent-refs", input.product_intent_refs.join(","));
     }
     const timeoutMs = mode === "triage" ? 30_000 : 180_000;
-    const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, { timeoutMs });
+    const { code, stdout, stderr } = await runPythonCli(args, { timeoutMs });
     if (code !== 0) {
-        throw new Error(stderr?.trim() ? `advisory_review_engine_error: ${stderr.trim()}` : `advisory_review_exit_code: ${code}`);
+        const classified = classifyPythonError(stderr ?? "", code, "Advisory Review");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(stdout);
     if (!parsed.ok) {

package/build/tools/vibe_pm/bridge_build_seed.js

@@ -0,0 +1,164 @@
+// adapters/mcp-ts/src/tools/vibe_pm/bridge_build_seed.ts
+// vibe_pm.bridge_build_seed - Create runs/<run_id>/bridge/work_order_seed.json
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId, resolveRunId, getRunContext } from "./context.js";
+import { BridgeConfirmedReferenceFileSchema } from "../../generated/bridge_confirmed_reference_file.js";
+import { BridgeReferencesFileSchema } from "../../generated/bridge_references_file.js";
+import { BridgeWorkOrderSeedFileSchema } from "../../generated/bridge_work_order_seed_file.js";
+function sanitizeStrings(values, maxItems) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter(Boolean)
+        .slice(0, maxItems);
+}
+function toRelPath(basePath, absPath) {
+    const rel = path.relative(basePath, absPath);
+    return rel.replace(/\\\\/g, "/");
+}
+function looksKorean(text) {
+    return /[가-힣]/.test(text);
+}
+export async function bridgeBuildSeed(input, basePath = process.cwd()) {
+    validateToolInput({ project_id: input.project_id, run_id: input.run_id });
+    const resolvedRun = resolveRunId(input.run_id ?? input.project_id, basePath);
+    const run_id = resolvedRun.run_id;
+    const project_id = resolveProjectId(run_id, basePath);
+    const context = getRunContext(run_id, basePath);
+    const bridgeDir = path.join(context.runs_path, "bridge");
+    const confirmedPathAbs = path.join(bridgeDir, "confirmed_reference.json");
+    const referencesPathAbs = path.join(bridgeDir, "references.json");
+    const seedPathAbs = path.join(bridgeDir, "work_order_seed.json");
+    // Rule C: confirmed_reference 없이는 seed 생성 불가
+    let confirmedRaw;
+    try {
+        confirmedRaw = JSON.parse(await fs.readFile(confirmedPathAbs, "utf-8"));
+    }
+    catch {
+        throw new Error("confirmed_reference.json이 없어 seed를 만들 수 없습니다. 먼저 레퍼런스를 확정하세요.");
+    }
+    const confirmed = BridgeConfirmedReferenceFileSchema.parse(confirmedRaw);
+    const overwrite = input?.overwrite !== false;
+    if (!overwrite) {
+        try {
+            await fs.access(seedPathAbs);
+            throw new Error("work_order_seed.json이 이미 존재합니다. overwrite=true로 다시 시도하세요.");
+        }
+        catch {
+            // ok (does not exist)
+        }
+    }
+    let rawIntent = typeof input?.raw_user_intent === "string" ? input.raw_user_intent.trim() : "";
+    if (!rawIntent) {
+        try {
+            const refsRaw = JSON.parse(await fs.readFile(referencesPathAbs, "utf-8"));
+            const refs = BridgeReferencesFileSchema.parse(refsRaw);
+            rawIntent = typeof refs.query?.raw_user_intent === "string" ? refs.query.raw_user_intent.trim() : "";
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!rawIntent)
+        rawIntent = "Clarify requirements using the selected reference.";
+    const isKo = looksKorean(rawIntent);
+    const goal = typeof input?.goal === "string" && input.goal.trim()
+        ? input.goal.trim()
+        : isKo
+            ? `레퍼런스(${confirmed.selected.title}) 기준으로 요구사항을 정규화한다: ${rawIntent}`
+            : `Normalize requirements using reference (${confirmed.selected.title}): ${rawIntent}`;
+    const userStory = typeof input?.user_story === "string" && input.user_story.trim()
+        ? input.user_story.trim()
+        : isKo
+            ? `사용자로서, 나는 ${rawIntent}을(를) 원한다. 그래서 원하는 결과를 빠르게 얻을 수 있다.`
+            : `As a user, I want ${rawIntent} so I can get the intended result quickly.`;
+    const acceptance = sanitizeStrings(input?.acceptance, 12);
+    const acceptanceFinal = acceptance.length >= 3
+        ? acceptance
+        : isKo
+            ? [
+                "레퍼런스 확정(confirmed_reference.json)이 기록된다",
+                "seed(work_order_seed.json)이 생성된다",
+                "create_work_order가 seed를 소비한다"
+            ]
+            : [
+                "Confirmed reference is written (confirmed_reference.json)",
+                "Seed is written (work_order_seed.json)",
+                "create_work_order consumes the seed when it exists"
+            ];
+    const constraints = mergeOverrides(sanitizeStrings(input?.constraints, 12), sanitizeStrings(confirmed?.user_confirmation?.must_have_overrides, 12), 12);
+    const nonGoals = mergeOverrides(sanitizeStrings(input?.non_goals, 8), sanitizeStrings(confirmed?.user_confirmation?.must_not_overrides, 8), 8);
+    const scopeSeedRaw = input?.scope_seed;
+    const scope_seed = scopeSeedRaw && typeof scopeSeedRaw === "object"
+        ? {
+            include: sanitizeStrings(scopeSeedRaw?.include, 20),
+            exclude: sanitizeStrings(scopeSeedRaw?.exclude, 20),
+            do_not_touch: sanitizeStrings(scopeSeedRaw?.do_not_touch, 20)
+        }
+        : {
+            include: ["src/**", "tests/**"],
+            exclude: ["**/.vibe/**", "config/**"],
+            do_not_touch: ["config/**", ".env*", "*.pem", "*.key", ".vibe/**"]
+        };
+    if (scope_seed.include.length === 0)
+        scope_seed.include = ["src/**"];
+    const preferredStackHint = typeof input?.preferred_stack_hint === "string" ? input.preferred_stack_hint : "";
+    const riskNotes = sanitizeStrings(input?.risk_notes, 8);
+    const nowIso = new Date().toISOString();
+    const seedDoc = BridgeWorkOrderSeedFileSchema.parse({
+        schema_version: "bridge.work_order_seed.v1",
+        run_id,
+        project_id,
+        created_at: nowIso,
+        intent: {
+            goal,
+            user_story: userStory,
+            acceptance: acceptanceFinal,
+            constraints,
+            non_goals: nonGoals
+        },
+        scope_seed,
+        reference: {
+            key: confirmed.selected.key,
+            title: confirmed.selected.title,
+            primary_link: confirmed.selected.primary_link,
+            takeaways: []
+        },
+        handoff: {
+            preferred_stack_hint: preferredStackHint,
+            risk_notes: riskNotes
+        }
+    });
+    if (input?.write_files !== false) {
+        await fs.mkdir(bridgeDir, { recursive: true });
+        await fs.writeFile(seedPathAbs, JSON.stringify(seedDoc, null, 2) + "\n", "utf-8");
+    }
+    const out = {
+        success: true,
+        project_id,
+        run_id,
+        seed_path: toRelPath(basePath, seedPathAbs),
+        next_action: {
+            tool: "vibe_pm.create_work_order",
+            reason: "seed를 기반으로 작업 지시서를 발행하세요."
+        }
+    };
+    return out;
+}
+function mergeOverrides(base, overrides, maxItems) {
+    const seen = new Set();
+    const out = [];
+    for (const x of [...base, ...overrides]) {
+        const v = typeof x === "string" ? x.trim() : "";
+        if (!v || seen.has(v))
+            continue;
+        seen.add(v);
+        out.push(v);
+        if (out.length >= maxItems)
+            break;
+    }
+    return out;
+}

package/build/tools/vibe_pm/bridge_confirm_reference.js

@@ -0,0 +1,91 @@
+// adapters/mcp-ts/src/tools/vibe_pm/bridge_confirm_reference.ts
+// vibe_pm.bridge_confirm_reference - Create runs/<run_id>/bridge/confirmed_reference.json
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId, resolveRunId, getRunContext } from "./context.js";
+import { BridgeReferencesFileSchema } from "../../generated/bridge_references_file.js";
+import { BridgeConfirmedReferenceFileSchema } from "../../generated/bridge_confirmed_reference_file.js";
+function sanitizeStrings(values, maxItems) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter(Boolean)
+        .slice(0, maxItems);
+}
+function toRelPath(basePath, absPath) {
+    const rel = path.relative(basePath, absPath);
+    return rel.replace(/\\\\/g, "/");
+}
+export async function bridgeConfirmReference(input, basePath = process.cwd()) {
+    validateToolInput({ project_id: input.project_id, run_id: input.run_id });
+    const resolvedRun = resolveRunId(input.run_id ?? input.project_id, basePath);
+    const run_id = resolvedRun.run_id;
+    const project_id = resolveProjectId(run_id, basePath);
+    const context = getRunContext(run_id, basePath);
+    const bridgeDir = path.join(context.runs_path, "bridge");
+    const referencesPathAbs = path.join(bridgeDir, "references.json");
+    const confirmedPathAbs = path.join(bridgeDir, "confirmed_reference.json");
+    let referencesRaw;
+    try {
+        referencesRaw = JSON.parse(await fs.readFile(referencesPathAbs, "utf-8"));
+    }
+    catch {
+        throw new Error("references.json이 없어 레퍼런스를 확정할 수 없습니다. 먼저 레퍼런스 후보를 생성하세요.");
+    }
+    const references = BridgeReferencesFileSchema.parse(referencesRaw);
+    const selectedKey = String(input?.selected_key ?? "").trim();
+    if (!["A", "B", "C"].includes(selectedKey)) {
+        throw new Error("selected_key는 A/B/C 중 하나여야 합니다.");
+    }
+    const selected = (references.candidates ?? []).find((c) => c?.key === selectedKey);
+    if (!selected) {
+        throw new Error("선택한 레퍼런스를 찾을 수 없습니다. A/B/C 중 다시 선택해주세요.");
+    }
+    const rawAnswer = String(input?.raw_answer ?? "").trim();
+    if (!rawAnswer)
+        throw new Error("raw_answer is required");
+    const notes = typeof input?.notes === "string" ? input.notes : "";
+    const mustHave = sanitizeStrings(input?.must_have_overrides, 12);
+    const mustNot = sanitizeStrings(input?.must_not_overrides, 12);
+    const nowIso = new Date().toISOString();
+    const confirmedDoc = BridgeConfirmedReferenceFileSchema.parse({
+        schema_version: "bridge.confirmed_reference.v1",
+        run_id,
+        project_id,
+        created_at: nowIso,
+        selected: {
+            key: selectedKey,
+            title: selected.title,
+            kind: selected.kind,
+            primary_link: selected.links.primary
+        },
+        user_confirmation: {
+            raw_answer: rawAnswer,
+            notes,
+            must_have_overrides: mustHave,
+            must_not_overrides: mustNot
+        }
+    });
+    if (input?.write_files !== false) {
+        await fs.mkdir(bridgeDir, { recursive: true });
+        await fs.writeFile(confirmedPathAbs, JSON.stringify(confirmedDoc, null, 2) + "\n", "utf-8");
+    }
+    const out = {
+        success: true,
+        project_id,
+        run_id,
+        confirmed_reference_path: toRelPath(basePath, confirmedPathAbs),
+        selected: {
+            key: confirmedDoc.selected.key,
+            title: confirmedDoc.selected.title,
+            primary_link: confirmedDoc.selected.primary_link
+        },
+        next_action: {
+            tool: "vibe_pm.bridge_build_seed",
+            reason: "확정된 레퍼런스를 기반으로 seed를 생성하세요."
+        }
+    };
+    return out;
+}

package/build/tools/vibe_pm/bridge_generate_references.js

@@ -0,0 +1,258 @@
+// adapters/mcp-ts/src/tools/vibe_pm/bridge_generate_references.ts
+// vibe_pm.bridge_generate_references - Create runs/<run_id>/bridge/references.json (A/B/C)
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { decode as decodeMsgpack } from "@msgpack/msgpack";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId, resolveRunId, getRunContext } from "./context.js";
+import { BridgeReferencesFileSchema } from "../../generated/bridge_references_file.js";
+import { searchOss } from "./search_oss.js";
+function sanitizeStrings(values, maxItems) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter(Boolean)
+        .slice(0, maxItems);
+}
+function keyForIndex(i) {
+    return i === 0 ? "A" : i === 1 ? "B" : "C";
+}
+function toRelPath(basePath, absPath) {
+    const rel = path.relative(basePath, absPath);
+    return rel.replace(/\\\\/g, "/");
+}
+export async function bridgeGenerateReferences(input, basePath = process.cwd()) {
+    validateToolInput({ project_id: input.project_id, run_id: input.run_id });
+    const resolvedRun = resolveRunId(input.run_id ?? input.project_id, basePath);
+    const run_id = resolvedRun.run_id;
+    const project_id = resolveProjectId(run_id, basePath);
+    const context = getRunContext(run_id, basePath);
+    const rawUserIntent = String(input.raw_user_intent ?? "").trim();
+    let keywords = sanitizeStrings(input?.keywords, 12);
+    if (!rawUserIntent)
+        throw new Error("raw_user_intent is required");
+    if (keywords.length === 0) {
+        keywords = deriveKeywordsFromContextScan({ basePath, runDirAbs: context.runs_path });
+        if (keywords.length === 0) {
+            keywords = ["reference"];
+        }
+    }
+    const constraints = sanitizeStrings(input?.constraints, 12);
+    const mustHave = sanitizeStrings(input?.must_have, 12);
+    const mustNot = sanitizeStrings(input?.must_not, 12);
+    const maxCandidates = typeof input?.max_candidates === "number" ? Math.trunc(input.max_candidates) : 3;
+    const maxK = maxCandidates >= 2 && maxCandidates <= 3 ? maxCandidates : 3;
+    const warnings = [];
+    // Candidate sources:
+    // 1) candidates_seed (explicit) - deterministic + test-friendly
+    // 2) best-effort OSS search (vibe_pm.search_oss) - may fail offline
+    // 3) fallback patterns (always available)
+    const seedCandidates = Array.isArray(input?.candidates_seed) ? input.candidates_seed : [];
+    const candidates = [];
+    if (seedCandidates.length > 0) {
+        warnings.push("OSS_SEARCH_SKIPPED: candidates_seed provided");
+        for (const c of seedCandidates.slice(0, maxK)) {
+            const obj = c;
+            const title = typeof obj?.title === "string" ? obj.title.trim() : "";
+            const kind = typeof obj?.kind === "string" ? obj.kind : "doc";
+            const primary_link = typeof obj?.primary_link === "string" ? obj.primary_link.trim() : "";
+            if (!title || !primary_link)
+                continue;
+            candidates.push({
+                title,
+                kind,
+                why_similar: typeof obj?.why_similar === "string" ? obj.why_similar : "유사 레퍼런스",
+                fit_summary: typeof obj?.fit_summary === "string" ? obj.fit_summary : "",
+                confidence: 4,
+                links: { primary: primary_link, secondary: [] },
+                evidence: { source: "manual", highlights: [] }
+            });
+        }
+    }
+    else {
+        try {
+            const oss = await searchOss({
+                project_id,
+                run_id,
+                intent: rawUserIntent.slice(0, 200),
+                keywords,
+                write_evidence: true
+            });
+            for (const c of (oss.candidates ?? []).slice(0, maxK)) {
+                const repo = typeof c?.repo === "string" ? c.repo.trim() : "";
+                const url = typeof c?.url === "string" ? c.url.trim() : "";
+                const desc = typeof c?.description === "string" ? c.description : "";
+                if (!repo || !url)
+                    continue;
+                candidates.push({
+                    title: repo,
+                    kind: "oss_repo",
+                    why_similar: desc || "유사 기능을 가진 OSS 레퍼런스",
+                    fit_summary: desc || "",
+                    confidence: 3,
+                    links: { primary: url, secondary: [] },
+                    evidence: { source: "github", highlights: [] }
+                });
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            warnings.push(`OSS_SEARCH_FAILED: ${msg}`);
+        }
+    }
+    // Ensure at least 2 candidates by adding deterministic fallbacks.
+    const fallback = [
+        {
+            title: "Minimal Bridge Protocol",
+            kind: "doc",
+            why_similar: "A/B/C 선택 → 확인 기록 → seed 생성의 최소 프로토콜",
+            fit_summary: "도입 난이도 낮음",
+            confidence: 3,
+            links: { primary: "https://example.com/bridge-protocol", secondary: [] },
+            evidence: { source: "manual", highlights: [] }
+        },
+        {
+            title: "Local Evidence Pattern (Zoekt/Ripgrep)",
+            kind: "pattern",
+            why_similar: "로컬 코드베이스 근거를 모아 구현 방향을 고정",
+            fit_summary: "증거 기반 정렬",
+            confidence: 3,
+            links: { primary: "https://example.com/zoekt", secondary: [] },
+            evidence: { source: "manual", highlights: [] }
+        },
+        {
+            title: "Template Pin Pattern",
+            kind: "pattern",
+            why_similar: "레퍼런스를 핀으로 고정하고 작업 범위를 줄이는 방식",
+            fit_summary: "합의/반복 비용 감소",
+            confidence: 3,
+            links: { primary: "https://example.com/pattern-template-pin", secondary: [] },
+            evidence: { source: "manual", highlights: [] }
+        }
+    ];
+    for (const f of fallback) {
+        if (candidates.length >= 2)
+            break;
+        candidates.push(f);
+    }
+    const picked = candidates.slice(0, maxK).map((c, i) => ({
+        key: keyForIndex(i),
+        ...c
+    }));
+    const nowIso = new Date().toISOString();
+    const referencesDoc = BridgeReferencesFileSchema.parse({
+        schema_version: "bridge.references.v1",
+        run_id,
+        project_id,
+        created_at: nowIso,
+        query: {
+            raw_user_intent: rawUserIntent,
+            keywords,
+            constraints,
+            must_have: mustHave,
+            must_not: mustNot
+        },
+        candidates: picked
+    });
+    const bridgeDir = path.join(context.runs_path, "bridge");
+    const referencesPathAbs = path.join(bridgeDir, "references.json");
+    if (input?.write_files !== false) {
+        await fs.mkdir(bridgeDir, { recursive: true });
+        await fs.writeFile(referencesPathAbs, JSON.stringify(referencesDoc, null, 2) + "\n", "utf-8");
+    }
+    const out = {
+        success: true,
+        project_id,
+        run_id,
+        references_path: toRelPath(basePath, referencesPathAbs),
+        candidates: picked.map((c) => ({ key: c.key, title: c.title, primary_link: c.links.primary })),
+        warnings,
+        next_action: {
+            tool: "vibe_pm.bridge_confirm_reference",
+            reason: "A/B/C 중 하나를 선택해 레퍼런스를 확정하세요."
+        }
+    };
+    return out;
+}
+function deriveKeywordsFromContextScan(args) {
+    const ingressDir = path.join(args.runDirAbs, "ingress");
+    const repoMapAbs = path.join(ingressDir, "repo_map.msgpack");
+    const riskFlagsAbs = path.join(ingressDir, "risk_flags.json");
+    const summaryAbs = path.join(ingressDir, "ingress_summary.json");
+    const out = [];
+    const push = (s) => {
+        const v = (s ?? "").trim();
+        if (!v)
+            return;
+        out.push(v);
+    };
+    // 1) ingress_summary.json (cheap JSON)
+    try {
+        if (fsSync.existsSync(summaryAbs)) {
+            const raw = JSON.parse(fsSync.readFileSync(summaryAbs, "utf-8"));
+            const hint = typeof raw?.high_level?.repo_kind_hint === "string" ? raw.high_level.repo_kind_hint : "";
+            hint.split(/[\s+]+/).forEach(push);
+            const reasons = Array.isArray(raw?.high_level?.clarification_reasons) ? raw.high_level.clarification_reasons : [];
+            for (const r of reasons) {
+                if (typeof r === "string" && r.trim())
+                    push(r.trim().toLowerCase());
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    // 2) risk_flags.json (cheap JSON)
+    try {
+        if (fsSync.existsSync(riskFlagsAbs)) {
+            const raw = JSON.parse(fsSync.readFileSync(riskFlagsAbs, "utf-8"));
+            const flags = raw?.flags ?? {};
+            if (flags?.monorepo_suspected)
+                push("monorepo");
+            if (flags?.entrypoint_ambiguous)
+                push("entrypoint");
+            if (flags?.has_env_files)
+                push("env");
+        }
+    }
+    catch {
+        // ignore
+    }
+    // 3) repo_map.msgpack (best-effort, still deterministic)
+    try {
+        if (fsSync.existsSync(repoMapAbs)) {
+            const decoded = decodeMsgpack(fsSync.readFileSync(repoMapAbs));
+            const summary = decoded?.summary ?? {};
+            const topDirs = Array.isArray(summary?.top_dirs) ? summary.top_dirs : [];
+            for (const d of topDirs.slice(0, 8)) {
+                if (typeof d === "string" && d.trim())
+                    push(d.trim());
+            }
+            const signals = Array.isArray(summary?.signals) ? summary.signals : [];
+            for (const s of signals.slice(0, 8)) {
+                if (typeof s === "string" && s.trim())
+                    push(s.trim());
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Normalize + dedupe + clamp
+    const seen = new Set();
+    const normalized = [];
+    for (const k of out) {
+        const v = k.toLowerCase().replace(/[^\w-]+/g, " ").trim().split(/\s+/)[0] ?? "";
+        if (!v)
+            continue;
+        if (seen.has(v))
+            continue;
+        seen.add(v);
+        normalized.push(v);
+        if (normalized.length >= 12)
+            break;
+    }
+    return normalized;
+}

package/build/tools/vibe_pm/briefing.js

@@ -1,13 +1,17 @@
 // adapters/mcp-ts/src/tools/vibe_pm/briefing.ts
 // vibe_pm.briefing - Project intake and structuring
+import * as fsPromises from "node:fs/promises";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { runEngine } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
-import { generateRunId, resolveProjectId, ensureRunsDir, getRunsDir } from "./context.js";
+import { generateRunId, resolveProjectId, ensureRunsDir, getRunsDir, getRunContext } from "./context.js";
 import { validateBriefingInput } from "../../security/input-validator.js";
 import { ensureResearchForBriefing } from "./modules/ensure.js";
 import { memorySync } from "./memory_sync.js";
 import { getAuthGate } from "../../auth/index.js";
 import { SpecHighDecisionDraftOutputSchema } from "../../generated/spec_high_decision_draft_output.js";
+import { IngressResolutionFileSchema } from "../../generated/ingress_resolution_file.js";
 import { applyPromptDensityHysteresis, computePromptDensity, loadLatestPromptDensityForProject, savePromptDensity } from "./intent/prompt_density.js";
 import { generateIntentFromBriefing, saveIntentWithMarkdown } from "./intent/index.js";
 /**
@@ -39,6 +43,27 @@ export async function briefing(input) {
     if (initResult.code !== 0) {
         throw new Error(`프로젝트 초기화 실패: ${initResult.stderr || "알 수 없는 오류"}`);
     }
+    // Ingress v2 (best-effort): record ingress_resolution.json so downstream tools can gate deterministically.
+    try {
+        const ctx = getRunContext(run_id, basePath);
+        const ingressDir = path.join(ctx.runs_path, "ingress");
+        await fsPromises.mkdir(ingressDir, { recursive: true });
+        const doc = IngressResolutionFileSchema.parse({
+            schema_version: "ingress.resolution.v2",
+            run_id,
+            project_id,
+            workspace_path: path.resolve(basePath),
+            resolution: "INGRESS_RESOLVED_NEW_TASK",
+            has_vibe_state: fs.existsSync(path.join(basePath, ".vibe")),
+            context_scan_required: false,
+            context_scan_completed: false,
+            created_at: new Date().toISOString()
+        });
+        await fsPromises.writeFile(path.join(ingressDir, "ingress_resolution.json"), JSON.stringify(doc, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // ignore (best-effort)
+    }
     // Step 2: Set the project brief as input
     const inputSetResult = await runEngine("spec-high", ["--root", "engines/spec_high", "input-set", run_id, "--text", input.project_brief], { timeoutMs: 60_000 });
     if (inputSetResult.code !== 0) {