@asc-agent/runtime 0.3.2 → 0.5.0

package/dist/core/runtime/workspaces.d.ts

@@ -0,0 +1,61 @@
+/** 운영 상태 — 별도 state machine 이 아니라 읽기 모델이다. */
+export type WorkspaceHealth = 'ACTIVE' | 'DEGRADED' | 'DORMANT';
+export type WorkspaceView = {
+    workspaceId: string;
+    /** 이 workspace 의 runtime 뿌리. */
+    root: string;
+    /** 지금 살아 있는 checkout 들. 비어 있으면 DORMANT 다. */
+    liveLocators: string[];
+    /** 등록돼 있지만 지금 없는 checkout 들. 지우지 않는다 — 돌아올 수 있다. */
+    missingLocators: string[];
+    health: WorkspaceHealth;
+    aliases: readonly string[];
+};
+export type WorkspaceInput = {
+    workspaceId: string;
+    root: string;
+    aliases: readonly string[];
+    locators: readonly string[];
+};
+/**
+ * 지금 이 기계의 상태를 계산한다. **판정도 삭제도 하지 않는다.**
+ *
+ * `rootExists` 가 거짓이면 runtime 자체가 사라진 것이다 — locator 가 살아 있어도
+ * 관측할 수 없으므로 DEGRADED 로 든다. 사라진 것을 조용히 지우지 않는 이유는 위와 같다.
+ */
+export declare function viewWorkspaces(workspaces: readonly WorkspaceInput[], exists: (path: string) => boolean): WorkspaceView[];
+/**
+ * 이번 회차에 실제로 돌 곳.
+ *
+ * DORMANT 는 **밖을 치지 않는다** (설계 §19). 살아 있는 checkout 이 없으면 그 저장소를
+ * 대신해 무엇을 물어볼 자리도 없고, 없는 자리를 대신해 외부에 질문하면 그것은 관측이
+ * 아니라 잡음이다.
+ */
+export declare function dueWorkspaces(views: readonly WorkspaceView[]): {
+    workspaceId: string;
+    cwd: string;
+}[];
+/** 사람이 읽는 기계 전체 화면. `cd` 없이 지금 무엇이 도는지 보여야 한다 (설계 §13.2). */
+export declare function renderWorkspaces(views: readonly WorkspaceView[]): string[];
+/** 회차 하나에서 workspace 하나가 어떻게 끝났는가. */
+export type PassResult = {
+    workspaceId: string;
+    code: number;
+};
+/**
+ * 기계 회차 전체의 결과 (P0-R2).
+ *
+ * 원칙 둘이 같이 선다: **한 workspace 의 실패가 다른 workspace 를 세우지 않는다** — 그래서
+ * 전부 돌린 뒤에 센다. 그리고 **기계 수준 결과는 실패를 삼키지 않는다** — 하나라도 0 이 아니면
+ * 회차도 0 이 아니다. 예전에는 무조건 0 을 돌려줘서 OS 기록(LastExitStatus)에는 두 workspace 가
+ * 실패한 회차가 정상으로 남았다. 실패를 지운 것이 아니라 볼 수 없게 만든 것이고, 그것이 더 나쁘다.
+ */
+export declare function summarizePass(ran: readonly PassResult[], skipped: readonly {
+    workspaceId: string;
+    health: WorkspaceHealth;
+}[]): {
+    code: 0 | 1;
+    outcome: 'ok' | 'partial' | 'failed';
+    failed: PassResult[];
+    line: string;
+};

package/dist/core/runtime/workspaces.js

@@ -0,0 +1,82 @@
+// 이 기계가 돌보는 workspace 들 (설계 §6·§7).
+//
+// **두 번째 등록부를 만들지 않는다.** `monitorEnabled=true` 같은 플래그를 새로 두면 그것이
+// 곧 두 번째 정본이 되고, 붙어 있는데 감시되지 않는(또는 그 반대의) 상태가 생긴다.
+// 운영 상태는 **이미 있는 사실에서 계산한다**:
+//
+//   workspace 가 index 에 있다        → 이 기계가 아는 workspace 다
+//   살아 있는 locator 가 하나라도 있다 → 관측할 수 있다
+//   하나도 없다                        → DORMANT — 상태는 남기고 밖을 치지 않는다
+//
+// DORMANT 는 삭제 대상이 아니다 (설계 §3.9). checkout 을 잠시 지웠다고 몇 달치 기록을
+// 버리면, 그 삭제를 되돌릴 방법이 없다. 새 locator 가 나타나면 다시 ACTIVE 가 된다.
+/**
+ * 지금 이 기계의 상태를 계산한다. **판정도 삭제도 하지 않는다.**
+ *
+ * `rootExists` 가 거짓이면 runtime 자체가 사라진 것이다 — locator 가 살아 있어도
+ * 관측할 수 없으므로 DEGRADED 로 든다. 사라진 것을 조용히 지우지 않는 이유는 위와 같다.
+ */
+export function viewWorkspaces(workspaces, exists) {
+    return workspaces.map((workspace) => {
+        const liveLocators = workspace.locators.filter((locator) => exists(locator));
+        const missingLocators = workspace.locators.filter((locator) => !exists(locator));
+        const rootExists = exists(workspace.root);
+        const health = liveLocators.length === 0 ? 'DORMANT' : rootExists ? 'ACTIVE' : 'DEGRADED';
+        return {
+            workspaceId: workspace.workspaceId,
+            root: workspace.root,
+            liveLocators,
+            missingLocators,
+            health,
+            aliases: workspace.aliases,
+        };
+    });
+}
+/**
+ * 이번 회차에 실제로 돌 곳.
+ *
+ * DORMANT 는 **밖을 치지 않는다** (설계 §19). 살아 있는 checkout 이 없으면 그 저장소를
+ * 대신해 무엇을 물어볼 자리도 없고, 없는 자리를 대신해 외부에 질문하면 그것은 관측이
+ * 아니라 잡음이다.
+ */
+export function dueWorkspaces(views) {
+    return views
+        .filter((view) => view.health === 'ACTIVE')
+        // 여러 checkout 이 있으면 아무 곳에서나 한 번이면 된다 — 관측 대상은 workspace 이지
+        // checkout 이 아니다. 첫 번째를 쓰는 것은 안정적인 선택이다(목록 순서가 index 순서다).
+        .map((view) => ({ workspaceId: view.workspaceId, cwd: view.liveLocators[0] }));
+}
+/** 사람이 읽는 기계 전체 화면. `cd` 없이 지금 무엇이 도는지 보여야 한다 (설계 §13.2). */
+export function renderWorkspaces(views) {
+    if (views.length === 0)
+        return ['No workspaces are registered on this machine.'];
+    const lines = [];
+    for (const view of views) {
+        const alias = view.aliases[0] ?? '(no alias)';
+        lines.push(`${view.workspaceId}  ${view.health}  ${alias}`);
+        for (const locator of view.liveLocators)
+            lines.push(`  ${locator}`);
+        // 없어진 checkout 도 든다 — 지우지 않았다는 사실이 보여야 사람이 놀라지 않는다
+        for (const locator of view.missingLocators)
+            lines.push(`  ${locator} (gone)`);
+    }
+    return lines;
+}
+/**
+ * 기계 회차 전체의 결과 (P0-R2).
+ *
+ * 원칙 둘이 같이 선다: **한 workspace 의 실패가 다른 workspace 를 세우지 않는다** — 그래서
+ * 전부 돌린 뒤에 센다. 그리고 **기계 수준 결과는 실패를 삼키지 않는다** — 하나라도 0 이 아니면
+ * 회차도 0 이 아니다. 예전에는 무조건 0 을 돌려줘서 OS 기록(LastExitStatus)에는 두 workspace 가
+ * 실패한 회차가 정상으로 남았다. 실패를 지운 것이 아니라 볼 수 없게 만든 것이고, 그것이 더 나쁘다.
+ */
+export function summarizePass(ran, skipped) {
+    const failed = ran.filter((result) => result.code !== 0);
+    const outcome = failed.length === 0 ? 'ok' : failed.length === ran.length ? 'failed' : 'partial';
+    const parts = [`${ran.length - failed.length} passed`];
+    if (failed.length > 0)
+        parts.push(`${failed.length} failed (${failed.map((r) => `${r.workspaceId}: ${r.code}`).join(', ')})`);
+    if (skipped.length > 0)
+        parts.push(`${skipped.length} skipped (${skipped.map((s) => s.health).join(', ')})`);
+    return { code: failed.length === 0 ? 0 : 1, outcome, failed, line: `Machine pass ${outcome} — ${parts.join(' · ')}` };
+}

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

@@ -11,6 +11,21 @@ export type Resolution = {
     workspaceId: string;
     locator: string;
 }
+/**
+ * 등록된 적은 없지만 **같은 Git repository의 다른 checkout이 등록돼 있다.**
+ * 같은 논리 workspace의 다른 execution instance다 (C-11 §1.3) — 쪼개지도 합치지도 않는다.
+ */
+ | {
+    kind: 'LINKED_WORKTREE';
+    root: string;
+    workspaceId: string;
+    /** 지금 이 checkout의 최상위. 호출자가 이 값을 index에 등록해 다음 번을 빠르게 만든다. */
+    locator: string;
+    /** 근거가 된, 이미 등록돼 있던 형제 checkout. */
+    via: string;
+    /** main checkout인가 linked worktree인가. */
+    kindOfLocator: 'checkout' | 'worktree';
+}
 /** 저장소 안의 `.asc/` — 팀이 채택했거나 아직 이전하지 않은 개인 legacy다. */
  | {
     kind: 'PROJECT_LOCAL';
@@ -28,7 +43,28 @@ export type ResolveInput = {
     /** 여기를 넘어서는 위로 올라가지 않는다. 보통 사용자 홈. */
     stopAt?: string;
     exists?: (path: string) => Promise<boolean>;
+    /**
+     * 이 경로가 속한 Git repository의 checkout 전부(main + linked). 없으면 이 갈래를 건너뛴다.
+     *
+     * **주입이 기본값이다** — guard hook처럼 매 호출마다 도는 소비자는 이것을 넘기지 않고,
+     * 그러면 예전과 똑같이 index만 본다.
+     */
+    worktrees?: WorktreeProbe;
 };
+/**
+ * 같은 Git repository에 속한 checkout 경로들. 첫 번째가 main worktree다.
+ * git이 없거나 저장소가 아니면 `null` — "없다"와 "못 봤다"를 구분한다.
+ */
+export type WorktreeProbe = (cwd: string) => Promise<readonly string[] | null>;
 export declare function resolveWorkspace(input: ResolveInput): Promise<Resolution>;
+/**
+ * 기본 통로 — `git worktree list --porcelain`. 첫 `worktree` 항목이 main checkout이다.
+ *
+ * git이 없거나 저장소가 아니면 `null`을 돌려준다. 빈 배열이 아니다 — "checkout이 하나도
+ * 없다"와 "물어보지 못했다"는 다른 사실이고, 후자를 전자로 적으면 조용한 오판이 된다.
+ */
+export declare const gitWorktrees: WorktreeProbe;
+/** porcelain 출력에서 checkout 경로만. 순서를 보존한다 — 첫 줄이 main worktree다. */
+export declare function parseWorktreeList(stdout: string): string[];
 /** 사람이 읽는 한 줄. 왜 그 뿌리인지가 함께 와야 사람이 틀린 결합을 알아챈다. */
 export declare function resolutionLine(resolution: Resolution): string;

package/dist/core/workspace/resolve.js

@@ -9,8 +9,12 @@
 //
 //   1. explicit root      사람이 말한 것이 이긴다
 //   2. workspace index    이 기계에 등록된 locator (경로가 바뀌어도 따라온다)
-//   3. project-adopted    저장소 안의 `.asc/` — 팀이 채택한 경우 (legacy 개인 사용 포함)
-//   4. UNRESOLVED         모르면 모른다고 한다
+//   3. linked worktree    같은 Git repository의 다른 checkout이 등록돼 있다 (C-11 §1.3)
+//   4. project-adopted    저장소 안의 `.asc/` — 팀이 채택한 경우 (legacy 개인 사용 포함)
+//   5. UNRESOLVED         모르면 모른다고 한다
+//
+// **3번은 index가 빗나갔을 때만 돈다.** 등록된 locator로 풀리는 정상 경로는 예전 그대로
+// 파일 접근 하나이며, Git을 부르지 않는다 — guard hook이 매 Bash 호출마다 지나는 길이다.
 //
 // **3번의 탐색에는 경계가 있다.** 예전에는 파일시스템 루트까지 올라갔는데, 사용자 홈에
 // `~/.asc` 가 생기는 순간 홈 아래 아무 저장소나 그 뿌리로 오인 매칭된다. 그래서 홈을
@@ -47,11 +51,112 @@ export async function resolveWorkspace(input) {
                 };
         }
     }
+    // index가 빗나갔다. 여기서 처음으로 Git에게 **구조**를 묻는다 — remote가 같다는 이유로
+    // 이어붙이지 않는다 (C-11 불변식 ③). 같은 linked repository라는 것은 로컬에서 증명된다.
+    if (input.index && input.worktrees) {
+        const linked = await resolveLinkedWorktree(input.cwd, input.index, input.worktrees, exists);
+        if (linked)
+            return linked;
+    }
     const local = await findProjectLocal(input.cwd, input.stopAt, exists);
     if (local)
         return { kind: 'PROJECT_LOCAL', root: join(local, ASC_DIR), projectRoot: local };
     return { kind: 'UNRESOLVED', detail: '이 경로에 붙은 ASC workspace가 없다' };
 }
+/**
+ * 이 checkout이 **이미 등록된 checkout과 같은 Git repository**인가.
+ *
+ * `git worktree list` 는 그 저장소의 checkout만 든다. 그래서 remote가 같은 **독립 clone**은
+ * 서로의 경로를 담지 않고, 여기서 절대 이어붙지 않는다 — 그것이 이 판정이 alias 대조가
+ * 아니라 worktree 목록을 쓰는 이유다 (C-11 불변식 ③: alias 일치는 recover candidate일 뿐).
+ *
+ * 후보 workspace가 둘 이상이면 **고르지 않는다.** 고르면 사람이 그 선택을 보지 못한다.
+ */
+async function resolveLinkedWorktree(cwd, index, probe, exists) {
+    const paths = await probe(cwd);
+    if (!paths || paths.length === 0)
+        return null;
+    const normalized = paths.map(normalizeLocator);
+    const here = currentWorktree(normalized, normalizeLocator(cwd));
+    if (!here)
+        return null;
+    const hits = new Map();
+    for (const path of normalized) {
+        if (path === here)
+            continue;
+        const found = lookupLocator(index, path);
+        if (found)
+            hits.set(found.workspaceId, { root: found.root, via: found.locator });
+    }
+    if (hits.size === 0)
+        return null;
+    if (hits.size > 1) {
+        return {
+            kind: 'UNRESOLVED',
+            detail: `이 저장소의 다른 checkout들이 서로 다른 workspace에 등록돼 있다 (${[...hits.keys()].join(', ')}) — 고르지 않는다`,
+        };
+    }
+    const [[workspaceId, hit]] = [...hits.entries()];
+    // 등록은 돼 있는데 뿌리가 없으면 넘어가지 않는다 — REGISTERED와 같은 태도다.
+    if (!(await exists(hit.root))) {
+        return {
+            kind: 'UNRESOLVED',
+            detail: `${workspaceId} 가 등록돼 있으나 runtime(${hit.root})이 없다 — 옮겼거나 지워졌다`,
+        };
+    }
+    return {
+        kind: 'LINKED_WORKTREE',
+        root: hit.root,
+        workspaceId,
+        locator: here,
+        via: hit.via,
+        // 목록의 첫 항목이 main worktree다 (git worktree list 의 계약).
+        kindOfLocator: here === normalized[0] ? 'checkout' : 'worktree',
+    };
+}
+/**
+ * 목록 중 지금 서 있는 checkout. cwd는 그 아래 하위 디렉터리일 수 있으므로 **가장 긴
+ * 접두어**를 고른다. 경계는 구분자에서만 인정한다 — `/a/repo` 가 `/a/repo-2` 를 삼키면 안 된다.
+ */
+function currentWorktree(paths, cwd) {
+    let best = null;
+    for (const path of paths) {
+        if (cwd !== path && !cwd.startsWith(`${path}/`))
+            continue;
+        if (best === null || path.length > best.length)
+            best = path;
+    }
+    return best;
+}
+/**
+ * 기본 통로 — `git worktree list --porcelain`. 첫 `worktree` 항목이 main checkout이다.
+ *
+ * git이 없거나 저장소가 아니면 `null`을 돌려준다. 빈 배열이 아니다 — "checkout이 하나도
+ * 없다"와 "물어보지 못했다"는 다른 사실이고, 후자를 전자로 적으면 조용한 오판이 된다.
+ */
+export const gitWorktrees = async (cwd) => {
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    try {
+        const { stdout } = await promisify(execFile)('git', ['worktree', 'list', '--porcelain'], {
+            cwd,
+            // 목록은 짧다. 오래 걸리면 그것 자체가 "물어보지 못했다"이다 — 명령을 세우지 않는다.
+            timeout: 5_000,
+        });
+        return parseWorktreeList(stdout);
+    }
+    catch {
+        return null;
+    }
+};
+/** porcelain 출력에서 checkout 경로만. 순서를 보존한다 — 첫 줄이 main worktree다. */
+export function parseWorktreeList(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('worktree '))
+        .map((line) => line.slice('worktree '.length).trim())
+        .filter(Boolean);
+}
 /**
  * 저장소 안의 `.asc/` 를 위로 올라가며 찾되 **경계를 지킨다**.
  *
@@ -69,7 +174,7 @@ async function findProjectLocal(start, stopAt, exists) {
         const candidate = join(dir, ASC_DIR);
         // 정지선이 홈이어도 **다른 홈**의 `.asc` 는 걸러지지 않는다. Windows는 temp
         // 디렉터리가 사용자 프로필 아래라, temp의 프로젝트에서 위로 걷다 실사용자
-        // `~/.asc` 를 프로젝트 상태로 오인했다 (SSAFESTA 실측 — setup status가
+        // `~/.asc` 를 프로젝트 상태로 오인했다 (실 프로젝트 실측 — setup status가
         // UNATTACHED 대신 BROKEN을 답한 원인). user runtime은 내용으로 알아본다:
         // workspaces/·profiles/·runtime.json 은 홈에만 생긴다.
         if ((await exists(candidate)) && !(await looksLikeUserRuntime(candidate, exists)))
@@ -95,6 +200,8 @@ export function resolutionLine(resolution) {
             return `runtime: ${resolution.root} (given with --root)`;
         case 'REGISTERED':
             return `runtime: ${resolution.root} (workspace ${resolution.workspaceId} · ${resolution.locator})`;
+        case 'LINKED_WORKTREE':
+            return `runtime: ${resolution.root} (workspace ${resolution.workspaceId} · same git repository as ${resolution.via})`;
         case 'PROJECT_LOCAL':
             return `runtime: ${resolution.root} (.asc inside the repository — team-adopted, or personal state not yet migrated)`;
         case 'UNRESOLVED':

package/dist/ports/adapter.d.ts

@@ -5,6 +5,18 @@ export type DiscoveryContext = {
     projectRoot: string;
     /** 환경변수. 자격 **존재 여부** 판단에만 쓰고 값을 실어 나르지 않는다. */
     env?: NodeJS.ProcessEnv;
+    /**
+     * Profile 이 이 adapter 에 대해 선언한 자원들 (C-09 §3.1).
+     *
+     * **추측의 반대다.** adapter 가 지역 흔적에서 아무것도 못 찾아도, 사람이 Profile 에
+     * 적어 둔 것은 이미 내려진 결정이다 — 그것을 못 본 척하면 "선언은 있는데 아무 일도
+     * 일어나지 않는" 상태가 된다. adapter 는 이 값을 후보로 올릴 수 있고, 실제로 되는지는
+     * 여전히 probe 가 정한다.
+     */
+    declared?: readonly {
+        adapterId: string;
+        resource: string;
+    }[];
 };
 export type ProbeResult = {
     state: ProbeState;

package/dist/ports/coordination-surface.d.ts

@@ -0,0 +1,59 @@
+import type { RemoteIdentity } from '../core/runtime/coordination.ts';
+/**
+ * 밖으로 나가는 내용 **전부**.
+ *
+ * 상관 관계·근거 출처·라우팅·사적 메모는 여기 없다. 그것들은 호출자 쪽 내부 값이며
+ * 이 타입으로 들어올 자리가 없다 — 그것이 이 분리의 요점이다.
+ */
+export type PublicPayload = {
+    title: string;
+    body: string;
+    labels?: readonly string[];
+};
+/**
+ * 이미 있는 것을 찾기 위한 질의.
+ *
+ * **제목 유사도로 찾지 않는다.** 제목은 사람이 바꾸고, 비슷한 제목은 다른 것일 수 있다.
+ * 여기서 주는 것은 안정적인 관계 근거다 — 무엇에 대한 조율인지, 어떤 작업 항목에
+ * 걸려 있는지, 우리가 이미 아는 게시물이 있는지.
+ */
+export type SurfaceQuery = {
+    /** 이 조율이 어느 기대에 대한 것인가. adapter 는 이것을 자기 방식으로 심을 수 있다. */
+    correlation: string;
+    /** 관련된 작업 항목의 신원. adapter 어휘 그대로이며 Core 는 해석하지 않는다. */
+    workReference?: string;
+    /** 이미 아는 게시물. 있으면 그것부터 확인한다. */
+    known?: readonly Pick<RemoteIdentity, 'objectType' | 'objectId'>[];
+};
+/** 찾아진 후보 하나. */
+export type SurfaceCandidate = {
+    identity: RemoteIdentity;
+    title: string;
+    /**
+     * 왜 후보인가. **판정 근거를 값으로 든다** — 산문으로 적으면 호출자가 그것으로
+     * 판단할 수 없다.
+     */
+    matchedBy: 'known-identity' | 'correlation' | 'work-reference' | 'weak';
+    /** 닫힌 것인가. 닫힌 곳에 이어 붙일지는 호출자가 정한다. */
+    closed?: boolean;
+};
+/** 되읽기 결과. 없으면 `null` — "만들었다고 했는데 없다"는 별개의 사실이다. */
+export type SurfaceSnapshot = {
+    identity: RemoteIdentity;
+    title: string;
+    closed?: boolean;
+};
+/**
+ * 조율 표면 하나. adapter 가 구현한다.
+ *
+ * Core 는 이 인터페이스만 알고 provider 를 모른다 (C-09 §6).
+ */
+export interface CoordinationSurfacePort {
+    readonly id: string;
+    /** 이미 있는가. 없으면 빈 배열 — 못 찾은 것과 없는 것을 호출자가 구분하려면 throw 한다. */
+    find(query: SurfaceQuery): Promise<SurfaceCandidate[]>;
+    /** 만든다. 돌려주는 것은 주소가 아니라 **안정 신원**이다. */
+    create(payload: PublicPayload, query: SurfaceQuery): Promise<RemoteIdentity>;
+    /** 지금도 있는가. 만든 직후 이것으로 확인한다 — 만들었다는 주장만으로 끝내지 않는다. */
+    read(identity: Pick<RemoteIdentity, 'objectType' | 'objectId'>): Promise<SurfaceSnapshot | null>;
+}

package/dist/ports/coordination-surface.js

@@ -0,0 +1,16 @@
+// Coordination Surface — 밖에 무언가를 게시하고, 그것을 다시 찾고, 다시 읽는 통로.
+//
+// 기존 `ScmPort.execute` 로는 이 일을 할 수 없다. 그쪽은 성공을 문자열 하나로 돌려주고
+// (`resultRef`), 만들기 전에 이미 있는지 찾는 경로도, 만든 뒤 정말 있는지 되읽는 경로도
+// 없다. 실 프로젝트에서 그 구조가 같은 것을 두 번 만들게 했다:
+//
+//   생성 성공 → 돌아온 주소 모양이 예상과 다름 → 실패로 판정 → 다시 생성
+//
+// 대조할 값이 계약에 없으면 그 판정을 막을 방법이 없다. 그래서 이 Port 는 세 가지를
+// 요구한다 — **찾기 · 만들기 · 되읽기**. 그리고 성공의 정본은 주소가 아니라 그 시스템이
+// 준 안정적인 id 다.
+//
+// **공개될 것만 지나간다.** `PublicPayload` 밖의 값은 이 경계에 올 수 없다 — 내부 메모와
+// 공개 본문을 한 문자열에 담았다가 나중에 가르는 구조가 유출을 만들었고, 관례로 가르면
+// 언젠가 갈리지 않는다 (F4).
+export {};

package/dist/ports/resource-context.d.ts

@@ -6,6 +6,11 @@ export type ContextComment = {
     body: string;
     /** 아직 닫히지 않은 논의인가. provider가 알려주지 않으면 생략한다 — 추측하지 않는다. */
     unresolved?: boolean;
+    /**
+     * 사람이 쓴 것이 아니라 그 시스템이 남긴 자국인가 (커밋 언급·배정 변경 등).
+     * 사람의 답과 섞이면 "답이 왔다"가 자동으로 성립해 버린다.
+     */
+    system?: boolean;
 };
 export type ResourceSnapshot = {
     reference: string;

package/dist/schemas/profile.d.ts

@@ -212,20 +212,20 @@ export declare const ProjectProfile: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, un
         resource: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         role: string;
-        resource: string;
         adapter: string;
+        resource: string;
     }, {
         role: string;
-        resource: string;
         adapter: string;
+        resource: string;
     }>, "many">>, {
         role: string;
-        resource: string;
         adapter: string;
+        resource: string;
     }[] | undefined, {
         role: string;
-        resource: string;
         adapter: string;
+        resource: string;
     }[] | undefined>;
     /** 프로젝트 용어를 Core 개념에 붙인다. 사람이 읽는 문서에만 쓰인다. */
     terminology: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -280,8 +280,8 @@ export declare const ProjectProfile: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, un
     }> | undefined;
     bindings?: {
         role: string;
-        resource: string;
         adapter: string;
+        resource: string;
     }[] | undefined;
 }, {
     id: string;
@@ -318,8 +318,8 @@ export declare const ProjectProfile: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, un
     }> | undefined;
     bindings?: {
         role: string;
-        resource: string;
         adapter: string;
+        resource: string;
     }[] | undefined;
     policy?: {
         hardDeny?: string[] | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asc-agent/runtime",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "ASC (Agent Session Control) \u2014 local-first human-in-the-loop agent control plane: core, CLI, and adapters",
   "keywords": [
     "agent",