@asc-agent/runtime 0.2.1 → 0.3.0

package/dist/composition/runtime.js

@@ -5,12 +5,14 @@
 // 변경으로 끝난다 — 그것이 "provider 교체는 Binding 교체" 의 실제 모습이다.
 //
 // **Core는 이 파일을 import하지 않는다.** 방향은 언제나 Composition → Core다.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { resolveCapability } from "../core/binding/types.js";
 import { GitHubClient, discoverToken } from "../adapters/github/client.js";
 import { GitHubChangeContext, GitHubInventory, GitHubResourceContext } from "../adapters/github/context.js";
 import { GitHubEventSource } from "../adapters/github/event-source.js";
 import { GitHubScm } from "../adapters/github/scm.js";
-import { GitLabClient, discoverToken as discoverGitLabToken } from "../adapters/gitlab/client.js";
+import { GitLabClient, GlabApiClient, discoverToken as discoverGitLabToken, glabAvailable, } from "../adapters/gitlab/client.js";
 import { GitLabChangeContext, GitLabEventSource, GitLabInventory, GitLabResourceContext, } from "../adapters/gitlab/ports.js";
 import { JamMcpClient } from "../adapters/jam/mcp-client.js";
 import { JamEventSource } from "../adapters/jam/event-source.js";
@@ -19,7 +21,9 @@ const FACTORIES = {
     gitlab(binding, input, token) {
         // 자체 호스팅이 흔하다. 어디를 가리키는지는 발견 단계가 이미 알아냈으므로 같은 값을 쓴다.
         const baseUrl = input.endpointFor?.(binding);
-        const client = new GitLabClient({ token, ...(baseUrl ? { baseUrl } : {}) });
+        // 토큰이 빈 문자열이면 자격이 도구 안에 있다는 뜻이다 (P1-H). 값을 꺼내 오지 않고
+        // 그 도구에게 요청을 대신 보내 달라고 한다 — 읽기 전용이다.
+        const client = token === '' ? new GlabApiClient(defaultGlabRun) : new GitLabClient({ token, ...(baseUrl ? { baseUrl } : {}) });
         const project = binding.resource;
         return {
             eventSource: new GitLabEventSource({ client, project, perPage: input.perPage ?? 30 }),
@@ -44,11 +48,11 @@ const FACTORIES = {
         // JAM은 토큰을 받지 않는다 — 자격은 도구가 자기 안에서 관리하고 ASC는 상태만 읽는다.
         if (!input.jam)
             return {};
-        const client = new JamMcpClient({
+        const client = registerToolClient(new JamMcpClient({
             command: input.jam.command,
             ...(input.jam.args ? { args: input.jam.args } : {}),
             ...(input.jam.cwd ? { cwd: input.jam.cwd } : {}),
-        });
+        }));
         const projectKey = binding.resource;
         const timezone = input.jam.timezone;
         const inventory = new JamInventory({ client, projectKey, ...(timezone ? { timezone } : {}) });
@@ -64,8 +68,40 @@ const FACTORIES = {
         };
     },
 };
+const execFileAsync = promisify(execFile);
+/** glab 실행 통로. 실패는 예외로 올라가고, 호출측이 "없다"로 접는다. */
+const defaultGlabRun = async (command, args) => {
+    const { stdout } = await execFileAsync(command, [...args]);
+    return stdout;
+};
+/**
+ * gitlab 자격 찾기. env 토큰이 먼저고, 없으면 로그인된 `glab` 을 통로로 인정해 빈 문자열을
+ * 돌려준다 — **값이 아니라 "통로가 있다"는 사실이다.** 둘 다 없으면 null 이고, 그때만
+ * 조립하지 않는다.
+ */
+const discoverGitLabAccess = async () => {
+    const token = discoverGitLabToken();
+    if (token)
+        return token;
+    return (await glabAvailable(defaultGlabRun)) ? '' : null;
+};
 /** 이 adapter는 토큰 없이 조립된다. 자격은 도구가 자기 안에서 진다. */
 const TOKENLESS = new Set(['jam']);
+/**
+ * 자식 프로세스를 띄우는 도구 클라이언트들. 명령이 끝나면 닫아야 한다 — 안 닫으면
+ * CLI 가 할 일을 다 하고도 종료하지 못하고 서버 프로세스가 남는다(실제로 그렇게 됐다).
+ */
+const toolClients = new Set();
+function registerToolClient(client) {
+    toolClients.add(client);
+    return client;
+}
+/** 이 프로세스가 띄운 도구 자식들을 정리한다. 여러 번 불러도 안전하다. */
+export async function closeToolClients() {
+    const clients = [...toolClients];
+    toolClients.clear();
+    await Promise.all(clients.map((client) => client.stop().catch(() => undefined)));
+}
 /**
  * capability와 Port의 대응. **이 표가 없으면 조립이 덮어쓰기가 된다** —
  * 두 binding이 각각 다른 capability를 맡았는데 나중 것이 앞 것의 Port까지 밀어낸다.
@@ -108,7 +144,7 @@ export async function buildRuntimePorts(input) {
     const ports = { unavailable: [] };
     // 자격은 adapter마다 다른 곳에 있다. Core는 이 사실을 모르고, 여기서만 안다.
     const findToken = input.findToken ??
-        (async (adapterId) => adapterId === 'gitlab' ? discoverGitLabToken() : await discoverToken());
+        (async (adapterId) => adapterId === 'gitlab' ? await discoverGitLabAccess() : await discoverToken());
     // capability마다 따로 푼다. 한 binding이 여럿을 제공해도, 서로 다른 binding이 나눠
     // 맡아도 같은 경로로 조립된다 — 어느 갈래가 어디서 왔는지가 Port마다 정확해야 한다.
     const wanted = Object.keys(PORT_OF);

package/dist/core/attach/init.d.ts

@@ -27,3 +27,20 @@ export declare function overrideTemplate(): string;
 export declare function identitiesTemplate(): string;
 /** 이미 있으면 건드리지 않는다. 사람이 채운 것을 덮지 않기 위해서다. */
 export declare function writeIfAbsent(path: string, content: string): Promise<boolean>;
+/**
+ * 지금 이 사람을 승인 권한자·감시 대상으로 세운 두 파일의 내용 (P1-F).
+ *
+ * 순수 함수인 이유: 이 결정은 두 파일에 서로 다른 형식으로 적히고, 한쪽만 채워 두면
+ * 게이트가 왜 안 열리는지 알 수 없는 상태가 된다. 그 짝을 코드 한 곳에서 만든다.
+ *
+ * **비밀은 다루지 않는다** — 이름과 채널만 적힌다.
+ */
+export declare function withIdentity(identities: Record<string, unknown>, override: Record<string, unknown>, input: {
+    name: string;
+    actor: string;
+    controller: boolean;
+    monitor: boolean;
+}): {
+    identities: Record<string, unknown>;
+    override: Record<string, unknown>;
+};

package/dist/core/attach/init.js

@@ -98,3 +98,31 @@ export async function writeIfAbsent(path, content) {
         throw error;
     }
 }
+/**
+ * 지금 이 사람을 승인 권한자·감시 대상으로 세운 두 파일의 내용 (P1-F).
+ *
+ * 순수 함수인 이유: 이 결정은 두 파일에 서로 다른 형식으로 적히고, 한쪽만 채워 두면
+ * 게이트가 왜 안 열리는지 알 수 없는 상태가 된다. 그 짝을 코드 한 곳에서 만든다.
+ *
+ * **비밀은 다루지 않는다** — 이름과 채널만 적힌다.
+ */
+export function withIdentity(identities, override, input) {
+    const nextIdentities = { ...identities };
+    const nextOverride = { ...override };
+    if (input.controller) {
+        nextIdentities[input.name] = [input.actor];
+        const controller = { ...(nextOverride.controller ?? {}) };
+        controller.identities = {
+            ...(controller.identities ?? {}),
+            [input.name]: [input.actor],
+        };
+        nextOverride.controller = controller;
+    }
+    if (input.monitor) {
+        const existing = Array.isArray(nextOverride.monitorIdentities)
+            ? nextOverride.monitorIdentities.filter((v) => typeof v === 'string')
+            : [];
+        nextOverride.monitorIdentities = [...new Set([...existing, input.name])];
+    }
+    return { identities: nextIdentities, override: nextOverride };
+}

package/dist/core/distribution/release.d.ts

@@ -1,9 +1,9 @@
 export declare const RUNTIME_PACKAGE = "@asc-agent/runtime";
 export declare const BOOTSTRAP_PACKAGE = "@asc-agent/bootstrap";
 /** runtime과 bootstrap은 초기 release에서 lockstep이다. */
-export declare const RELEASE_VERSION = "0.2.1";
-export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.2.1";
-export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.2.1";
+export declare const RELEASE_VERSION = "0.3.0";
+export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.3.0";
+export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.3.0";
 /**
  * 아직 설치되지 않은 machine에서 그대로 실행되는 형태 (C-14 §3.4).
  *

package/dist/core/distribution/release.js

@@ -9,7 +9,7 @@
 export const RUNTIME_PACKAGE = '@asc-agent/runtime';
 export const BOOTSTRAP_PACKAGE = '@asc-agent/bootstrap';
 /** runtime과 bootstrap은 초기 release에서 lockstep이다. */
-export const RELEASE_VERSION = '0.2.1';
+export const RELEASE_VERSION = '0.3.0';
 export const RUNTIME_SPEC = `${RUNTIME_PACKAGE}@${RELEASE_VERSION}`;
 export const BOOTSTRAP_SPEC = `${BOOTSTRAP_PACKAGE}@${RELEASE_VERSION}`;
 /**

package/dist/core/monitor/investigation.d.ts

@@ -5,6 +5,18 @@ import { type OwnershipMap } from '../policy/ownership.ts';
 import type { Relevance } from './relevance.ts';
 export declare const STEPS: readonly ["resource", "delta", "responsibility", "work", "thread", "change", "work-context", "canonical", "relevance", "recommendation", "draft"];
 export type StepId = (typeof STEPS)[number];
+/**
+ * 확인하지 못한 이유. "안 봤다"와 "볼 수 없다"가 같은 결과로 뭉개지면, 조사 누락이
+ * 접근 불가처럼 보이고 그 상태로 추천이 나간다.
+ *
+ * - `MISSING`        — 통로 자체가 없어 **보지 않았다** (Port 미배선)
+ * - `UNAVAILABLE`    — 보려 했으나 실패했다 (조회 오류·접근 거부·사라짐)
+ * - `NOT_APPLICABLE` — 이 사건에 해당하지 않는다
+ *
+ * 이전 판의 결과가 `done` 으로 되돌아오면 이 필드가 없다. 그때는 MISSING 으로 읽는다 —
+ * 모르는 쪽을 "확인했다"로 읽는 것보다 "안 봤다"로 읽는 편이 안전하다.
+ */
+export type StepReason = 'MISSING' | 'UNAVAILABLE' | 'NOT_APPLICABLE';
 export type StepResult = {
     id: StepId;
     kind: 'DONE';
@@ -15,13 +27,17 @@ export type StepResult = {
     id: StepId;
     kind: 'UNDECIDABLE';
     detail: string;
+    reason?: Extract<StepReason, 'MISSING' | 'UNAVAILABLE'>;
 }
 /** 이 사건에는 해당하지 않는다 (변경이 없는 사건의 change 단계 등). */
  | {
     id: StepId;
     kind: 'SKIPPED';
     detail: string;
+    reason?: Extract<StepReason, 'NOT_APPLICABLE'>;
 };
+/** 단계 결과를 세 상태로 읽는다. reason 이 없는 옛 결과는 보수적으로 읽는다. */
+export declare function stepReason(step: StepResult): 'DONE' | StepReason;
 export type Investigation = {
     steps: StepResult[];
     /** 사람이 읽는 상황. 단계 산출을 이어 붙인 것이며 요약하지 않는다. */

package/dist/core/monitor/investigation.js

@@ -21,10 +21,19 @@ export const STEPS = [
     'recommendation', // ⑩ 무엇을 하면 되는가
     'draft', // ⑪ 초안 (조건을 만족할 때만)
 ];
+/** 단계 결과를 세 상태로 읽는다. reason 이 없는 옛 결과는 보수적으로 읽는다. */
+export function stepReason(step) {
+    if (step.kind === 'DONE')
+        return 'DONE';
+    if (step.kind === 'SKIPPED')
+        return step.reason ?? 'NOT_APPLICABLE';
+    return step.reason ?? 'MISSING';
+}
 const missingPort = (id, what) => ({
     id,
     kind: 'UNDECIDABLE',
     detail: `${what} 를 제공하는 binding이 없다 — 이 단계는 확인하지 못했다`,
+    reason: 'MISSING',
 });
 /**
  * 단계를 순서대로 밟는다. **각 단계는 자기가 필요한 Port만 요청한다** — 어떤 외부 시스템이
@@ -45,7 +54,7 @@ export async function investigate(input, ports, done = []) {
     if (!ports.resource)
         put(missingPort('resource', '리소스 조회'));
     else if (!resource || resource.missing) {
-        put({ id: 'resource', kind: 'UNDECIDABLE', detail: '리소스를 읽지 못했다 (사라졌거나 접근 불가)' });
+        put({ id: 'resource', kind: 'UNDECIDABLE', detail: '리소스를 읽지 못했다 (사라졌거나 접근 불가)', reason: 'UNAVAILABLE' });
     }
     else {
         put({
@@ -60,7 +69,7 @@ export async function investigate(input, ports, done = []) {
     }
     // ② Delta — 현재 모습만 보면 무엇이 새로운지 알 수 없다.
     if (!input.previous) {
-        put({ id: 'delta', kind: 'SKIPPED', detail: '지난 관측이 없다 — 처음 보는 사건이다' });
+        put({ id: 'delta', kind: 'SKIPPED', detail: '지난 관측이 없다 — 처음 보는 사건이다', reason: 'NOT_APPLICABLE' });
     }
     else if (!resource) {
         put(missingPort('delta', '리소스 조회'));
@@ -88,11 +97,11 @@ export async function investigate(input, ports, done = []) {
     }
     put(responsibility.length > 0
         ? { id: 'responsibility', kind: 'DONE', findings: responsibility }
-        : { id: 'responsibility', kind: 'SKIPPED', detail: 'owner·결정 영역이 선언되지 않았다' });
+        : { id: 'responsibility', kind: 'SKIPPED', detail: 'owner·결정 영역이 선언되지 않았다', reason: 'NOT_APPLICABLE' });
     // ④ 지금 돌고 있는 것과의 관계.
     put(input.activeSessions?.length
         ? { id: 'work', kind: 'DONE', findings: [`활성 세션: ${input.activeSessions.join(', ')}`] }
-        : { id: 'work', kind: 'SKIPPED', detail: '지금 돌고 있는 세션이 없다' });
+        : { id: 'work', kind: 'SKIPPED', detail: '지금 돌고 있는 세션이 없다', reason: 'NOT_APPLICABLE' });
     // ⑤ Thread — 전부 읽지 않는다. 판단에 필요한 만큼만 (C-05 §3).
     if (!ports.resource)
         put(missingPort('thread', '스레드 조회'));
@@ -101,7 +110,7 @@ export async function investigate(input, ports, done = []) {
             .getComments(input.reference, { limit: input.commentLimit ?? 5 })
             .catch(() => null);
         put(comments === null
-            ? { id: 'thread', kind: 'UNDECIDABLE', detail: '논의를 읽지 못했다' }
+            ? { id: 'thread', kind: 'UNDECIDABLE', detail: '논의를 읽지 못했다', reason: 'UNAVAILABLE' }
             : {
                 id: 'thread',
                 kind: 'DONE',
@@ -128,7 +137,7 @@ export async function investigate(input, ports, done = []) {
     }
     // ⑦ Work Context — 작업 항목의 상태·연결. 코드 쪽과 다른 Binding일 수 있다.
     if (!input.workReference) {
-        put({ id: 'work-context', kind: 'SKIPPED', detail: '연결된 작업 항목이 선언되지 않았다' });
+        put({ id: 'work-context', kind: 'SKIPPED', detail: '연결된 작업 항목이 선언되지 않았다', reason: 'NOT_APPLICABLE' });
     }
     else if (!ports.work) {
         put(missingPort('work-context', '작업 항목 조회'));
@@ -136,7 +145,7 @@ export async function investigate(input, ports, done = []) {
     else {
         const item = await ports.work.getResource(input.workReference).catch(() => null);
         if (!item || item.missing) {
-            put({ id: 'work-context', kind: 'UNDECIDABLE', detail: '작업 항목을 읽지 못했다' });
+            put({ id: 'work-context', kind: 'UNDECIDABLE', detail: '작업 항목을 읽지 못했다', reason: 'UNAVAILABLE' });
         }
         else {
             // 경위는 있으면 더한다. 없다고 이 단계 전체가 무너지지는 않는다 —
@@ -163,7 +172,7 @@ export async function investigate(input, ports, done = []) {
     else {
         const snapshots = await ports.baselines().catch(() => null);
         if (!snapshots)
-            put({ id: 'canonical', kind: 'UNDECIDABLE', detail: '정본을 읽지 못했다' });
+            put({ id: 'canonical', kind: 'UNDECIDABLE', detail: '정본을 읽지 못했다', reason: 'UNAVAILABLE' });
         else {
             const touched = (change?.changedPaths ?? []).filter((path) => input.canonicalPaths?.length && isWithinScopes(path, input.canonicalPaths));
             canonicalConflict = touched.length > 0;
@@ -184,7 +193,7 @@ export async function investigate(input, ports, done = []) {
             kind: 'DONE',
             findings: input.relevance.evidence.map((e) => `${e.supports ? '+' : '-'} ${e.detail}`),
         }
-        : { id: 'relevance', kind: 'SKIPPED', detail: '관련성 판정을 받지 못했다' });
+        : { id: 'relevance', kind: 'SKIPPED', detail: '관련성 판정을 받지 못했다', reason: 'NOT_APPLICABLE' });
     const undecidable = steps
         .filter((s) => s.kind === 'UNDECIDABLE')
         .map((s) => `${s.id}: ${s.detail}`);

package/dist/core/operator/contract-draft.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { EscalationPredicate } from '../runtime/escalation.ts';
+import { type OwnershipMap } from '../policy/ownership.ts';
+import { type PreflightResult } from './preflight.ts';
+import type { ResolvedPolicy } from '../policy/policy.ts';
+/**
+ * 이 값이 어디서 왔는가. **claims.ts의 CONFIRMED/INFERRED/PENDING과 같은 축이다** —
+ * 이름만 계약 초안의 어휘로 부른다 (agent가 읽는 문서에서 "추론"보다 "PROPOSAL"이
+ * 무엇을 해야 하는지 더 곧게 말한다).
+ */
+export type DraftStatus = 
+/** 사용자·정본·work item·Profile에서 직접 확인된 값. 뒤집으려면 그 출처를 봐야 한다. */
+'FACT'
+/** agent가 근거를 갖고 제안한 값. 근거가 충분하고 경계 안이면 그대로 진행해도 된다. */
+ | 'PROPOSAL'
+/** agent가 확정해서는 안 되는 값. 사람의 경계다. */
+ | 'DECISION_REQUIRED';
+/** 값이 어디서 왔는지. 지어낸 것과 읽어 온 것을 문자열 하나로 구분한다. */
+export declare const DRAFT_SOURCES: readonly ["user", "work_item", "profile", "repository", "canonical", "agent_proposal"];
+export type DraftSource = (typeof DRAFT_SOURCES)[number];
+/** 초안의 출처 한 줄. CLI가 받는 문자열도 이 스키마로 통과시켜야 들어온다. */
+export declare const DraftProvenance: z.ZodObject<{
+    field: z.ZodEnum<["id", "role", "goal", "boundary", "criteria", "owner"]>;
+    status: z.ZodEnum<["FACT", "PROPOSAL", "DECISION_REQUIRED"]>;
+    source: z.ZodEnum<["user", "work_item", "profile", "repository", "canonical", "agent_proposal"]>;
+    /** 왜 이 값인가. PROPOSAL이면 반드시 있어야 한다 — 근거 없는 제안은 추측이다. */
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "FACT" | "PROPOSAL" | "DECISION_REQUIRED";
+    source: "canonical" | "profile" | "user" | "work_item" | "repository" | "agent_proposal";
+    field: "id" | "role" | "goal" | "owner" | "boundary" | "criteria";
+    reason?: string | undefined;
+}, {
+    status: "FACT" | "PROPOSAL" | "DECISION_REQUIRED";
+    source: "canonical" | "profile" | "user" | "work_item" | "repository" | "agent_proposal";
+    field: "id" | "role" | "goal" | "owner" | "boundary" | "criteria";
+    reason?: string | undefined;
+}>;
+export type DraftField = z.infer<typeof DraftProvenance>;
+/** agent가 만들어 오는 것. 완성된 계약이 아니라 **초안**이다. */
+export type SessionContractDraft = {
+    id?: string;
+    role?: string;
+    goal?: string;
+    boundary?: readonly string[];
+    criteria?: readonly string[];
+    owner?: string;
+    decisionDomains?: readonly string[];
+    decisionAuthority?: Readonly<Record<string, string>>;
+    /** 각 값의 출처. 없는 필드는 `agent_proposal` 로 간주하지 않고 **출처 미상**으로 본다. */
+    provenance?: readonly DraftField[];
+};
+/**
+ * 사람이 답해야 하는 것 하나. **빠진 정보 전부가 아니라 결정 지점 하나씩** 든다 —
+ * 목록이 길면 사람은 그것을 질문이 아니라 서식으로 읽는다.
+ */
+export type UnresolvedDecision = {
+    field: DraftField['field'];
+    /** 왜 사람인가. escalation predicate와 같은 어휘를 쓴다 (C-13). */
+    reason: (typeof EscalationPredicate)['_type'] | 'missing_input' | 'multiple_options';
+    detail: string;
+    /** 고를 수 있는 것들. 하나뿐이면 질문이 아니라 제안이다. */
+    options?: string[];
+    /** 추천 인덱스. 추천 없이 선택지만 주는 것은 판단을 떠넘기는 것이다. */
+    recommended?: number;
+};
+/**
+ * 발급 권한은 **사람의 것이다** (OM §450). 다만 그 문장이 "매번 사람이 직접 쳐야 한다"는
+ * 뜻은 아니다 — Controller가 **범위를 정해 위임**할 수 있고, 그 범위 안에서만 agent가
+ * 스스로 발급한다. 위임이 없으면 계약이 완성돼도 발급하지 않고 사람에게 넘긴다.
+ *
+ * 위임은 Profile/Override의 `policy.unionLists.issuanceDelegation` 에 **역할 이름**으로
+ * 적는다 (closureChecklist와 같은 관례 키 자리). 경로 범위는 이미 `roleScopes` 가 좁히고
+ * 있으므로 여기서 다시 정의하지 않는다 — 권한을 두 곳에 적으면 둘이 갈라진다.
+ */
+export declare const ISSUANCE_DELEGATION_KEY = "issuanceDelegation";
+export type IssuanceAuthority = {
+    /** `controller` = 사람이 발급한다. `delegated` = 이 역할에 한해 agent가 발급해도 된다. */
+    authority: 'controller' | 'delegated';
+    /** Controller가 위임한 역할들. 비어 있으면 위임이 없다는 뜻이다. */
+    delegatedRoles: string[];
+    detail: string;
+};
+export type ContractPlanStatus = 
+/** 지금 발급해도 된다. 사람에게 물을 것이 없다. */
+'READY_TO_ISSUE'
+/** 구조는 맞는데 사람만 정할 수 있는 것이 남았다. */
+ | 'NEEDS_DECISION'
+/** 이 초안으로는 계약이 성립하지 않는다 — 문법·범위가 틀렸다. */
+ | 'INVALID';
+export type SessionContractPlan = {
+    status: ContractPlanStatus;
+    draft: SessionContractDraft;
+    /** 출처가 확인된 값들. */
+    facts: DraftField[];
+    /** 근거를 갖고 제안된 값들. */
+    proposals: DraftField[];
+    unresolved: UnresolvedDecision[];
+    /** 계약이 완성돼도 **발급해도 되는가**는 별개다 (OM §450). */
+    issuance: IssuanceAuthority;
+    /** 구조가 깨진 지점. 있으면 status는 INVALID다. */
+    invalid: {
+        field: string;
+        detail: string;
+    }[];
+    /** 경로·책임 축 판정 원본. 있는 그대로 실어 agent가 다시 계산하지 않게 한다. */
+    preflight?: PreflightResult;
+};
+export type ContractPlanInput = {
+    draft: SessionContractDraft;
+    policy?: ResolvedPolicy;
+    ownership?: OwnershipMap;
+    /** 이미 있는 세션 id들. 겹치면 발급이 실패하므로 미리 말한다. */
+    existingIds?: readonly string[];
+};
+/**
+ * 초안을 잰다. **아무것도 쓰지 않는다** — 순수 함수이고, 같은 입력이면 같은 답이다.
+ *
+ * 판정 순서에 뜻이 있다: 먼저 구조(문법·필수값)를 보고, 그 다음 경계(범위·책임)를 본다.
+ * 구조가 깨진 초안의 경계를 논하는 것은 의미가 없고, 사람에게 두 번 묻게 만든다.
+ */
+export declare function planSessionContract(input: ContractPlanInput): SessionContractPlan;
+/** 발급 명령의 인자. plan이 통과했을 때만 부른다 — 통과하지 않은 초안은 명령이 되지 않는다. */
+export declare function issueArgs(draft: SessionContractDraft): string[];