@asc-agent/runtime 0.1.0

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

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+/** `W-` + 32 hex. 날짜·순번을 쓰지 않는다 — 두 기계가 같은 날 만든 id가 부딪히면 안 된다. */
+export declare const WORKSPACE_ID: RegExp;
+export declare const WorkspaceId: z.ZodString;
+/** 팀이 채택했는가, 개인이 쓰는가 (C-11 §2). **추론으로 승격되지 않는다.** */
+export declare const AdoptionScope: z.ZodEnum<["local", "project"]>;
+export type AdoptionScope = z.infer<typeof AdoptionScope>;
+export declare const Locator: z.ZodObject<{
+    /** 이 기계의 checkout 경로. 정규화해 저장한다 — 대소문자·구분자 차이로 갈라지지 않게. */
+    path: z.ZodString;
+    /** 이 경로가 worktree인가 main checkout인가. 모르면 적지 않는다. */
+    kind: z.ZodOptional<z.ZodEnum<["checkout", "worktree"]>>;
+    platform: z.ZodString;
+    observedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    observedAt: string;
+    platform: string;
+    kind?: "checkout" | "worktree" | undefined;
+}, {
+    path: string;
+    observedAt: string;
+    platform: string;
+    kind?: "checkout" | "worktree" | undefined;
+}>;
+export type Locator = z.infer<typeof Locator>;
+export declare const Workspace: z.ZodObject<{
+    workspaceId: z.ZodString;
+    /** 정규화된 외부 이름들. `host/group/project` 형태이며 자격·포트·질의는 들어가지 않는다. */
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    adoptionScope: z.ZodDefault<z.ZodEnum<["local", "project"]>>;
+    createdAt: z.ZodString;
+    lastSeenAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    lastSeenAt: string;
+    workspaceId: string;
+    aliases: string[];
+    adoptionScope: "local" | "project";
+    createdAt: string;
+}, {
+    lastSeenAt: string;
+    workspaceId: string;
+    createdAt: string;
+    aliases?: string[] | undefined;
+    adoptionScope?: "local" | "project" | undefined;
+}>;
+export type Workspace = z.infer<typeof Workspace>;
+export declare const newWorkspaceId: () => string;
+/**
+ * remote URL을 identity alias로 정규화한다 (C-11 §1.2).
+ *
+ * 자격·userinfo·포트·질의는 **넣지 않는다.** 비밀이 identity에 섞이면 index와 로그에
+ * 비밀이 남는다. 형태가 달라도 같은 저장소면 같은 문자열이 나와야 한다:
+ *
+ *   git@host:group/project.git
+ *   https://user:token@host:8443/group/project.git?ref=main
+ *   ssh://git@host:2222/group/project
+ *   → host/group/project
+ */
+export declare function normalizeRemote(url: string): string | null;
+/**
+ * 경로를 비교 가능한 형태로. Windows의 역슬래시·대소문자와 후행 구분자를 흡수한다.
+ *
+ * **경로는 identity가 아니다** — 이 값은 locator 조회 키일 뿐이며, 이동하면 바뀐다.
+ */
+export declare function normalizeLocator(path: string): string;
+/**
+ * 같은 workspace로 볼 근거가 있는가 (C-11 §1.1).
+ *
+ * **동일성 증명이 아니다.** alias가 겹치면 "그 프로젝트일 수 있다"까지이며, 실제로
+ * 이어붙일지는 호출자가 정한다. remote가 하나도 없으면 후보가 아니다 — 없는 근거로
+ * 이어붙이는 것이 경로를 identity로 쓰는 것과 같은 실수다.
+ */
+export declare function recoverCandidates(workspaces: readonly Workspace[], remotes: readonly string[]): {
+    workspace: Workspace;
+    matched: string[];
+}[];
+/** 사람이 읽는 줄. 후보가 여럿이면 고르지 않고 여럿이라고 말한다. */
+export declare function recoverLines(hits: readonly {
+    workspace: Workspace;
+    matched: string[];
+}[]): string[];

package/dist/core/workspace/identity.js

@@ -0,0 +1,133 @@
+// Workspace Identity — 이것이 어떤 논리적 프로젝트인가 (C-11 §1).
+//
+// 지금까지 identity는 사실상 "walk-up이 멈춘 경로"였다. 그러면 디렉터리를 한 번 옮기는
+// 것만으로 다른 프로젝트가 되고, 같은 저장소를 두 곳에 clone하면 서로를 알아보지 못한다.
+//
+// 네 개념을 분리한다:
+//
+//   Workspace Identity   안정적인 내부 id. 사람이 바꾸지 않는다
+//   Alias                외부 시스템이 부르는 이름들. 여러 개고 바뀔 수 있다
+//   Locator              이 기계에서 지금 어디에 있는가. 자주 바뀐다
+//   Execution Instance   그 Locator에서 실제로 도는 작업 단위 (worktree)
+//
+// 내부 id가 정본인 이유: remote가 없는 저장소도, remote가 바뀌는 저장소도 있어야 하기
+// 때문이다. alias가 필요한 이유: 새 clone을 같은 프로젝트로 알아보는 유일한 단서이기
+// 때문이다. **alias 일치는 recover candidate이지 동일성 증명이 아니다** (C-11 불변식 ③).
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+/** `W-` + 32 hex. 날짜·순번을 쓰지 않는다 — 두 기계가 같은 날 만든 id가 부딪히면 안 된다. */
+export const WORKSPACE_ID = /^W-[0-9a-f]{32}$/;
+export const WorkspaceId = z.string().regex(WORKSPACE_ID);
+/** 팀이 채택했는가, 개인이 쓰는가 (C-11 §2). **추론으로 승격되지 않는다.** */
+export const AdoptionScope = z.enum(['local', 'project']);
+export const Locator = z.object({
+    /** 이 기계의 checkout 경로. 정규화해 저장한다 — 대소문자·구분자 차이로 갈라지지 않게. */
+    path: z.string().min(1),
+    /** 이 경로가 worktree인가 main checkout인가. 모르면 적지 않는다. */
+    kind: z.enum(['checkout', 'worktree']).optional(),
+    platform: z.string().min(1),
+    observedAt: z.string().min(1),
+});
+export const Workspace = z.object({
+    workspaceId: WorkspaceId,
+    /** 정규화된 외부 이름들. `host/group/project` 형태이며 자격·포트·질의는 들어가지 않는다. */
+    aliases: z.array(z.string()).default([]),
+    adoptionScope: AdoptionScope.default('local'),
+    createdAt: z.string().min(1),
+    lastSeenAt: z.string().min(1),
+});
+export const newWorkspaceId = () => `W-${randomUUID().replace(/-/g, '')}`;
+/**
+ * remote URL을 identity alias로 정규화한다 (C-11 §1.2).
+ *
+ * 자격·userinfo·포트·질의는 **넣지 않는다.** 비밀이 identity에 섞이면 index와 로그에
+ * 비밀이 남는다. 형태가 달라도 같은 저장소면 같은 문자열이 나와야 한다:
+ *
+ *   git@host:group/project.git
+ *   https://user:token@host:8443/group/project.git?ref=main
+ *   ssh://git@host:2222/group/project
+ *   → host/group/project
+ */
+export function normalizeRemote(url) {
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    // 로컬 경로는 identity가 아니다. `C:\work\repo` 는 scp 문법(`host:path`)과 모양이 같아
+    // 그냥 두면 드라이브 문자가 host가 된다 — 실측에서 실제로 그렇게 나왔다.
+    if (/^[a-zA-Z]:[\\/]/.test(trimmed) || trimmed.startsWith('/') || trimmed.startsWith('file://'))
+        return null;
+    let host;
+    let path;
+    const scheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/([^/]+)\/(.+)$/.exec(trimmed);
+    if (scheme) {
+        host = scheme[1];
+        path = scheme[2];
+    }
+    else {
+        // scp 문법 — `user@host:group/project`. 콜론 뒤가 경로다.
+        const scp = /^(?:[^@/]+@)?([^:/]+):(.+)$/.exec(trimmed);
+        if (scp) {
+            host = scp[1];
+            path = scp[2];
+        }
+        else if (/^[^/]+\/.+$/.test(trimmed)) {
+            // 이미 `host/group/project` 형태로 정규화된 값
+            const slash = trimmed.indexOf('/');
+            host = trimmed.slice(0, slash);
+            path = trimmed.slice(slash + 1);
+        }
+    }
+    if (!host || !path)
+        return null;
+    // userinfo·포트를 떼고 host만 남긴다. 대소문자는 host에서 의미가 없다.
+    const bare = host.slice(host.lastIndexOf('@') + 1).replace(/:\d+$/, '').toLowerCase();
+    const cleaned = path
+        .split(/[?#]/)[0]
+        .replace(/\.git$/, '')
+        .replace(/^\/+|\/+$/g, '');
+    if (!bare || !cleaned)
+        return null;
+    return `${bare}/${cleaned}`;
+}
+/**
+ * 경로를 비교 가능한 형태로. Windows의 역슬래시·대소문자와 후행 구분자를 흡수한다.
+ *
+ * **경로는 identity가 아니다** — 이 값은 locator 조회 키일 뿐이며, 이동하면 바뀐다.
+ */
+export function normalizeLocator(path) {
+    const slashed = path.replace(/\\/g, '/').replace(/\/+$/, '');
+    // 드라이브 문자만 대소문자를 흡수한다. 나머지는 그대로 둔다 — 대소문자를 구분하는
+    // 파일시스템에서 서로 다른 두 디렉터리를 하나로 합치면 그게 더 큰 사고다.
+    return /^[a-zA-Z]:/.test(slashed) ? slashed[0].toUpperCase() + slashed.slice(1) : slashed;
+}
+/**
+ * 같은 workspace로 볼 근거가 있는가 (C-11 §1.1).
+ *
+ * **동일성 증명이 아니다.** alias가 겹치면 "그 프로젝트일 수 있다"까지이며, 실제로
+ * 이어붙일지는 호출자가 정한다. remote가 하나도 없으면 후보가 아니다 — 없는 근거로
+ * 이어붙이는 것이 경로를 identity로 쓰는 것과 같은 실수다.
+ */
+export function recoverCandidates(workspaces, remotes) {
+    const normalized = remotes.map(normalizeRemote).filter((alias) => alias !== null);
+    if (normalized.length === 0)
+        return [];
+    return workspaces
+        .map((workspace) => ({
+        workspace,
+        matched: workspace.aliases.filter((alias) => normalized.includes(alias)),
+    }))
+        .filter((hit) => hit.matched.length > 0);
+}
+/** 사람이 읽는 줄. 후보가 여럿이면 고르지 않고 여럿이라고 말한다. */
+export function recoverLines(hits) {
+    if (hits.length === 0)
+        return ['알아볼 수 있는 workspace 없음 — 새로 만들거나 --root 로 지정하라'];
+    if (hits.length === 1) {
+        const [only] = hits;
+        return [`후보 1개: ${only.workspace.workspaceId} (일치 ${only.matched.join(', ')})`];
+    }
+    return [
+        `후보가 ${hits.length}개다 — 고르지 않는다. 사람이 정하라:`,
+        ...hits.map((hit) => `  ${hit.workspace.workspaceId} (일치 ${hit.matched.join(', ')})`),
+    ];
+}

package/dist/core/workspace/index-store.d.ts

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+import { type Locator } from './identity.ts';
+export declare const WORKSPACE_INDEX_FILE = "workspace-index.json";
+declare const LocatorEntry: z.ZodObject<{
+    workspaceId: z.ZodString;
+    /** 이 locator에 붙는 ASC runtime 뿌리. guard가 이 값만 있으면 판정할 수 있다. */
+    root: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<["checkout", "worktree"]>>;
+    platform: z.ZodString;
+    observedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    observedAt: string;
+    root: string;
+    platform: string;
+    workspaceId: string;
+    kind?: "checkout" | "worktree" | undefined;
+}, {
+    observedAt: string;
+    root: string;
+    platform: string;
+    workspaceId: string;
+    kind?: "checkout" | "worktree" | undefined;
+}>;
+export type LocatorEntry = z.infer<typeof LocatorEntry>;
+export declare const WorkspaceIndex: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    workspaces: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        workspaceId: z.ZodString;
+        aliases: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        adoptionScope: z.ZodDefault<z.ZodEnum<["local", "project"]>>;
+        createdAt: z.ZodString;
+        lastSeenAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        lastSeenAt: string;
+        workspaceId: string;
+        aliases: string[];
+        adoptionScope: "local" | "project";
+        createdAt: string;
+    }, {
+        lastSeenAt: string;
+        workspaceId: string;
+        createdAt: string;
+        aliases?: string[] | undefined;
+        adoptionScope?: "local" | "project" | undefined;
+    }>>>;
+    /** 정규화된 경로 → workspace. guard가 cwd에서 위로 올라가며 찾는 표다. */
+    locators: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        workspaceId: z.ZodString;
+        /** 이 locator에 붙는 ASC runtime 뿌리. guard가 이 값만 있으면 판정할 수 있다. */
+        root: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<["checkout", "worktree"]>>;
+        platform: z.ZodString;
+        observedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        observedAt: string;
+        root: string;
+        platform: string;
+        workspaceId: string;
+        kind?: "checkout" | "worktree" | undefined;
+    }, {
+        observedAt: string;
+        root: string;
+        platform: string;
+        workspaceId: string;
+        kind?: "checkout" | "worktree" | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    workspaces: Record<string, {
+        lastSeenAt: string;
+        workspaceId: string;
+        aliases: string[];
+        adoptionScope: "local" | "project";
+        createdAt: string;
+    }>;
+    locators: Record<string, {
+        observedAt: string;
+        root: string;
+        platform: string;
+        workspaceId: string;
+        kind?: "checkout" | "worktree" | undefined;
+    }>;
+}, {
+    version: 1;
+    workspaces?: Record<string, {
+        lastSeenAt: string;
+        workspaceId: string;
+        createdAt: string;
+        aliases?: string[] | undefined;
+        adoptionScope?: "local" | "project" | undefined;
+    }> | undefined;
+    locators?: Record<string, {
+        observedAt: string;
+        root: string;
+        platform: string;
+        workspaceId: string;
+        kind?: "checkout" | "worktree" | undefined;
+    }> | undefined;
+}>;
+export type WorkspaceIndex = z.infer<typeof WorkspaceIndex>;
+export declare const emptyIndex: () => WorkspaceIndex;
+/**
+ * index를 읽는다. 없으면 빈 index다 — 없는 것과 깨진 것을 구분하지 않는 쪽이 위험하므로
+ * 깨진 파일은 던진다. 조용히 빈 index로 시작하면 등록된 workspace가 통째로 사라진 것처럼
+ * 보이고, 그 위에 새로 쓰면 진짜로 사라진다.
+ */
+export declare function readIndex(homeDir: string): Promise<WorkspaceIndex>;
+/** tmp+rename. 같은 디렉터리 안에서 rename해야 원자성이 선다. */
+export declare function writeIndex(homeDir: string, index: WorkspaceIndex): Promise<void>;
+/**
+ * cwd에서 위로 올라가며 이 경로가 속한 workspace를 찾는다.
+ *
+ * **경계가 있다.** 등록된 locator에만 반응하므로, 상위 어딘가에 우연히 있는 디렉터리를
+ * 프로젝트 상태로 오인하지 않는다 — 무한 walk-up이 만들던 문제가 여기서는 생기지 않는다.
+ */
+export declare function lookupLocator(index: WorkspaceIndex, cwd: string): (LocatorEntry & {
+    locator: string;
+}) | null;
+export type RegisterInput = {
+    workspaceId: string;
+    root: string;
+    locator: Locator;
+    aliases?: readonly string[];
+    adoptionScope?: 'local' | 'project';
+    now: string;
+};
+/**
+ * workspace와 locator를 등록한다. **기존 alias를 지우지 않는다** — provider가 바뀌어도
+ * 옛 이름으로 알아볼 수 있어야 하고(C-11 불변식 ②), 이름이 사라지면 그 근거도 사라진다.
+ *
+ * 순수 함수다. 저장은 호출자가 writeIndex로 한다 — 읽고-고쳐-쓰기의 경계를 한 군데로 모은다.
+ */
+export declare function register(index: WorkspaceIndex, input: RegisterInput): WorkspaceIndex;
+/** 이 workspace에 달린 locator들. 하나의 논리 workspace가 여러 곳에 있을 수 있다. */
+export declare function locatorsOf(index: WorkspaceIndex, workspaceId: string): (LocatorEntry & {
+    locator: string;
+})[];
+/** 더 이상 없는 checkout을 목록에서 뺀다. workspace 자체는 지우지 않는다. */
+export declare function forgetLocator(index: WorkspaceIndex, path: string): WorkspaceIndex;
+export {};

package/dist/core/workspace/index-store.js

@@ -0,0 +1,125 @@
+// Workspace Index — 이 기계의 경로에서 workspace를 되찾는 역색인 (C-11 §3).
+//
+// 저장 위치가 저장소 밖으로 나가면 "여기가 어느 workspace인가"를 경로 탐색만으로는
+// 알 수 없다. 그 답을 이 파일 하나가 진다.
+//
+// **가장 까다로운 독자는 Host guard hook이다.** hook은 어떤 프로젝트에서든 도는 무의존
+// 단일 파일이고, 매 Bash 호출마다 실행된다. 그래서 포맷의 상한이 정해져 있다:
+//
+//   readFileSync 한 번 + JSON.parse 한 번 + 문자열 조회
+//
+// 데이터베이스도, 다단 조회도, 스키마 협상도 두지 않는다 (C-11 불변식 ⑩).
+//
+// 쓰기는 tmp+rename이다. 반쯤 쓰인 index를 guard가 읽으면 관리 대상 판정이 흔들린다
+// (C-11 불변식 ⑨).
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { Workspace, normalizeLocator } from "./identity.js";
+export const WORKSPACE_INDEX_FILE = 'workspace-index.json';
+const LocatorEntry = z.object({
+    workspaceId: z.string().min(1),
+    /** 이 locator에 붙는 ASC runtime 뿌리. guard가 이 값만 있으면 판정할 수 있다. */
+    root: z.string().min(1),
+    kind: z.enum(['checkout', 'worktree']).optional(),
+    platform: z.string().min(1),
+    observedAt: z.string().min(1),
+});
+export const WorkspaceIndex = z.object({
+    version: z.literal(1),
+    workspaces: z.record(Workspace).default({}),
+    /** 정규화된 경로 → workspace. guard가 cwd에서 위로 올라가며 찾는 표다. */
+    locators: z.record(LocatorEntry).default({}),
+});
+export const emptyIndex = () => ({ version: 1, workspaces: {}, locators: {} });
+/**
+ * index를 읽는다. 없으면 빈 index다 — 없는 것과 깨진 것을 구분하지 않는 쪽이 위험하므로
+ * 깨진 파일은 던진다. 조용히 빈 index로 시작하면 등록된 workspace가 통째로 사라진 것처럼
+ * 보이고, 그 위에 새로 쓰면 진짜로 사라진다.
+ */
+export async function readIndex(homeDir) {
+    let raw;
+    try {
+        raw = await readFile(join(homeDir, WORKSPACE_INDEX_FILE), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return emptyIndex();
+        throw error;
+    }
+    return WorkspaceIndex.parse(JSON.parse(raw));
+}
+/** tmp+rename. 같은 디렉터리 안에서 rename해야 원자성이 선다. */
+export async function writeIndex(homeDir, index) {
+    const file = join(homeDir, WORKSPACE_INDEX_FILE);
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}`;
+    await writeFile(tmp, `${JSON.stringify(index, null, 2)}\n`, 'utf8');
+    await rename(tmp, file);
+}
+/**
+ * cwd에서 위로 올라가며 이 경로가 속한 workspace를 찾는다.
+ *
+ * **경계가 있다.** 등록된 locator에만 반응하므로, 상위 어딘가에 우연히 있는 디렉터리를
+ * 프로젝트 상태로 오인하지 않는다 — 무한 walk-up이 만들던 문제가 여기서는 생기지 않는다.
+ */
+export function lookupLocator(index, cwd) {
+    let path = normalizeLocator(cwd);
+    for (;;) {
+        const entry = index.locators[path];
+        if (entry)
+            return { ...entry, locator: path };
+        const parent = path.slice(0, path.lastIndexOf('/'));
+        // 루트(`C:` 나 빈 문자열)에 닿으면 끝이다
+        if (!parent || parent === path || /^[a-zA-Z]:$/.test(path))
+            return null;
+        path = parent;
+    }
+}
+/**
+ * workspace와 locator를 등록한다. **기존 alias를 지우지 않는다** — provider가 바뀌어도
+ * 옛 이름으로 알아볼 수 있어야 하고(C-11 불변식 ②), 이름이 사라지면 그 근거도 사라진다.
+ *
+ * 순수 함수다. 저장은 호출자가 writeIndex로 한다 — 읽고-고쳐-쓰기의 경계를 한 군데로 모은다.
+ */
+export function register(index, input) {
+    const existing = index.workspaces[input.workspaceId];
+    const aliases = [...new Set([...(existing?.aliases ?? []), ...(input.aliases ?? [])])];
+    const workspace = Workspace.parse({
+        workspaceId: input.workspaceId,
+        aliases,
+        // adoption은 추론으로 승격되지 않는다 — 명시적으로 넘길 때만 바뀐다 (C-11 불변식 ⑤)
+        adoptionScope: input.adoptionScope ?? existing?.adoptionScope ?? 'local',
+        createdAt: existing?.createdAt ?? input.now,
+        lastSeenAt: input.now,
+    });
+    return {
+        ...index,
+        workspaces: { ...index.workspaces, [workspace.workspaceId]: workspace },
+        locators: {
+            ...index.locators,
+            [normalizeLocator(input.locator.path)]: LocatorEntry.parse({
+                workspaceId: input.workspaceId,
+                root: input.root,
+                ...(input.locator.kind ? { kind: input.locator.kind } : {}),
+                platform: input.locator.platform,
+                observedAt: input.locator.observedAt,
+            }),
+        },
+    };
+}
+/** 이 workspace에 달린 locator들. 하나의 논리 workspace가 여러 곳에 있을 수 있다. */
+export function locatorsOf(index, workspaceId) {
+    return Object.entries(index.locators)
+        .filter(([, entry]) => entry.workspaceId === workspaceId)
+        .map(([locator, entry]) => ({ ...entry, locator }));
+}
+/** 더 이상 없는 checkout을 목록에서 뺀다. workspace 자체는 지우지 않는다. */
+export function forgetLocator(index, path) {
+    const key = normalizeLocator(path);
+    if (!(key in index.locators))
+        return index;
+    const locators = { ...index.locators };
+    delete locators[key];
+    return { ...index, locators };
+}

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

@@ -0,0 +1,73 @@
+export type Adoption = {
+    kind: 'PROJECT_ADOPTED';
+    evidence: string;
+} | {
+    kind: 'PERSONAL_LEGACY';
+    evidence: string;
+} | {
+    kind: 'AMBIGUOUS';
+    evidence: string;
+};
+export type AdoptionInput = {
+    projectRoot: string;
+    /** Git이 추적하는 경로들 중 `.asc` 아래인 것. 하나라도 있으면 팀의 것이다. */
+    trackedAscPaths: readonly string[];
+    /** `.git/info/exclude` 내용. `.asc/` 가 등록돼 있으면 개인용으로 숨긴 것이다. */
+    excludeContent?: string;
+    /** `.gitignore` 내용. 팀 파일에 `.asc/` 가 있으면 팀이 알고 둔 것이다. */
+    gitignoreContent?: string;
+};
+/**
+ * 이 `.asc/` 가 누구 것인가.
+ *
+ * 순서가 중요하다. **추적된 파일이 있으면 다른 어떤 신호보다 먼저 팀의 것이다** —
+ * 커밋된 설정을 개인 상태로 옮기면 다른 사람의 저장소에서 파일이 사라진다.
+ */
+export declare function judgeAdoption(input: AdoptionInput): Adoption;
+export type MigrationPlan = {
+    from: string;
+    to: string;
+    adoption: Adoption;
+    /** 옮길 항목 수. 0이면 옮길 것이 없다. */
+    entries: number;
+};
+export type MigrationOutcome = {
+    ok: true;
+    plan: MigrationPlan;
+    verified: string[];
+} | {
+    ok: false;
+    reason: 'AMBIGUOUS_ADOPTION';
+    adoption: Adoption;
+    detail: string;
+} | {
+    ok: false;
+    reason: 'PROJECT_ADOPTED';
+    adoption: Adoption;
+    detail: string;
+} | {
+    ok: false;
+    reason: 'TARGET_EXISTS';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'VERIFY_FAILED';
+    detail: string;
+    mismatched: string[];
+};
+export type MigrateInput = {
+    from: string;
+    to: string;
+    adoption: Adoption;
+    /** 판정을 무시하고 옮긴다. **ambiguous에서만 의미가 있다** — 사람이 확인했다는 뜻이다. */
+    force?: boolean;
+};
+/**
+ * 복사하고, 복사된 것이 같은지 확인한다. **원본은 지우지 않는다.**
+ *
+ * 지우는 것은 사람이 확인한 뒤에 할 일이다. 여기서 지우면 verify가 실패했을 때 되돌릴
+ * 것이 없다.
+ */
+export declare function migrate(input: MigrateInput): Promise<MigrationOutcome>;
+/** 사람이 읽는 줄. 무엇을 근거로 그렇게 봤는지가 함께 와야 사람이 뒤집을 수 있다. */
+export declare function adoptionLine(adoption: Adoption): string;

package/dist/core/workspace/migrate.js

@@ -0,0 +1,123 @@
+// Legacy Migration — 저장소 안에 있던 `.asc/` 를 사용자 소유 공간으로 옮긴다 (C-11 §6).
+//
+// **가장 나쁜 결과는 팀이 채택한 artefact를 개인 상태로 오판해 옮기는 것이다.** 그래서
+// 옮기기 전에 무엇인지부터 판정하고, 모르면 옮기지 않는다:
+//
+//   personal legacy   개인이 만든 것        → 옮길 후보
+//   project adopted   팀이 채택한 것        → 그대로 둔다
+//   ambiguous         판단 불가            → 자동 이동 금지, 사람이 정한다
+//
+// 판정은 **추론이 아니라 증거**로 한다. Git이 추적하고 있으면 팀의 것이고, 추적 제외
+// 목록에 개인용으로 등록돼 있으면 개인 것이다. 둘 다 아니면 모른다 — 그 상태를
+// "아마 개인 것"으로 읽는 순간 남의 팀 설정이 사라진다.
+//
+// 옮기는 순서도 되돌릴 수 있게 잡는다: 복사 → 확인 → 등록 → (원본은 사람이 지운다).
+// verify 전에 원본을 지우지 않는다 (C-11 불변식 ⑮).
+import { cp, readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * 이 `.asc/` 가 누구 것인가.
+ *
+ * 순서가 중요하다. **추적된 파일이 있으면 다른 어떤 신호보다 먼저 팀의 것이다** —
+ * 커밋된 설정을 개인 상태로 옮기면 다른 사람의 저장소에서 파일이 사라진다.
+ */
+export function judgeAdoption(input) {
+    if (input.trackedAscPaths.length > 0) {
+        return {
+            kind: 'PROJECT_ADOPTED',
+            evidence: `Git이 추적하는 .asc 파일 ${input.trackedAscPaths.length}건 (${input.trackedAscPaths.slice(0, 3).join(', ')})`,
+        };
+    }
+    if (/^\s*\.asc\/?\s*$/m.test(input.gitignoreContent ?? '')) {
+        // 팀 파일에 적혀 있다 — 팀이 이 디렉터리를 알고 무시하기로 한 것이다.
+        return { kind: 'PROJECT_ADOPTED', evidence: '.gitignore 에 .asc/ 가 선언돼 있다 (팀이 아는 상태)' };
+    }
+    if (/^\s*\.asc\/?\s*$/m.test(input.excludeContent ?? '')) {
+        return { kind: 'PERSONAL_LEGACY', evidence: '.git/info/exclude 에만 등록된 개인 작업 공간' };
+    }
+    return {
+        kind: 'AMBIGUOUS',
+        evidence: 'Git 추적도 추적 제외 등록도 없다 — 개인 것인지 팀 것인지 판단할 근거가 없다',
+    };
+}
+/**
+ * 복사하고, 복사된 것이 같은지 확인한다. **원본은 지우지 않는다.**
+ *
+ * 지우는 것은 사람이 확인한 뒤에 할 일이다. 여기서 지우면 verify가 실패했을 때 되돌릴
+ * 것이 없다.
+ */
+export async function migrate(input) {
+    if (input.adoption.kind === 'PROJECT_ADOPTED') {
+        return {
+            ok: false,
+            reason: 'PROJECT_ADOPTED',
+            adoption: input.adoption,
+            detail: '팀이 채택한 상태다 — 개인 공간으로 옮기지 않는다',
+        };
+    }
+    if (input.adoption.kind === 'AMBIGUOUS' && !input.force) {
+        return {
+            ok: false,
+            reason: 'AMBIGUOUS_ADOPTION',
+            adoption: input.adoption,
+            detail: '개인 것인지 팀 것인지 모른다 — 확인한 뒤 --force 로 다시 부르라',
+        };
+    }
+    if (await exists(input.to)) {
+        return { ok: false, reason: 'TARGET_EXISTS', detail: `${input.to} 가 이미 있다 — 덮어쓰지 않는다` };
+    }
+    const before = await fileMap(input.from);
+    await cp(input.from, input.to, { recursive: true });
+    // 옮겨진 것이 같은지 본다. 복사만 하고 "됐다"고 말하면 그게 유실의 시작이다.
+    const after = await fileMap(input.to);
+    const mismatched = [...before.entries()]
+        .filter(([rel, content]) => after.get(rel) !== content)
+        .map(([rel]) => rel);
+    if (mismatched.length > 0) {
+        return {
+            ok: false,
+            reason: 'VERIFY_FAILED',
+            detail: `${mismatched.length}건이 원본과 다르다 — 원본은 그대로 두었다`,
+            mismatched: mismatched.slice(0, 10),
+        };
+    }
+    return {
+        ok: true,
+        plan: { from: input.from, to: input.to, adoption: input.adoption, entries: before.size },
+        verified: [...before.keys()].sort(),
+    };
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 상대 경로 → 내용. 대조는 목록이 아니라 내용으로 한다. */
+async function fileMap(root) {
+    const out = new Map();
+    const walk = async (dir, prefix) => {
+        for (const entry of await readdir(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+                await walk(full, rel);
+            else
+                out.set(rel, await readFile(full, 'utf8'));
+        }
+    };
+    await walk(root, '');
+    return out;
+}
+/** 사람이 읽는 줄. 무엇을 근거로 그렇게 봤는지가 함께 와야 사람이 뒤집을 수 있다. */
+export function adoptionLine(adoption) {
+    const label = {
+        PROJECT_ADOPTED: '팀이 채택한 상태',
+        PERSONAL_LEGACY: '개인 작업 공간',
+        AMBIGUOUS: '판단 불가',
+    }[adoption.kind];
+    return `${label} — ${adoption.evidence}`;
+}