@asc-agent/runtime 0.1.0

package/dist/core/resolver/load.d.ts

@@ -0,0 +1,121 @@
+import { OperationalPreset, ProfileLock, ProjectProfile, UserOverride } from '../../schemas/profile.ts';
+import type { MonitorConfig } from '../monitor/signals.ts';
+import type { OwnershipMap } from '../policy/ownership.ts';
+import { type ConfigLayer, type ResolvedProfile } from './resolve.ts';
+export type LoadedLayers = {
+    profile: ProjectProfile;
+    profileSource: string;
+    preset?: OperationalPreset;
+    presetSource?: string;
+    override?: UserOverride;
+};
+export type ResolvedRuntime = {
+    resolved: ResolvedProfile;
+    layers: LoadedLayers;
+    /** Monitor에 그대로 넘길 수 있는 형태로 합쳐 둔다. */
+    monitor: MonitorConfig;
+    canonicalSources: string[];
+    /** 승인 권한자 → 채널:actor. Override가 채운다 (OM §11.6). */
+    controllerIdentities: Record<string, string[]>;
+    /** 역할 → 쓰기 영역·결정권. Profile만 선언한다 (C-04 §6). 없는 것이 정상이다. */
+    ownership?: OwnershipMap;
+    degraded: string[];
+};
+export declare const digest: (value: unknown) => string;
+/**
+ * 설치 경로에서 Profile과 Preset을, 프로젝트에서 Override를 읽는다.
+ * Override가 없는 것은 정상이다 — 팀 설정만으로도 돌아가야 한다.
+ */
+export declare function loadLayers(input: {
+    installRoot: string;
+    profileId: string;
+    presetId?: string;
+    overridePath?: string;
+}): Promise<LoadedLayers>;
+/** Vanilla Defaults — 어느 프로젝트에서도 풀리지 않는 바닥 (OM §5.2). */
+export declare function vanillaLayer(): ConfigLayer;
+export declare function toLayers(loaded: LoadedLayers): ConfigLayer[];
+export declare function resolveRuntime(loaded: LoadedLayers, availableCapabilities: readonly string[], ascVersion: string): {
+    ok: false;
+    failures: import("./resolve.ts").ResolveFailure[];
+} | {
+    ok: false;
+    failures: {
+        kind: "INCOMPATIBLE_CORE";
+        detail: string;
+    }[];
+    runtime?: undefined;
+} | {
+    ok: true;
+    runtime: ResolvedRuntime;
+    failures?: undefined;
+};
+export declare function buildLock(input: {
+    runtime: ResolvedRuntime;
+    ascVersion: string;
+    adapters: Record<string, string>;
+    generatedAt: string;
+}): ProfileLock;
+/**
+ * 이전 lock을 무손실로 옮긴다 (OM §4.9·§7.4). 덮어쓰기만 하면 어떤 조합으로 돌렸는지가
+ * 사라지고, 그러면 "그때는 됐는데"를 재현할 방법이 없다.
+ * 파일명에 생성 시각과 digest를 함께 넣어 같은 날 여러 번 바꿔도 부딪히지 않게 한다.
+ */
+export declare function archiveLock(ascRoot: string, previous: ProfileLock): Promise<string>;
+export type LockDrift = {
+    field: string;
+    locked: string;
+    current: string;
+};
+/**
+ * lock과 지금을 견준다. **자동으로 다시 만들지 않는다** — 무엇이 달라졌는지 사람이 보고
+ * 정하는 것이 이 파일의 존재 이유다 (OM §4.9).
+ */
+export declare function compareLock(locked: ProfileLock, current: ProfileLock): LockDrift[];
+export type BootstrapOutcome = {
+    ok: true;
+    runtime: ResolvedRuntime;
+    lock: ProfileLock;
+}
+/** attach 전이다. `.asc/` 자체가 없다 — 설정 없이 도는 경로만 허용된다. */
+ | {
+    ok: false;
+    reason: 'NOT_ATTACHED';
+}
+/**
+ * `.asc/`는 있는데 lock이 없다. init이 중간에 죽었거나 lock을 잃은 상태이며,
+ * attach 전과 구분되지 않으면 무엇으로 도는지 모르는 채 굴러간다.
+ */
+ | {
+    ok: false;
+    reason: 'BROKEN_ATTACHMENT';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'RESOLVE_FAILED';
+    details: string[];
+}
+/** 지금 조합이 lock과 다르다. 무엇으로 돌지 사람이 정해야 한다. */
+ | {
+    ok: false;
+    reason: 'LOCK_DRIFT';
+    drifts: LockDrift[];
+    runtime: ResolvedRuntime;
+};
+/**
+ * 모든 Run이 시작 전에 지나는 문 (OM §4.9). 지금 계층을 다시 합쳐 lock과 견주고,
+ * 어긋나면 멈춘다.
+ *
+ * **자동으로 다시 resolve하거나 lock을 덮지 않는다.** 설정이 바뀐 채로 계속 돌면 그 Run이
+ * 무엇을 근거로 판단했는지 나중에 알 수 없고, 사람이 바꾼 것인지 무언가 어긋난 것인지도
+ * 구분되지 않는다. 멈추고 묻는 편이 싸다.
+ */
+export declare function bootstrapGuard(input: {
+    ascRoot: string;
+    installRoot: string;
+    profileId?: string;
+    presetId?: string;
+    capabilities: readonly string[];
+    adapters: Record<string, string>;
+    ascVersion: string;
+}): Promise<BootstrapOutcome>;

package/dist/core/resolver/load.js

@@ -0,0 +1,246 @@
+// Profile Resolver — 파일에서 계층을 읽어 하나의 Resolved Profile을 만들고,
+// 그 조합을 재현할 수 있게 lock에 박아 둔다 (OM §4.7~4.9).
+//
+// 산출물 셋의 성격이 다르다:
+//   resolved-profile — 언제든 다시 만들 수 있는 파생물. 지워도 된다.
+//   ASC.md           — 사람과 Agent가 읽는 생성물. 정책의 정본이 아니다 (OM §7.1).
+//   profile.lock     — 재현성 기록. Resolver만 쓰고, 저절로 갱신되지 않는다.
+//
+// 마지막 것이 앞의 둘과 다른 이유: 파생물은 낡으면 다시 만들면 그만이지만, lock이 저 혼자
+// 갱신되면 "무엇으로 돌렸는지"를 영영 잃는다. 그래서 불일치는 고쳐 주지 않고 알린다.
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { access, mkdir, readFile, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { OperationalPreset, ProfileLock, ProjectProfile, UserOverride } from "../../schemas/profile.js";
+import { resolveProfile } from "./resolve.js";
+import { satisfies } from "./version.js";
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const digest = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 16);
+async function readJson(path) {
+    return JSON.parse(await readFile(path, 'utf8'));
+}
+/**
+ * 설치 경로에서 Profile과 Preset을, 프로젝트에서 Override를 읽는다.
+ * Override가 없는 것은 정상이다 — 팀 설정만으로도 돌아가야 한다.
+ */
+export async function loadLayers(input) {
+    const profileSource = join(input.installRoot, 'profiles', input.profileId, 'profile.json');
+    const profile = ProjectProfile.parse(await readJson(profileSource));
+    let preset;
+    let presetSource;
+    if (input.presetId) {
+        presetSource = join(input.installRoot, 'presets', `${input.presetId}.json`);
+        preset = OperationalPreset.parse(await readJson(presetSource));
+    }
+    let override;
+    if (input.overridePath) {
+        try {
+            override = UserOverride.parse(await readJson(input.overridePath));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return {
+        profile,
+        profileSource,
+        ...(preset ? { preset } : {}),
+        ...(presetSource ? { presetSource } : {}),
+        ...(override ? { override } : {}),
+    };
+}
+/** Vanilla Defaults — 어느 프로젝트에서도 풀리지 않는 바닥 (OM §5.2). */
+export function vanillaLayer() {
+    return {
+        id: 'vanilla',
+        kind: 'vanilla',
+        // 외부 write와 정본 수정은 Session 계약으로 열 수 없다. 나가는 길은 Execution Grant뿐이다.
+        hardDeny: ['external.write', 'canonical.modify', 'policy.change'],
+        softDeny: ['dependency.add', 'shared-module.change'],
+        roleScopes: { implementer: ['**'], researcher: ['**'], planner: ['**'], verifier: [] },
+    };
+}
+export function toLayers(loaded) {
+    const layers = [vanillaLayer()];
+    layers.push({
+        id: `profile:${loaded.profile.id}`,
+        kind: 'profile',
+        ...loaded.profile.policy,
+        requiredCapabilities: loaded.profile.requires.capabilities,
+        optionalCapabilities: loaded.profile.optionalCapabilities,
+    });
+    if (loaded.preset)
+        layers.push({ id: `preset:${loaded.preset.id}`, kind: 'preset', ...loaded.preset.policy });
+    if (loaded.override)
+        layers.push({ id: 'override:local', kind: 'override', ...loaded.override.policy });
+    return layers;
+}
+export function resolveRuntime(loaded, availableCapabilities, ascVersion) {
+    const result = resolveProfile(toLayers(loaded), availableCapabilities);
+    if (!result.ok)
+        return result;
+    // Profile이 요구한 Core 범위를 벗어나면 bootstrap 실패다. capability가 모자란 것과
+    // 같은 급으로 다룬다 — 맞지 않는 Core에서 도는 것이 없는 기능을 쓰는 것보다 낫지 않다.
+    const required = loaded.profile.requires.asc;
+    if (required) {
+        const check = satisfies(ascVersion, required);
+        if (!check.ok) {
+            return {
+                ok: false,
+                failures: [
+                    {
+                        kind: 'INCOMPATIBLE_CORE',
+                        detail: `Profile '${loaded.profile.id}' 는 ASC ${required} 를 요구한다 (${check.reason}: ${check.detail})`,
+                    },
+                ],
+            };
+        }
+    }
+    const monitor = {
+        identities: loaded.override?.monitorIdentities ?? [],
+        reasonSignals: loaded.profile.monitor.reasonSignals,
+        priorityLabels: loaded.profile.monitor.priorityLabels,
+        escalationLabels: loaded.profile.monitor.escalationLabels,
+        signalPriority: loaded.profile.monitor.signalPriority,
+        ...(loaded.profile.monitor.inboxSignals ? { inboxSignals: loaded.profile.monitor.inboxSignals } : {}),
+    };
+    const runtime = {
+        resolved: result.profile,
+        layers: loaded,
+        monitor,
+        canonicalSources: loaded.profile.canonical.sources.map((s) => s.id),
+        controllerIdentities: loaded.override?.controller.identities ?? {},
+        ...(loaded.profile.ownership ? { ownership: loaded.profile.ownership } : {}),
+        degraded: result.degraded,
+    };
+    return { ok: true, runtime };
+}
+// ── profile.lock ────────────────────────────────────────────────────────────
+export function buildLock(input) {
+    const { layers, resolved } = input.runtime;
+    return ProfileLock.parse({
+        schemaVersion: 1,
+        ascCore: { version: input.ascVersion },
+        profile: { id: layers.profile.id, source: layers.profileSource, digest: digest(layers.profile) },
+        ...(layers.preset && layers.presetSource
+            ? { preset: { id: layers.preset.id, source: layers.presetSource, digest: digest(layers.preset) } }
+            : {}),
+        ...(layers.override ? { overrideDigest: digest(layers.override) } : {}),
+        adapters: input.adapters,
+        capabilities: resolved.capabilities,
+        // 계층 하나만 달라져도 값이 바뀐다 — 무엇이 달라졌는지는 아래 compareLock이 짚는다
+        configurationDigest: digest({
+            profile: layers.profile,
+            preset: layers.preset ?? null,
+            override: layers.override ?? null,
+            capabilities: resolved.capabilities,
+            adapters: input.adapters,
+        }),
+        generatedAt: input.generatedAt,
+    });
+}
+/**
+ * 이전 lock을 무손실로 옮긴다 (OM §4.9·§7.4). 덮어쓰기만 하면 어떤 조합으로 돌렸는지가
+ * 사라지고, 그러면 "그때는 됐는데"를 재현할 방법이 없다.
+ * 파일명에 생성 시각과 digest를 함께 넣어 같은 날 여러 번 바꿔도 부딪히지 않게 한다.
+ */
+export async function archiveLock(ascRoot, previous) {
+    const dir = join(ascRoot, 'archive', 'profile-locks');
+    await mkdir(dir, { recursive: true });
+    const stamp = previous.generatedAt.replace(/[:.]/g, '-');
+    const destination = join(dir, `${stamp}-${previous.configurationDigest}.json`);
+    await rename(join(ascRoot, 'profile.lock'), destination);
+    return destination;
+}
+/**
+ * lock과 지금을 견준다. **자동으로 다시 만들지 않는다** — 무엇이 달라졌는지 사람이 보고
+ * 정하는 것이 이 파일의 존재 이유다 (OM §4.9).
+ */
+export function compareLock(locked, current) {
+    const drifts = [];
+    const check = (field, a, b) => {
+        if ((a ?? '(없음)') !== (b ?? '(없음)'))
+            drifts.push({ field, locked: a ?? '(없음)', current: b ?? '(없음)' });
+    };
+    check('ascCore.version', locked.ascCore.version, current.ascCore.version);
+    check('profile.id', locked.profile.id, current.profile.id);
+    check('profile.digest', locked.profile.digest, current.profile.digest);
+    check('preset.id', locked.preset?.id, current.preset?.id);
+    check('preset.digest', locked.preset?.digest, current.preset?.digest);
+    check('override.digest', locked.overrideDigest, current.overrideDigest);
+    check('capabilities', locked.capabilities.join(','), current.capabilities.join(','));
+    for (const name of new Set([...Object.keys(locked.adapters), ...Object.keys(current.adapters)])) {
+        check(`adapters.${name}`, locked.adapters[name], current.adapters[name]);
+    }
+    check('configurationDigest', locked.configurationDigest, current.configurationDigest);
+    return drifts;
+}
+/**
+ * 모든 Run이 시작 전에 지나는 문 (OM §4.9). 지금 계층을 다시 합쳐 lock과 견주고,
+ * 어긋나면 멈춘다.
+ *
+ * **자동으로 다시 resolve하거나 lock을 덮지 않는다.** 설정이 바뀐 채로 계속 돌면 그 Run이
+ * 무엇을 근거로 판단했는지 나중에 알 수 없고, 사람이 바꾼 것인지 무언가 어긋난 것인지도
+ * 구분되지 않는다. 멈추고 묻는 편이 싸다.
+ */
+export async function bootstrapGuard(input) {
+    let lockedRaw;
+    try {
+        lockedRaw = await readFile(join(input.ascRoot, 'profile.lock'), 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        // `.asc/`가 있느냐 없느냐가 갈림길이다. 없으면 아직 붙이지 않은 것이고,
+        // 있는데 lock만 없으면 붙이다 만 것이다 — 뒤엣것은 통과시키면 안 된다.
+        try {
+            await readFile(join(input.ascRoot, 'ASC.md'), 'utf8');
+        }
+        catch (inner) {
+            if (inner.code === 'ENOENT') {
+                const attached = await pathExists(input.ascRoot);
+                return attached
+                    ? { ok: false, reason: 'BROKEN_ATTACHMENT', detail: 'profile.lock 이 없다' }
+                    : { ok: false, reason: 'NOT_ATTACHED' };
+            }
+            throw inner;
+        }
+        return { ok: false, reason: 'BROKEN_ATTACHMENT', detail: 'ASC.md 는 있는데 profile.lock 이 없다' };
+    }
+    const locked = ProfileLock.parse(JSON.parse(lockedRaw));
+    const layers = await loadLayers({
+        installRoot: input.installRoot,
+        profileId: input.profileId ?? locked.profile.id,
+        ...(input.presetId ?? locked.preset?.id ? { presetId: input.presetId ?? locked.preset.id } : {}),
+        overridePath: join(input.ascRoot, 'override.json'),
+    });
+    const resolved = resolveRuntime(layers, input.capabilities, input.ascVersion);
+    if (!resolved.ok) {
+        return {
+            ok: false,
+            reason: 'RESOLVE_FAILED',
+            details: resolved.failures.map((f) => f.kind === 'POLICY' ? `${f.violation.kind}: ${f.violation.detail}` : `${f.kind}: ${f.detail}`),
+        };
+    }
+    const current = buildLock({
+        runtime: resolved.runtime,
+        ascVersion: input.ascVersion,
+        adapters: input.adapters,
+        // 시각은 비교 대상이 아니다 — 조합이 같은지만 본다
+        generatedAt: locked.generatedAt,
+    });
+    const drifts = compareLock(locked, current);
+    if (drifts.length > 0)
+        return { ok: false, reason: 'LOCK_DRIFT', drifts, runtime: resolved.runtime };
+    return { ok: true, runtime: resolved.runtime, lock: locked };
+}

package/dist/core/resolver/render.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedRuntime } from './load.ts';
+export declare function renderAscMd(runtime: ResolvedRuntime, generatedAt: string): string;
+/** 사람이 처음 채우는 파일. 한 번 만들고 나면 Resolver가 손대지 않는다. */
+export declare function renderControllerMd(profileId: string): string;

package/dist/core/resolver/render.js

@@ -0,0 +1,62 @@
+// ASC.md 생성 — Agent가 세션 시작할 때 맨 먼저 읽는 파일 (OM §7.1·§9).
+//
+// 이것은 **생성물**이지 정책의 정본이 아니다. Core Policy와 Profile/Preset/Override를
+// Resolver가 해석한 결과를 사람과 Agent가 읽기 좋게 옮겨 적은 것뿐이며, 직접 고치면
+// 다음 resolve에서 덮인다. 정책을 바꾸려면 입력 계층을 고치고 다시 만든다.
+//
+// controller.md는 여기서 만들지 않는다. 그건 사람이 쓰는 현재 지시이고 Resolver 입력이
+// 아니다 — 둘을 한 파일에 섞으면 "시스템 규칙"과 "오늘의 지시"가 구분되지 않는다.
+import { decisionDomains, lookupAuthority } from "../policy/ownership.js";
+export function renderAscMd(runtime, generatedAt) {
+    const { resolved, layers } = runtime;
+    const profile = layers.profile;
+    const lines = [];
+    lines.push('<!-- 생성물입니다. 직접 고치지 마세요 — 다음 resolve에서 덮입니다.', `     입력: ${resolved.policy.layers.join(' → ')}`, `     생성: ${generatedAt} -->`, '', `# Agent Session Control — ${profile.id}`, '', '이 파일은 지금 적용되는 운영 규칙이다. 정책을 바꾸려면 이 파일이 아니라', 'Profile · Preset · User Override를 고치고 다시 생성한다.', '', '## 부트스트랩 (모든 Run 공통)', '', '1. 이 파일 → `controller.md` → `state.md` → 자기 Session Contract → CHECKPOINT(있으면)', '2. Session Contract의 Canonical Sources를 **실제로 다시 읽는다**. 세션 파일의 요약을 믿지 않는다', '3. 정본이 기록된 baseline과 다르면 diff를 확인하고, 계약에 영향이 있으면 중단·보고한다', '', '## 절대 규칙', '', '- 이 목록의 행위는 Session Contract로 열 수 없다. Policy Exception으로도 열리지 않는다:', ...resolved.policy.hardDeny.map((item) => `  - \`${item}\``), '- 외부로 나가는 길은 Execution Grant 하나뿐이다. 승인은 게시 권한이 아니다', '- 미결은 임의로 확정하지 않는다 — UNRESOLVED로 회수한다', '- Verifier는 발견하고 반환한다. 고치지 않는다', '', '## Controller 허가가 필요한 행위', '', resolved.policy.softDeny.length > 0
+        ? '아래는 기본 금지다. 이번 세션에 한해 Controller가 Policy Exception을 주면 열린다:'
+        : '_없음_', ...resolved.policy.softDeny.map((item) => `- \`${item}\``), '', '## Role별 쓰기 범위', '', '| Role | 최대 범위 |', '|---|---|', ...Object.entries(resolved.policy.roleScopes).map(([role, scopes]) => `| ${role} | ${scopes.length > 0 ? scopes.map((s) => `\`${s}\``).join(', ') : '_없음_'} |`), '', 'Session Contract는 이보다 **좁아야** 한다. 넓은 범위를 요청하면 발급이 거절된다.', '', '## 정본 (Canonical Sources)', '', '| id | provider | ref | 경로 |', '|---|---|---|---|', ...profile.canonical.sources.map((s) => `| ${s.id} | ${s.provider} | ${s.ref ?? '—'} | ${s.paths.length > 0 ? s.paths.join(', ') : '—'} |`), '', '스냅샷은 source별로 따로 기록한다. 하나로 뭉뚱그리지 않는다.', '', '## 파일별 쓰기 주체', '', '| 파일 | 쓰는 주체 |', '|---|---|', '| `ASC.md`, `cache/resolved-profile`, `profile.lock` | Resolver (생성물) |', '| `controller.md` | 사람 |', '| `state.md`, `blocks/`, `monitor/queue` | Controller 전용 |', '| `sessions/S-*` | 해당 Logical Session |', '| `monitor/M-*`, `monitor/inbox/`, `log-current` | Monitor / 처분 주체 |', '', '세션이 끝나면 Agent는 자기 세션 파일에 Handoff를 쓰는 데까지다.', 'state·block·queue 갱신은 Controller가 회수한 뒤에 한다.', '');
+    if (runtime.ownership) {
+        const domains = decisionDomains(runtime.ownership);
+        lines.push('## 책임 지도 (Ownership)', '', '| 역할 | 쓰기 영역 |', '|---|---|', ...Object.entries(runtime.ownership).map(([role, spec]) => `| ${role} | ${spec.paths.length > 0 ? spec.paths.map((p) => `\`${p}\``).join(', ') : '_없음 (결정만)_'} |`), '', '| 결정 영역 | 결정권자 |', '|---|---|', ...domains.map((domain) => {
+            const found = lookupAuthority(runtime.ownership, domain);
+            // domain 목록을 이 map에서 뽑았으므로 UNDECLARED는 나올 수 없다. 그래도 조용히
+            // 넘기지 않는다 — 표에 빈칸이 뜨면 "결정권자가 없다"로 읽힌다.
+            const who = found.kind === 'RESOLVED'
+                ? found.role
+                : found.kind === 'AMBIGUOUS'
+                    ? `**갈림 — ${found.candidates.join(' / ')}**`
+                    : '_선언 없음_';
+            return `| ${domain} | ${who} |`;
+        }), '', '결정권자가 갈린 영역은 프로젝트가 아직 정하지 않은 것이다. ASC는 그중 하나를 고르지', '않는다 — 그 결정이 필요한 세션은 발급 전에 멈춘다.', '');
+    }
+    if (Object.keys(profile.terminology).length > 0) {
+        lines.push('## 이 프로젝트의 말', '', '| Core 개념 | 이 프로젝트에서 |', '|---|---|');
+        for (const [core, local] of Object.entries(profile.terminology))
+            lines.push(`| ${core} | ${local} |`);
+        lines.push('');
+    }
+    if (runtime.degraded.length > 0) {
+        lines.push('## 지금 꺼져 있는 기능', '', ...runtime.degraded.map((cap) => `- \`${cap}\` — 제공하는 Adapter가 없다`), '', '없어도 Local 경로만으로 승인은 완결된다.', '');
+    }
+    return lines.join('\n');
+}
+/** 사람이 처음 채우는 파일. 한 번 만들고 나면 Resolver가 손대지 않는다. */
+export function renderControllerMd(profileId) {
+    return [
+        `# Controller Contract — ${profileId}`,
+        '',
+        '사람이 쓰는 파일이다. Resolver 입력이 아니므로 여기를 고쳐도 ASC.md는 다시 생성되지 않는다.',
+        '',
+        '## 현재 목표',
+        '- (여기에 지금 무엇을 하려는지 적는다)',
+        '',
+        '## 우선순위',
+        '- (포인터로 적는다. 내용을 복사하지 않는다)',
+        '',
+        '## 이번에 허용한 Policy Exception',
+        '- (세션 id와 항목을 함께 적는다. 없으면 비워 둔다)',
+        '',
+        '## Controller Attention',
+        '- ',
+        '',
+    ].join('\n');
+}

package/dist/core/resolver/resolve.d.ts

@@ -0,0 +1,42 @@
+import { type PolicyLayer, type PolicyViolation, type ResolvedPolicy } from '../policy/policy.ts';
+/** 계층 종류. 순서가 곧 우선순위이며, 아래로 갈수록 하위 계층이다 (OM §4.1). */
+export declare const LAYER_ORDER: readonly ["vanilla", "profile", "preset", "override"];
+export type LayerKind = (typeof LAYER_ORDER)[number];
+export type ConfigLayer = PolicyLayer & {
+    kind: LayerKind;
+    /** Core 호환 요구 (OM §4.10). 형식은 B-10에서 semver로 확정한다. */
+    requires?: {
+        asc?: string;
+    };
+};
+export type ResolvedProfile = {
+    policy: ResolvedPolicy;
+    /** 실제로 켜진 capability — required 전부 + 제공되는 optional. */
+    capabilities: string[];
+    /** 요구했지만 Adapter가 제공하지 못해 꺼진 것. 기능 비활성 사유로 사람에게 보인다. */
+    degradedCapabilities: string[];
+};
+export type ResolveFailure = {
+    kind: 'LAYER_ORDER';
+    detail: string;
+} | {
+    kind: 'MISSING_CAPABILITY';
+    detail: string;
+} | {
+    kind: 'POLICY';
+    violation: PolicyViolation;
+};
+export type ResolveResult = {
+    ok: true;
+    profile: ResolvedProfile;
+    degraded: string[];
+} | {
+    ok: false;
+    failures: ResolveFailure[];
+};
+/**
+ * 계층을 병합해 Resolved Profile을 만든다.
+ * @param layers 상위→하위 순으로 정렬되어 있어야 한다. 어긋나면 실패로 보고한다.
+ * @param available Adapter가 실제로 제공하는 capability 집합.
+ */
+export declare function resolveProfile(layers: readonly ConfigLayer[], available?: readonly string[]): ResolveResult;

package/dist/core/resolver/resolve.js

@@ -0,0 +1,51 @@
+// Profile Resolver 골격 — 구성 계층을 정해진 순서로 합쳐 Resolved Profile을 만든다
+// (OM §4.1·§4.7·§4.8). Resolved Profile은 Derived View다: 지워도 다시 만들 수 있어야 하고,
+// 누구도 직접 손대지 않는다.
+//
+// 여기 없는 것: profile.lock 기록·대조(B-10), YAML 로딩(B-10), ASC.md 생성(B-10).
+// 이 단계의 목적은 계층 순서와 병합·검증 규칙이 실제로 성립하는지 확인하는 것이다.
+import { mergePolicyLayers } from "../policy/policy.js";
+/** 계층 종류. 순서가 곧 우선순위이며, 아래로 갈수록 하위 계층이다 (OM §4.1). */
+export const LAYER_ORDER = ['vanilla', 'profile', 'preset', 'override'];
+/**
+ * 계층을 병합해 Resolved Profile을 만든다.
+ * @param layers 상위→하위 순으로 정렬되어 있어야 한다. 어긋나면 실패로 보고한다.
+ * @param available Adapter가 실제로 제공하는 capability 집합.
+ */
+export function resolveProfile(layers, available = []) {
+    const failures = [];
+    let previous = -1;
+    for (const layer of layers) {
+        const rank = LAYER_ORDER.indexOf(layer.kind);
+        if (rank < previous) {
+            failures.push({
+                kind: 'LAYER_ORDER',
+                detail: `'${layer.id}' (${layer.kind}) appears after a lower-precedence layer`,
+            });
+        }
+        previous = Math.max(previous, rank);
+    }
+    const { policy, violations } = mergePolicyLayers(layers);
+    for (const violation of violations)
+        failures.push({ kind: 'POLICY', violation });
+    const provided = new Set(available);
+    // required 미충족은 bootstrap 실패다 — 없는 기능을 있는 척 굴리지 않는다 (OM §4.7).
+    for (const capability of policy.requiredCapabilities) {
+        if (!provided.has(capability)) {
+            failures.push({ kind: 'MISSING_CAPABILITY', detail: `required capability '${capability}' is not available` });
+        }
+    }
+    // optional은 없으면 그 기능만 끈다. Messenger가 없어도 Local 경로는 살아 있어야 한다 (OM §11.3).
+    const degradedCapabilities = policy.optionalCapabilities.filter((capability) => !provided.has(capability));
+    if (failures.length > 0)
+        return { ok: false, failures };
+    const capabilities = [
+        ...policy.requiredCapabilities,
+        ...policy.optionalCapabilities.filter((capability) => provided.has(capability)),
+    ];
+    return {
+        ok: true,
+        profile: { policy, capabilities, degradedCapabilities },
+        degraded: degradedCapabilities,
+    };
+}

package/dist/core/resolver/version.d.ts

@@ -0,0 +1,22 @@
+export type Version = readonly [number, number, number];
+export declare function parseVersion(text: string): Version | null;
+export type RangeCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'UNPARSEABLE_RANGE';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'UNPARSEABLE_VERSION';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'OUT_OF_RANGE';
+    detail: string;
+};
+/**
+ * `version`이 `range`를 만족하는가.
+ * 판정할 수 없으면 만족한 것으로 넘기지 않는다 — 모르면 막는 쪽이 맞다.
+ */
+export declare function satisfies(version: string, range: string): RangeCheck;

package/dist/core/resolver/version.js

@@ -0,0 +1,49 @@
+// Profile이 요구하는 Core 버전 범위를 판정한다 (OM §4.10).
+//
+// 전체 semver range 문법(캐럿·틸드·`||`·x-range)을 지원하지 않는다. Profile이 적는 것은
+// "이 범위의 Core에서 돌아간다"는 하한과 상한이고, 그 이상은 필요하지 않았다.
+// 대신 문법 밖은 통과시키지 않고 실패로 돌려준다 — 읽지 못한 요구를 만족한 것으로
+// 넘기면 호환되지 않는 Core에서 그냥 돌아가 버린다.
+//
+// 지원: `>=0.1`, `<1.0`, `>1.2.3`, `<=2.0`, `=1.0.0`, 그리고 공백으로 이어 붙인 AND.
+export function parseVersion(text) {
+    const match = /^(\d+)\.(\d+)(?:\.(\d+))?$/.exec(text.trim());
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3] ?? 0)];
+}
+function compare(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i] ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * `version`이 `range`를 만족하는가.
+ * 판정할 수 없으면 만족한 것으로 넘기지 않는다 — 모르면 막는 쪽이 맞다.
+ */
+export function satisfies(version, range) {
+    const current = parseVersion(version);
+    if (!current)
+        return { ok: false, reason: 'UNPARSEABLE_VERSION', detail: version };
+    const clauses = range.trim().split(/\s+/).filter(Boolean);
+    if (clauses.length === 0)
+        return { ok: false, reason: 'UNPARSEABLE_RANGE', detail: range };
+    for (const clause of clauses) {
+        const match = /^(>=|<=|>|<|=)?\s*(\d+\.\d+(?:\.\d+)?)$/.exec(clause);
+        if (!match)
+            return { ok: false, reason: 'UNPARSEABLE_RANGE', detail: clause };
+        const operator = match[1] ?? '=';
+        const bound = parseVersion(match[2]);
+        const order = compare(current, bound);
+        const satisfied = operator === '>=' ? order >= 0
+            : operator === '<=' ? order <= 0
+                : operator === '>' ? order > 0
+                    : operator === '<' ? order < 0
+                        : order === 0;
+        if (!satisfied)
+            return { ok: false, reason: 'OUT_OF_RANGE', detail: `${version} 은 ${clause} 를 만족하지 않는다` };
+    }
+    return { ok: true };
+}