cuelo 0.6.8 → 0.6.9

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":94212091,"timestamp":1068143,"id":14,"parentId":1,"tags":{},"startTime":1790791782933,"traceId":"ef9c20941a10f64d"},{"name":"run-typescript","duration":15350528,"timestamp":95608687,"id":10735,"parentId":1,"tags":{},"startTime":1790791877473,"traceId":"ef9c20941a10f64d"},{"name":"static-check","duration":3942334,"timestamp":111041358,"id":10738,"parentId":1,"tags":{},"startTime":1790791892906,"traceId":"ef9c20941a10f64d"},{"name":"static-generation","duration":11036951,"timestamp":115105841,"id":10892,"parentId":1,"tags":{},"startTime":1790791896970,"traceId":"ef9c20941a10f64d"},{"name":"collect-build-traces","duration":19364468,"timestamp":115073067,"id":10889,"parentId":1,"tags":{},"startTime":1790791896937,"traceId":"ef9c20941a10f64d"},{"name":"telemetry-flush","duration":81,"timestamp":134442431,"id":10901,"parentId":1,"tags":{},"startTime":1790791916307,"traceId":"ef9c20941a10f64d"},{"name":"next-build","duration":133475924,"timestamp":966614,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1790791782832,"traceId":"ef9c20941a10f64d"}]
+[{"name":"run-webpack","duration":101868985,"timestamp":684209,"id":14,"parentId":1,"tags":{},"startTime":1790818791514,"traceId":"b778babbdc8d61c8"},{"name":"run-typescript","duration":16676433,"timestamp":102902705,"id":10735,"parentId":1,"tags":{},"startTime":1790818893732,"traceId":"b778babbdc8d61c8"},{"name":"static-check","duration":4397314,"timestamp":119679483,"id":10738,"parentId":1,"tags":{},"startTime":1790818910508,"traceId":"b778babbdc8d61c8"},{"name":"static-generation","duration":11479379,"timestamp":124174322,"id":10892,"parentId":1,"tags":{},"startTime":1790818915003,"traceId":"b778babbdc8d61c8"},{"name":"collect-build-traces","duration":20134699,"timestamp":124144006,"id":10889,"parentId":1,"tags":{},"startTime":1790818914972,"traceId":"b778babbdc8d61c8"},{"name":"telemetry-flush","duration":89,"timestamp":144283259,"id":10901,"parentId":1,"tags":{},"startTime":1790818935111,"traceId":"b778babbdc8d61c8"},{"name":"next-build","duration":143711222,"timestamp":572151,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1790818791402,"traceId":"b778babbdc8d61c8"}]

package/README.md

@@ -16,7 +16,7 @@ Use the same `~/.omp/agent` sessions, credentials and model configuration from t
 
 **한국어:** CUELO는 omp(oh-my-pi)를 위한 오픈소스 AI 코딩 에이전트 작업 공간이자 하네스입니다. 웹 앱은 omp SDK를 서버 안에서 실행하고, `omp` CLI와 같은 `~/.omp/agent` 디렉터리를 씁니다. 터미널에서 하던 세션을 브라우저에서 이어 가고, 다시 터미널로 돌아가도 기록·계정·모델 설정을 공유합니다.
 
-내장 OMP 코어는 **18.4.4**입니다. 모델 탐색·서비스 등급 처리와 기억 검색 개선을 포함하며, 별도로 설치한 `omp` CLI의 버전은 웹 업데이트와 독립적입니다.
+내장 OMP 코어는 **18.4.5**입니다. 추론 강도를 바꾸거나 서브에이전트를 다시 이어도 예비 모델 설정을 유지하며, 별도로 설치한 `omp` CLI의 버전은 웹 업데이트와 독립적입니다.
 
 CUELO의 목적은 작업 중 확인한 실패와 막힘을 기억·작업 규칙·실행 절차에 반영해, 사람이 같은 문제를 다시 지적하지 않아도 다음 작업에서 실수를 줄이는 것입니다. 원인을 확인하고 필요한 부분만 바꾸며, 다음 작업에서 적용과 효과를 확인하는 것까지를 지향합니다. 기록을 저장했다는 이유만으로 자동 개선이 끝났다고 보지는 않습니다.
 
@@ -43,10 +43,11 @@ CUELO의 목적은 작업 중 확인한 실패와 막힘을 기억·작업 규
 - 작업 로그 패널에서 이번 턴의 과정 항목과 턴마다 쓴 파일을 따로 봅니다.
 - 입력창에 이미지·문서 외에 음성(받아쓰기), 코드·설정 파일(본문 첨부), 그 밖의 파일(저장 후 경로 첨부)을 붙여넣기·드롭·선택으로 넣습니다. 음성 받아쓰기에는 Google Antigravity 계정이 필요합니다.
 - 에이전트가 생성하거나 확인한 이미지가 그 턴의 대화 흐름에 썸네일로 보이고, 누르면 크게 열립니다.
-- Ctrl+K 팔레트로 모든 대화 내용을 검색해 해당 메시지로 이동하고, 긴 대화 안에서는 Ctrl+F로 가장 오래된 메시지까지 찾습니다. 오른쪽 질문 레일로 내가 한 질문 사이를 오갑니다.
+- Ctrl+K 팔레트로 대화 내용을 검색해 해당 메시지로 이동합니다. 압축으로 사라진 과거 메시지는 제외하고, 현재 볼 수 있는 메시지를 세션당 최대 3건 보여 줍니다. 긴 대화 안에서는 Ctrl+F로 찾고, 오른쪽 질문 레일로 내가 한 질문 사이를 오갑니다.
 - 실행이 3분 넘게 조용하면 멈춤 경고를, 서버나 PC가 꺼져 실행이 끊긴 대화를 열면 중단 알림을 보여 줍니다. 컨텍스트 압축 중에는 경과 시간을 표시합니다.
 - 모델 선택기 맨 위에 자주 고른 모델이 나오고, 팔레트에서 넓은 대화 폭을 켤 수 있습니다.
-- 입력창 아래 줄은 Main 프리셋 → 그 제공자의 모델 → 추론 강도 순서이고, 추론 강도는 "자동, 최대 high"처럼 상한을 둔 자동으로도 고를 수 있습니다.
+- 입력창 아래 줄은 Main 프리셋 → 그 제공자의 모델 → 추론 강도 순서입니다. "자동, 최대 high"처럼 상한을 고를 수 있고, Auto가 실제로 적용한 값은 「현재 추론 강도」로 따로 표시합니다. 새 대화는 선택한 상한 적용을 마친 뒤 첫 메시지를 보내며, 적용에 실패하면 재전송 때 다시 시도합니다.
+- 도구 옆 시간에는 모델 응답 생성 시간을 포함하지 않습니다. 실행 전에 취소된 도구나 완료 시각을 확인할 수 없는 옛 기록에는 시간을 추정해 붙이지 않습니다.
 
 **계정과 자원**
 
@@ -85,11 +86,11 @@ CUELO의 목적은 작업 중 확인한 실패와 막힘을 기억·작업 규
 
 - 모델 역할(`default`, `smol`, `slow`, `plan`, `commit`, `task` 등)별 모델 지정·전환 — TUI의 `/model`과 같은 `config.yml`을 씁니다.
 - 입력창의 `/` 명령은 대기 중뿐 아니라 실행 중에도 Enter·Steer·Follow-up으로 실행할 수 있습니다. 내장 명령은 즉시 처리하고, 발견된 확장·스킬·프롬프트 템플릿 명령은 해당 명령 경로로 전달합니다. 사용할 수 없거나 실행 중 허용되지 않는 명령은 안내하며 일반 채팅으로 전송하지 않습니다.
-- Codex 응답이 진행 중일 때 보낸 Steer가 서버의 "unsupported_native_inflight_message"로 거절돼도 대화가 오류로 끝나지 않습니다. 그 메시지는 현재 응답이 끝난 뒤 다음 요청으로 한 번 전달됩니다.
+- 응답을 기다리며 보낸 Steer를 실시간으로 반영할 수 없을 때, 아직 답변이나 도구 호출이 나오지 않았다면 현재 추론 요청만 끊고 새 지시로 이어갑니다. 이미 보인 답변이나 도구 호출은 보존하며, 대화 전체를 중단하지 않습니다.
 - 에이전트가 일반 구현 방식을 고르는 질문에 추천안을 붙여 물으면, 2분 동안 답이 없을 때 추천안으로 진행합니다. 질문 창에 그 안내가 표시되고, 옵션을 고르거나 답을 입력하면 대기 시간이 다시 시작됩니다. 자동 선택은 사용자 승인으로 치지 않으며, 배포·삭제·비용·계정·권한 확인 질문은 답할 때까지 기다립니다.
 - Main이 OpenAI 모델에서 Fast를 켜면 새로 만드는 OpenAI 계열 SubAgent도 Fast로 요청합니다. Anthropic·Google SubAgent에는 Fast를 자동으로 넘기지 않고, Fast가 꺼져 있으면 SubAgent도 표준 처리로 요청합니다.
 - 네이티브 창을 다루는 `computer.run`에서 버튼을 한 번 누른 뒤, 원하는 행·문구·값이 나타날 때까지 로컬 읽기로만 다시 확인하고 결과만 돌려줍니다. 기다리는 동안 다시 누르지 않으며, 제한 시간 초과·취소·읽기 오류를 서로 구분해 알립니다. 저장·전송처럼 결과가 남는 클릭의 승인 절차는 바뀌지 않습니다([사용법](./docs/harness.md#typed-judgment-routing-jev)).
-- provider 로그인·API 키, `models.yml`, 플러그인, 스킬을 웹에서 관리합니다.
+- provider 로그인·API 키, `models.yml`, 플러그인, 스킬을 웹에서 관리합니다. 플러그인 비활성화 설정을 저장해도 이미 불러온 플러그인은 CUELO 런타임을 재시작해야 멈춥니다. 「세션 다시 불러오기」는 플러그인을 해제하지 않습니다.
 - 프로젝트 파일 탐색과 소스·문서·이미지·오디오·PDF 미리보기, Git worktree 전환.
 - 프로젝트 신뢰: 설정에서 프로젝트별 승인을 관리·해제하고, 실행 중에는 작업을 끊지 않고 신뢰 승인을 예약합니다. 신뢰하지 않은 저장소의 확장·훅·도구·MCP는 실행하지 않습니다([docs/project-trust.md](./docs/project-trust.md)).
 - 비밀번호 잠금(HTTP Basic Auth, scrypt 해시 저장)과 `/recover` 복구([docs/authentication.md](./docs/authentication.md)).
@@ -177,7 +178,8 @@ node install.mjs start
 ## 개발
 
 ```bash
-bun install
+bun install --backend=copyfile
+bun run prepare:source  # SDK 호환 패치를 이 작업 사본에 적용
 bun run dev          # http://127.0.0.1:30141
 bun run typecheck
 bun run lint
@@ -187,6 +189,8 @@ bun run test:coverage  # 앱·설치기 테스트 + 커버리지 표
 
 개발 서버를 쓰는 동안 같은 출력 경로에 `bun run build`를 돌리지 마세요. `.next/`를 덮어써서 개발 서버가 깨집니다. 검증용 production 빌드는 별도 소스 복사본이나 격리된 `CUELO_DIST_DIR`에서 실행하세요.
 
+의존성을 다시 설치하거나 갱신한 뒤에는 `bun run prepare:source`를 다시 실행하세요. 이 준비 단계는 작업 사본의 SDK만 다루며 사용자 프로필이나 실행 중인 설치본을 변경하지 않습니다.
+
 참고 문서: [OMP 하네스](./docs/harness.md) · [인증](./docs/authentication.md) · [프로젝트 신뢰](./docs/project-trust.md) · [worktree](./docs/worktrees.md) · [다국어](./docs/i18n.md) · [Docker](./docs/docker.md)
 
 ## 계보와 라이선스

package/Tools/CUELO_Setup/files/native-runtime-patch.js

@@ -9,12 +9,12 @@ const MEMORY_RE = /(const phase1Model = await resolveMemoryModel\(\{[^}]*?fallba
 const MEMORY_DONE = /const phase1Model = await resolveMemoryModel\(\{[^}]*?fallbackRole: "smol"/;
 const EXPECTED = {
     name: 'cuelo',
-    version: '0.6.8',
+    version: '0.6.9',
     distribution: 'cuelo',
-    coreVersion: '18.4.4',
+    coreVersion: '18.4.5',
 };
 
-// OMP core 18.4.4 `src/sdk.ts`: session-scoped AsyncJobManager for a process
+// OMP core 18.4.5 `src/sdk.ts`: session-scoped AsyncJobManager for a process
 // that hosts several top-level sessions (CUELO opens one per browser session).
 // Upstream lets only the first top-level session construct a manager; every
 // later one got `asyncJobManager: undefined`, so its `task` calls logged
@@ -23,7 +23,7 @@ const EXPECTED = {
 // fix: it is disposed with its owning session (CUELO idle-shuts sessions
 // after 10 minutes) and would cancel every other session's jobs, and a
 // disposed manager throws on the next register(). Each edit is an exact text
-// anchor of the pristine 18.4.4 source (also present after core patch) and fails closed when it drifts.
+// anchor of the pristine 18.4.5 source (also present after core patch) and fails closed when it drifts.
 // `insertBefore` edits keep their anchor (the helper is inserted in front of
 // it), so their anchor count stays 1 after patching.
 const SDK_FILE = path.join('node_modules', '@oh-my-pi', 'pi-coding-agent', 'src', 'sdk.ts');
@@ -177,7 +177,7 @@ function readNativePackage(target) {
         throw new Error(`unexpected native package ${packageJson.name}@${packageJson.version}`);
     }
     if (!build || build.distribution !== EXPECTED.distribution || build.coreVersion !== EXPECTED.coreVersion) {
-        throw new Error('native cueloBuild metadata does not match cuelo / core 18.4.4');
+        throw new Error('native cueloBuild metadata does not match cuelo / core 18.4.5');
     }
     return packageJson;
 }

package/Tools/OMP_Global_Config/agent/extensions/jev-runtime.ts

@@ -1,8 +1,8 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
-import { registerMakerRouting } from "./lib/maker-routing";
+import { registerMakerRouting, workspaceOf, type Owner } from "./lib/maker-routing";
 import { clearPreparedTaskSession } from "./lib/prepared-task";
-import { createRoutingLedger, DEFAULT_LEDGER_PATH, scopedAttempts, type AttemptIdentity, type OutcomeRecord, type VerdictRecord } from "./lib/routing-ledger";
+import { createRoutingLedger, DEFAULT_LEDGER_PATH, scopedAttempts, type AttemptIdentity, type DispatchOwnership, type DispatchRecord, type OutcomeRecord, type VerdictRecord } from "./lib/routing-ledger";
 import {
   advanceTodoProgressState,
   assessTodoProgress,
@@ -162,6 +162,8 @@ interface SpawnedTaskMeta {
   agentId?: string;
   /** 그 spawn이 등록된 async jobId. details가 단일 spawn의 jobId를 줄 때만 채운다. */
   jobId?: string;
+  /** core spawn의 격리 요청(항목 값 우선, 없으면 상위 값). */
+  workspace: DispatchOwnership["workspace"];
 }
 
 function extractSpawnedTasks(
@@ -188,6 +190,7 @@ function extractSpawnedTasks(
       // 현재/이전 effort는 블라인드 판정을 깨므로 state에 싣지 않는다.
       guard,
       todoBindings: captureTodoBindings(guard.progress, currentTodos),
+      workspace: workspaceOf(input, item),
     });
   }
   return tasks;
@@ -858,7 +861,13 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
     });
     // spawn으로 실제 관측된 attempt. routing_verdict는 여기 있는 identity만 받는다.
     // 상태를 함께 두어 실행 중 attempt를 완료로 오인하지 않게 하고, session_start에서 원장 scoped 기록으로 복원한다.
-    type ObservedAttempt = AttemptIdentity & { name: string; status: "running" | OutcomeRecord["status"] };
+    // ownership은 그 attempt dispatch의 소유 계약(과거 row는 null=미상), restored는 session_start 원장 복원 계열이다.
+    type ObservedAttempt = AttemptIdentity & {
+      name: string;
+      status: "running" | OutcomeRecord["status"];
+      ownership: DispatchOwnership | null;
+      restored: boolean;
+    };
     const observedAttempts = new Map<string, ObservedAttempt>();
     /** outcome을 이미 기록한 attempt. 같은 attempt를 두 번 소비하지 않는다. */
     const settledAttempts = new Set<string>();
@@ -939,16 +948,17 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
     }
     const routing = registerMakerRouting(pi, {
       ledger: baseLedger,
-      owners: () => {
+      owners: (ctx) => {
         const activeTasks = [...liveMakers.values()].flat();
         const activeNames = new Set(
           activeTasks.flatMap((task) => task.name ? [task.name] : []),
         );
-        const owners = [...knownMakers.values()].map((task) => ({
+        const owners: Owner[] = [...knownMakers.values()].map((task) => ({
           name: task.name ?? null,
           primaryDeliverable: task.guard.primaryDeliverable ?? null,
           ownedPaths: task.guard.ownedPaths,
           active: Boolean(task.name && activeNames.has(task.name)),
+          workspace: task.workspace,
         }));
         for (const task of activeTasks) {
           if (task.name) continue;
@@ -957,8 +967,36 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
             primaryDeliverable: task.guard.primaryDeliverable ?? null,
             ownedPaths: task.guard.ownedPaths,
             active: true,
+            workspace: task.workspace,
           });
         }
+        // reload 전 spawn은 원장 복원 attempt로만 남는다. 이 runtime이 다시 관측한 이름은 위 목록이 우선한다.
+        // 이름별(이름 없으면 assignment별) 최신 attempt 하나만 owner로 두어 재작업이 소유를 중복 주장하지 않게 한다.
+        const restored = new Map<string, ObservedAttempt>();
+        for (const entry of observedAttempts.values()) {
+          if (!entry.restored || (entry.name && knownMakers.has(entry.name))) continue;
+          restored.set(entry.name || entry.assignmentId, entry);
+        }
+        // 원장 running은 프로세스 재시작으로 끝나지 못한 row일 수 있다. core async snapshot에 지금 실행 중인
+        // job이 있을 때만 active로 보아, 끝난·죽은 attempt가 영구 잠금이 되지 않게 한다.
+        const running = ctx.getAsyncJobSnapshot?.()?.running ?? [];
+        for (const entry of restored.values()) {
+          const active = entry.status === "running" && running.some((job) =>
+            job.agentId === entry.agentId || (entry.jobId !== "" && job.id === entry.jobId));
+          if (entry.ownership) {
+            if (!entry.name && !active) continue;
+            owners.push({
+              name: entry.name || null,
+              primaryDeliverable: entry.ownership.primaryDeliverable,
+              ownedPaths: entry.ownership.ownedPaths,
+              active,
+              workspace: entry.ownership.workspace,
+            });
+          } else if (active) {
+            // 소유 경로를 기록하지 않은 과거 row는 빈 소유로 위장하지 않는다. 실행 중일 때만 미상 owner로 둔다.
+            owners.push({ name: entry.name || null, primaryDeliverable: null, ownedPaths: [], active, ownershipUnknown: true });
+          }
+        }
         return owners;
       },
       // legacy-pi loader가 host SDK specifier를 재작성하므로 미러의 static runtime import는 불가하다.
@@ -1094,7 +1132,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
               jobId: job.jobId,
             };
             const sourceDispatch = baseLedger.read()
-              .filter((record) => record.type === "dispatch" && record.attemptId === source.attemptId)
+              .filter((record): record is DispatchRecord => record.type === "dispatch" && record.attemptId === source.attemptId)
               .at(-1);
             baseLedger.append({
               type: "dispatch",
@@ -1110,8 +1148,10 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
               chosenEffort: sourceDispatch?.chosenEffort ?? "",
               routingReason: sourceDispatch?.routingReason ?? false,
               purpose: sourceDispatch?.purpose ?? null,
+              // 재개 attempt는 원 attempt의 소유 계약을 그대로 잇는다. 미상이면 필드를 만들지 않는다.
+              ...(source.ownership ? { ownership: source.ownership } : {}),
             });
-            observedAttempts.set(identity.attemptId, { ...identity, name: source.name, status: "running" });
+            observedAttempts.set(identity.attemptId, { ...identity, name: source.name, status: "running", ownership: source.ownership, restored: source.restored });
             pendingResume.delete(agentId);
             resumeAttemptId = identity.attemptId;
           }
@@ -1253,7 +1293,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
       preWriteJobs.clear();
       pendingResume.clear();
       for (const entry of scopedAttempts(baseLedger.read(), typeof sessionId === "string" ? sessionId : "")) {
-        observedAttempts.set(entry.identity.attemptId, { ...entry.identity, name: entry.name, status: entry.status });
+        observedAttempts.set(entry.identity.attemptId, { ...entry.identity, name: entry.name, status: entry.status, ownership: entry.ownership, restored: true });
         if (entry.status !== "running") settledAttempts.add(entry.identity.attemptId);
       }
       // durable outcome이 남긴 jobId는 reload 뒤에도 중복 소비를 막는다.
@@ -1584,7 +1624,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
             };
           // 원 attempt의 dispatch metadata를 정확한 identity로 복사해 재작업 attempt가 같은 모델·effort 관측을 유지한다.
           const source = baseLedger.read()
-            .filter((record) => record.type === "dispatch" && record.attemptId === previous.attemptId)
+            .filter((record): record is DispatchRecord => record.type === "dispatch" && record.attemptId === previous.attemptId)
             .at(-1);
           baseLedger.append({
             type: "dispatch",
@@ -1600,8 +1640,9 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
             chosenEffort: source?.chosenEffort ?? "",
             routingReason: source?.routingReason ?? false,
             purpose: source?.purpose ?? null,
+            ...(previous.ownership ? { ownership: previous.ownership } : {}),
           });
-          observedAttempts.set(identity.attemptId, { ...identity, name: previous.name, status: "running" });
+          observedAttempts.set(identity.attemptId, { ...identity, name: previous.name, status: "running", ownership: previous.ownership, restored: previous.restored });
           // 바인딩에 전송 직후 관측한 정확한 새 jobId를 둔다. 다른 job이 먼저 정산돼도 이 attempt를 소비하지 않는다.
           resumeByAgent.set(targetAgentId, { attemptId: identity.attemptId, jobId: fresh[0]!, sentAt });
           sendAdvisory(
@@ -1661,12 +1702,13 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
         const dispatched = routing.noteSpawned(event.input, sessionId, event.toolCallId, ids);
         const identities: string[] = [];
         for (const task of spawned) {
-          const identity = dispatched.get(task.index);
-          if (!identity || !identity.sessionId) continue;
+          const entry = dispatched.get(task.index);
+          if (!entry || !entry.identity.sessionId) continue;
+          const { identity, ownership } = entry;
           task.identity = identity;
           if (identity.agentId) task.agentId = identity.agentId;
           if (identity.jobId) task.jobId = identity.jobId;
-          observedAttempts.set(identity.attemptId, { ...identity, name: task.name ?? "", status: "running" });
+          observedAttempts.set(identity.attemptId, { ...identity, name: task.name ?? "", status: "running", ownership, restored: false });
           identities.push(`${task.name ?? "<unnamed>"} agentId=${identity.agentId || "<unobserved>"} jobId=${identity.jobId || "<unobserved>"} ${identity.sessionId}|${identity.assignmentId}|${identity.attemptId}`);
         }
         if (identities.length > 0) {

package/Tools/OMP_Global_Config/agent/extensions/lib/maker-routing.ts

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@oh-my-pi/pi-coding-agent";
 import { isPathOwned, parseOwnedPaths } from "../command-guard/task-guard";
 import { resolvePreparedTaskInput, storePreparedTaskBatch } from "./prepared-task";
-import { assignmentsByName, summarizeHistory, type AttemptIdentity, type DispatchRecord, type RoutingHistory, type RoutingLedger } from "./routing-ledger";
+import { assignmentsByName, summarizeHistory, type AttemptIdentity, type DispatchOwnership, type DispatchRecord, type RoutingHistory, type RoutingLedger } from "./routing-ledger";
 
 export interface RoutingFacts {
   goal: string;
@@ -25,6 +25,10 @@ export interface Owner {
   primaryDeliverable: string | null;
   ownedPaths: string[];
   active?: boolean;
+  /** 관측된 spawn의 작업공간. 없으면 공유로 본다. */
+  workspace?: DispatchOwnership["workspace"];
+  /** 과거 원장 row처럼 소유 경로를 알 수 없는 owner. ownedPaths가 비어도 빈 소유가 아니다. */
+  ownershipUnknown?: boolean;
 }
 interface Candidate { profile: string; model: string; efforts: string[] }
 /** registry·추론 강도 확인에 실패한 후보. 다른 후보의 발주를 막지 않고, 다른 모델로 대체하지도 않는다. */
@@ -75,7 +79,8 @@ export type QuotaSnapshot =
 export interface RoutingDeps {
   judge: (ctx: ExtensionContext, request: { state: unknown; questions: Record<string, RoutingQuestion> }, signal?: AbortSignal) => Promise<{ answers: Record<string, RoutingAnswer> }>;
   settings: (ctx: ExtensionContext) => Promise<{ getModelRoles(): Readonly<Record<string, string>> } | undefined>;
-  owners: () => Owner[];
+  /** 현재 owner 목록. ctx는 실행 중 여부를 core async snapshot으로 확인할 때 쓴다. */
+  owners: (ctx: ExtensionContext) => Owner[];
   policy?: () => RoutingPolicy;
   candidates?: (ctx: ExtensionContext, policy: RoutingPolicy) => Promise<Candidate[]>;
   /** 후보 provider별 계정 잔량. 생략하면 CUELO usage 사이드카(`OMP_USAGE_PORT`, 기본 30142)를 읽는다. */
@@ -399,6 +404,20 @@ function relevantOwners(contract: DispatchContract, owners: Owner[]): Owner[] {
   );
 }
 
+type Workspace = DispatchOwnership["workspace"];
+
+/**
+ * core spawnParamsFor와 같은 우선순위로 task 항목의 격리 요청을 읽는다. 항목 값이 있으면 그것, 없으면 상위 값이다.
+ * isolated 요청은 격리 준비 실패 시 공유 cwd로 fallback하지 않고 실패하므로(structured-subagent) 별도 worktree scope다.
+ */
+export function workspaceOf(input: Record<string, unknown>, item: Record<string, unknown>): Workspace {
+  return (item.isolated !== undefined ? item.isolated : input.isolated) === true ? "isolated" : "shared";
+}
+
+/** 같은 checkout을 동시에 쓰는 경우만 충돌이다. 격리 worktree는 서로·공유 작업공간과 별도 scope다. */
+const sharesCheckout = (left: Workspace | undefined, right: Workspace | undefined) =>
+  left !== "isolated" && right !== "isolated";
+
 function ownerRevision(owners: Owner[]): string {
   return JSON.stringify(owners.map((owner) => [
     owner.name,
@@ -498,7 +517,9 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
   };
   const bindings = new Map<string, Promise<Prepared>>();
   // 검사를 통과한 발주의 이력 초안. spawn 성공(noteSpawned) 때만 identity와 함께 ledger에 남긴다.
-  const pendingDispatches = new Map<string, Omit<DispatchRecord, "ts" | keyof AttemptIdentity>>();
+  // 새 초안은 항상 소유 계약을 싣는다. 원장의 과거 row만 ownership이 없을 수 있다.
+  type DispatchDraft = Omit<DispatchRecord, "ts" | "ownership" | keyof AttemptIdentity> & { ownership: DispatchOwnership };
+  const pendingDispatches = new Map<string, DispatchDraft>();
   // 거절 진단 전용 색인. 준비된 계약을 이름별로 시간순으로 모아 어긋난 필드를 지목하며,
   // 통과·차단 판정에는 관여하지 않는다.
   const preparedContracts = new Map<string, DispatchContract[]>();
@@ -646,7 +667,7 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
   /** 배치 공통 정보(candidates·quota·instruction)는 한 번만, task별 route는 배열로 돌려준다. */
   async function prepareBatch(context: string, tasks: RouteTask[], ctx: ExtensionContext, signal?: AbortSignal, callId = "") {
     const current = policy();
-    const allOwners = deps.owners();
+    const allOwners = deps.owners(ctx);
     const atGeneration = generation;
     // TaskGuard는 같은 요청의 첫 child가 확립한 WORK_CLASS/PRIMARY_DELIVERABLE을 이후 child에
     // 파생한다. 준비 도구도 같은 batch와 이미 연결된 task에서 그 두 필드만 상속한다.
@@ -877,7 +898,7 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
       candidateLock ??= { workClass: contract.workClass, primaryDeliverable: contract.primaryDeliverable };
       return contract;
     });
-    const drafts: [string, Omit<DispatchRecord, "ts" | keyof AttemptIdentity>][] = [];
+    const drafts: [string, DispatchDraft][] = [];
     for (const [itemIndex, item] of tasks.entries()) {
       const requested = typeof item.model === "string" ? item.model : "";
       const task = typeof item.task === "string" ? item.task : "";
@@ -911,7 +932,8 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
         return { block: true, reason: "candidate 확인 중 같은 task 계약에 더 최신 maker_route 준비가 생겼습니다. 최신 판단으로 발주하세요." };
       }
       if (prepared.revision !== revisionOf(current, candidates)) return { block: true, reason: "후보 또는 판단 기준이 바뀌었습니다. maker_route로 변경된 조건만 다시 판단하세요." };
-      const owners = relevantOwners(contract, deps.owners());
+      const allOwners = deps.owners(ctx);
+      const owners = relevantOwners(contract, allOwners);
       if (ownerRevision(prepared.owners) !== ownerRevision(owners)) return { block: true, reason: "현재 소유권 충돌 조건이 바뀌었습니다. maker_route로 owner placement만 다시 판단하세요." };
       // 같은 모델이 여러 profile에 있을 수 있다(HARD_*). 추천 profile, 이어서 추천 등급의
       // profile 구간으로 검사해 등급의 강도 구간을 모델 이름으로 우회하지 못하게 한다. 추천 등급에 그 모델이
@@ -937,11 +959,17 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
       const index = candidates.findIndex((candidate) => candidate.profile === selected.profile);
       const recommendedEffort = selected.efforts.length === 1 ? selected.efforts[0] : answers?.[`effort${index}`]?.choice;
       const placement = placementOf(prepared, owners);
-      const activeConflicts = owners.filter((owner) => owner.active === true);
+      const workspace = workspaceOf(canonicalInput, item);
+      // 같은 checkout을 쓰는 active owner만 충돌이다. 소유 경로 미상 active owner는 빈 소유로 보지 않고 공유 발주 전체와 충돌로 둔다.
+      const activeConflicts = [
+        ...owners.filter((owner) => owner.active === true && sharesCheckout(owner.workspace, workspace)),
+        ...allOwners.filter((owner) => owner.active === true && owner.ownershipUnknown === true && sharesCheckout(owner.workspace, workspace)),
+      ];
       if (activeConflicts.length > 0) {
+        const unknown = activeConflicts.some((owner) => owner.ownershipUnknown === true);
         return {
           block: true,
-          reason: `현재 active owner의 소유 경로와 충돌합니다: ${activeConflicts.map((owner) => owner.name ?? "<unnamed>").join(", ")}. 오래된 owner index나 다른 경로 owner로 자동 배정하지 말고 현재 owner에게 지시하거나 maker_route로 placement를 다시 판단하세요.`,
+          reason: `현재 active owner의 소유 경로와 충돌합니다: ${activeConflicts.map((owner) => owner.name ?? "<unnamed>").join(", ")}. 오래된 owner index나 다른 경로 owner로 자동 배정하지 말고 현재 owner에게 지시하거나 maker_route로 placement를 다시 판단하세요.${unknown ? " 소유 경로가 기록되지 않은 과거 발주가 아직 실행 중이라 공유 작업공간의 어느 경로와도 겹칠 수 있다고 봅니다. 그 owner가 끝난 뒤 발주하거나 isolated로 발주하세요." : ""}`,
         };
       }
       const existingOwner = placement.action === "instruct-existing" || placement.action === "retarget-existing";
@@ -964,8 +992,25 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
         chosenEffort: effort,
         routingReason,
         purpose: guardFields(task)?.("PURPOSE").toLowerCase() || null,
+        ownership: { primaryDeliverable: contract.primaryDeliverable, ownedPaths: contract.ownedPaths, workspace },
       }]);
     }
+    // 같은 배치의 공유 작업공간 항목끼리는 게시 전에 한꺼번에 비교한다. 하나라도 겹치면 어떤 초안도 게시하지 않는다.
+    const overlaps: string[] = [];
+    for (const [leftIndex, [, left]] of drafts.entries()) {
+      for (const [, right] of drafts.slice(leftIndex + 1)) {
+        if (!sharesCheckout(left.ownership.workspace, right.ownership.workspace)) continue;
+        const shared = left.ownership.ownedPaths.filter((path) =>
+          right.ownership.ownedPaths.some((other) => ownedPathsOverlap(path, other)));
+        if (shared.length > 0) overlaps.push(`'${clipped(left.name, 40)}' ↔ '${clipped(right.name, 40)}'(${clippedList(shared)})`);
+      }
+    }
+    if (overlaps.length > 0) {
+      return {
+        block: true,
+        reason: `같은 task 배치에서 공유 작업공간 Maker의 OWNED_PATHS가 겹칩니다: ${overlaps.slice(0, DIAGNOSTIC_LIST_LIMIT).join("; ")}. 배치 전체를 발주하지 않았습니다. 경로를 나누거나 한 owner에게 맡기거나, 겹치는 쪽을 순서대로 내거나 isolated로 발주하세요.`,
+      };
+    }
     for (const [key, draft] of drafts) pendingDispatches.set(key, draft);
     return canonicalInput === input ? undefined : { input: canonicalInput };
   }
@@ -973,16 +1018,16 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
   /**
    * task spawn 성공 경계. TaskGuard lock을 확립하고, 검사를 통과해 실제로 spawn된 발주만 이력에 남긴다.
    * 실제 attempt identity는 이 spawn의 task 호출 id·index·session으로만 캡처한다(준비 handle과 섞지 않는다).
-   * 돌려주는 map은 task index → 관측된 identity이며, settle 시 같은 identity로 outcome을 잇는다.
+   * 돌려주는 map은 task index → 관측된 identity와 원장에 남긴 소유 계약이며, settle 시 같은 identity로 outcome을 잇는다.
    */
   function noteSpawned(
     input: Record<string, unknown>,
     sessionId: string,
     callId: string,
     ids: ReadonlyMap<number, { agentId: string; jobId: string }>,
-  ): Map<number, AttemptIdentity> {
+  ): Map<number, { identity: AttemptIdentity; ownership: DispatchOwnership }> {
     const tasks = (Array.isArray(input.tasks) ? input.tasks : [input]) as Record<string, unknown>[];
-    const dispatched = new Map<number, AttemptIdentity>();
+    const dispatched = new Map<number, { identity: AttemptIdentity; ownership: DispatchOwnership }>();
     // 같은 session 원장에서 이름별 assignment·최대 attempt를 읽어 FINDING_ID 재작업만 같은 assignment로 잇는다.
     // 원장에서 읽으므로 reload 뒤에도 연결이 유지되고, 관측되지 않은 준비만으로는 연결하지 않는다.
     const known = assignmentsByName(deps.ledger?.read() ?? [], sessionId);
@@ -1012,7 +1057,7 @@ export function registerMakerRouting(pi: ExtensionAPI, deps: RoutingDeps) {
         jobId: ids.get(index)?.jobId ?? "",
       };
       deps.ledger?.append({ ...draft, ...identity, ts: new Date().toISOString() });
-      dispatched.set(index, identity);
+      dispatched.set(index, { identity, ownership: draft.ownership });
       known.set(name, { assignmentId, lastAttempt: attempt });
     }
     contractLock ??= candidateLock;

package/Tools/OMP_Global_Config/agent/extensions/lib/routing-ledger.ts

@@ -24,6 +24,16 @@ export interface AttemptIdentity {
   jobId: string;
 }
 
+/**
+ * 실제 spawn으로 관측된 발주의 소유 계약. restart 뒤 owner 충돌 판정을 복원하는 근거다.
+ * workspace는 core spawn의 격리 요청이다: isolated 요청은 격리 준비에 실패하면 공유 cwd로 fallback하지 않고 실패한다.
+ */
+export interface DispatchOwnership {
+  primaryDeliverable: string;
+  ownedPaths: string[];
+  workspace: "shared" | "isolated";
+}
+
 export interface DispatchRecord extends AttemptIdentity {
   type: "dispatch";
   ts: string;
@@ -40,6 +50,8 @@ export interface DispatchRecord extends AttemptIdentity {
   chosenEffort: string;
   routingReason: boolean;
   purpose: string | null;
+  /** 이 필드가 생기기 전 기록에는 없다. 없으면 소유 미상이며 빈 소유가 아니다. */
+  ownership?: DispatchOwnership;
 }
 
 export interface OutcomeRecord extends AttemptIdentity {
@@ -182,13 +194,27 @@ export function assignmentsByName(
   return known;
 }
 
+/** 기록된 ownership이 기대 형태일 때만 쓴다. 과거·손상 row는 null(미상)이며 빈 소유로 바꾸지 않는다. */
+function ownershipOf(record: DispatchRecord): DispatchOwnership | null {
+  const value = record.ownership;
+  if (!value || typeof value.primaryDeliverable !== "string" || !Array.isArray(value.ownedPaths)
+    || !value.ownedPaths.every((path) => typeof path === "string")
+    || (value.workspace !== "shared" && value.workspace !== "isolated")) return null;
+  return { primaryDeliverable: value.primaryDeliverable, ownedPaths: [...value.ownedPaths], workspace: value.workspace };
+}
+
+export interface ScopedAttempt {
+  identity: AttemptIdentity;
+  name: string;
+  status: OutcomeRecord["status"] | "running";
+  /** 그 attempt dispatch의 소유 계약. dispatch가 없거나 과거 형식이면 null(미상). */
+  ownership: DispatchOwnership | null;
+}
+
 /** 같은 session에서 identity가 있는 attempt를 원장에서 복원한다. dispatch·outcome·verdict 어느 것으로도 등록된다. */
-export function scopedAttempts(
-  records: readonly LedgerRecord[],
-  sessionId: string,
-): { identity: AttemptIdentity; name: string; status: OutcomeRecord["status"] | "running" }[] {
+export function scopedAttempts(records: readonly LedgerRecord[], sessionId: string): ScopedAttempt[] {
   if (!sessionId) return [];
-  const byAttempt = new Map<string, { identity: AttemptIdentity; name: string; status: OutcomeRecord["status"] | "running" }>();
+  const byAttempt = new Map<string, ScopedAttempt>();
   const order: string[] = [];
   for (const record of records) {
     if (!hasIdentity(record) || record.sessionId !== sessionId) continue;
@@ -204,9 +230,12 @@ export function scopedAttempts(
       },
       name: "",
       status: "running",
+      ownership: null,
     };
-    if (record.type === "dispatch") entry.name = record.name;
-    else if (record.type === "outcome") entry.status = record.status;
+    if (record.type === "dispatch") {
+      entry.name = record.name;
+      entry.ownership = ownershipOf(record);
+    } else if (record.type === "outcome") entry.status = record.status;
     if (!byAttempt.has(key)) order.push(key);
     byAttempt.set(key, entry);
   }