cuelo 0.10.69 → 0.10.71

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":85845976,"timestamp":494313,"id":14,"parentId":1,"tags":{},"startTime":1792825122948,"traceId":"cb9ecb5dc0c3643e"},{"name":"run-typescript","duration":18741147,"timestamp":86695593,"id":11007,"parentId":1,"tags":{},"startTime":1792825209149,"traceId":"cb9ecb5dc0c3643e"},{"name":"static-check","duration":3317961,"timestamp":105536147,"id":11010,"parentId":1,"tags":{},"startTime":1792825227990,"traceId":"cb9ecb5dc0c3643e"},{"name":"static-generation","duration":4934400,"timestamp":108945665,"id":11178,"parentId":1,"tags":{},"startTime":1792825231399,"traceId":"cb9ecb5dc0c3643e"},{"name":"collect-build-traces","duration":19216849,"timestamp":108923202,"id":11175,"parentId":1,"tags":{},"startTime":1792825231377,"traceId":"cb9ecb5dc0c3643e"},{"name":"telemetry-flush","duration":115,"timestamp":128144594,"id":11187,"parentId":1,"tags":{},"startTime":1792825250598,"traceId":"cb9ecb5dc0c3643e"},{"name":"next-build","duration":127732439,"timestamp":412300,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1792825122866,"traceId":"cb9ecb5dc0c3643e"}]
+[{"name":"run-webpack","duration":69369772,"timestamp":381380,"id":14,"parentId":1,"tags":{},"startTime":1792893364989,"traceId":"1e142890171be839"},{"name":"run-typescript","duration":14231324,"timestamp":70158528,"id":11007,"parentId":1,"tags":{},"startTime":1792893434766,"traceId":"1e142890171be839"},{"name":"static-check","duration":2436485,"timestamp":84458146,"id":11010,"parentId":1,"tags":{},"startTime":1792893449066,"traceId":"1e142890171be839"},{"name":"static-generation","duration":6868284,"timestamp":86970693,"id":11178,"parentId":1,"tags":{},"startTime":1792893451578,"traceId":"1e142890171be839"},{"name":"collect-build-traces","duration":15411171,"timestamp":86953851,"id":11175,"parentId":1,"tags":{},"startTime":1792893451561,"traceId":"1e142890171be839"},{"name":"telemetry-flush","duration":60,"timestamp":102368551,"id":11187,"parentId":1,"tags":{},"startTime":1792893466976,"traceId":"1e142890171be839"},{"name":"next-build","duration":102049528,"timestamp":319104,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1792893364926,"traceId":"1e142890171be839"}]

package/README.md

@@ -233,7 +233,7 @@ Windows의 WSL Ubuntu에서 실행 중인 CUELO를 갱신하는 동안에는 WSL
 WSL 갱신에서는 시스템 시각이 보정되어도 실행 중인 서버를 같은 서버로 인식해, 진행 중인 대화의 중단·재개 절차를 건너뛰지 않습니다.
 WSL 갱신은 실행 중인 서버와 분리해 새 버전을 미리 빌드한 뒤 교체합니다. 빌드 캐시는 재사용하고 다시 만들 산출물은 복사하지 않아 준비 과정의 디스크 쓰기를 줄입니다.
 
-기존 프로필의 하네스·역할 설정은 앱 업데이트만으로 자동 덮어쓰지 않습니다. `0.6.1`의 설정 전환은 [기존 하네스 갱신](./docs/installation.md#061로-기존-하네스-갱신)을 확인하고, 반영 후 CUELO와 `omp`를 다시 시작하세요.
+기존 프로필의 하네스·역할 설정은 앱 업데이트만으로 자동 덮어쓰지 않습니다. 새 버전의 하네스는 `node install.mjs harness-diff`로 차이를 보고 `node install.mjs harness-update`로 반영합니다. 사용자가 고치지 않은 파일만 백업 후 바꾸고, 고친 파일과 `config.yml`은 그대로 둡니다([기존 프로필의 하네스 갱신](./docs/installation.md#기존-프로필의-하네스-갱신)). 반영 후 CUELO와 `omp`를 다시 시작하세요.
 
 ```bash
 git pull --ff-only

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

@@ -9,7 +9,7 @@ const MEMORY_RE = /(const phase1Model = await resolveMemoryModel\(\{[^}]*?fallba
 const MEMORY_DONE = /const phase1Model = await resolveMemoryModel\(\{[^}]*?fallbackRole: "smol"/;
 const EXPECTED = {
     name: 'cuelo',
-    version: '0.10.69',
+    version: '0.10.71',
     distribution: 'cuelo',
     coreVersion: '18.12.6',
 };

package/Tools/OMP_Global_Config/agent/extensions/command-guard/index.ts

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
+import { appendFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 import { isToolCallEventType, type ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { resolveToCwd } from "@oh-my-pi/pi-coding-agent/tools/path-utils";
@@ -24,8 +24,12 @@ import { matchPowerShellSyntax } from "./powershell-syntax";
 import {
   bindSpawnAliases,
   bindTaskGuardSession,
+  bindWriterOwners,
+  claimSharedWriters,
   createOwnershipState,
   createTaskGuardState,
+  createWriterClaimState,
+  decideOwnerWrite,
   dropOwnedChildren,
   hasUnreportedChildren,
   matchBlockedEvalModelBridge,
@@ -40,16 +44,23 @@ import {
   reservedMakers,
   resetOwnershipState,
   resetTaskGuardState,
+  resetWriterClaimState,
+  settleSharedWriters,
   settleTaskCall,
   stripScopePrefix,
   unbindTaskGuardSession,
+  unbindWriterOwners,
+  writerOwnersOf,
   type EvalCallInput,
   type MakerSpawn,
+  type OwnershipOutsideRow,
   type OwnershipState,
+  type RunningTaskJob,
   type TaskCallInput,
   type TaskCallOutcome,
   type TaskJobRow,
   type TreeSnapshot,
+  type WriterOwnerView,
 } from "./task-guard";
 
 /** WSL에서 Windows 실행 파일을 부를 수 있는지(binfmt interop 등록). Windows 출력 변환을 이때만 붙인다. */
@@ -105,6 +116,52 @@ function readTaskJobRegistry(ctx: unknown): TaskJobRow[] | undefined {
   return rows;
 }
 
+/**
+ * 세션이 소유한 실행 중 task job만 읽는다. core snapshot은 소유 세션 기준이라 child가 아니라 부모 ctx로 읽어야 한다.
+ * 조회 API가 없거나 실패하면 undefined(소유자 미상)이며, 빈 목록으로 대신하지 않는다.
+ */
+function readRunningTaskJobs(ctx: unknown): RunningTaskJob[] | undefined {
+  if (!ctx || typeof ctx !== "object" || !("getAsyncJobSnapshot" in ctx)) return undefined;
+  const read = ctx.getAsyncJobSnapshot;
+  if (typeof read !== "function") return undefined;
+  let snapshot: unknown;
+  try {
+    snapshot = read.call(ctx, { recentLimit: 0 });
+  } catch {
+    return undefined;
+  }
+  if (!snapshot || typeof snapshot !== "object" || !("running" in snapshot) || !Array.isArray(snapshot.running)) {
+    return undefined;
+  }
+  const jobs: RunningTaskJob[] = [];
+  for (const job of snapshot.running) {
+    if (!job || typeof job !== "object" || !("type" in job) || job.type !== "task") continue;
+    if (!("id" in job) || typeof job.id !== "string" || !job.id) continue;
+    const agentId = "agentId" in job && typeof job.agentId === "string" && job.agentId ? job.agentId : undefined;
+    jobs.push({ id: job.id, ...(agentId ? { agentId } : {}) });
+  }
+  return jobs;
+}
+
+/** edit·write 대상. core가 edit 이벤트 입력에 hashline 헤더를 풀어 `path`(한 파일)·`paths`(여러 파일)로 넣는다. */
+function writeTargets(input: unknown): string[] {
+  if (!input || typeof input !== "object") return [];
+  const record = input as Record<string, unknown>;
+  const raw: unknown[] = [...(Array.isArray(record.paths) ? record.paths : []), record.path];
+  return [...new Set(raw.flatMap((value) => (typeof value === "string" && value.trim() ? [value.trim()] : [])))];
+}
+
+/**
+ * OwnershipGuard의 `outside=none`이 아닌 완료 보고를 한 줄씩 덧붙이는 기록. 실행 프로필의 agent 루트
+ * (routing-ledger.jsonl·steering-gate-miss.jsonl과 같은 자리)에 둔다. 원장 레코드 종류는 늘리지 않는다.
+ */
+export const OWNERSHIP_OUTSIDE_LOG_PATH = join(import.meta.dir, "..", "..", "ownership-outside.jsonl");
+
+export interface CommandGuardDeps {
+  /** 범위 밖 변경 기록 파일. 테스트만 바꾼다. 기본은 OWNERSHIP_OUTSIDE_LOG_PATH다. */
+  ownershipOutsideLog?: string;
+}
+
 /**
  * bash 도구의 `cwd` 인자를 코어 bash와 같은 규칙으로 푼다. WSL에서 `E:/x`·`E:\x`는 코어가
  * `/mnt/e/x`에서 실행하므로, `path.resolve`로 `<세션 cwd>/E:/x`를 만들면 없는 경로의 저장소를
@@ -159,6 +216,7 @@ function sameMakerReservation(
       !right ||
       left.name !== right.name ||
       left.index !== right.index ||
+      left.isolated !== right.isolated ||
       left.ownedPaths.length !== right.ownedPaths.length
     ) {
       return false;
@@ -671,12 +729,105 @@ function hasOnlyExactCompletionCalls(input: EvalCallInput, target: string): bool
  * 그 뒤 기존 task budget/ownership, eval bridge, bash guard를 같은 순서로 적용한다.
  * 이 index.ts만 자동 로드되며 matcher/guard 오류는 잡지 않아 OMP 코어의 fail-closed 동작을 보존한다.
  */
-export default function commandGuard(pi: ExtensionAPI): void {
+function commandGuardWith(pi: ExtensionAPI, deps: CommandGuardDeps): void {
   const taskGuard = createTaskGuardState();
   const ownership = createOwnershipState();
   const summonCalls = new Map<string, CharacterAlias[]>();
   let pendingSummons: CharacterAlias[] = [];
   let ownershipGeneration = 0;
+  const ownershipOutsideLog = deps.ownershipOutsideLog ?? OWNERSHIP_OUTSIDE_LOG_PATH;
+
+  // OwnerWriteGuard: 이 세션이 띄운 공유 작업공간 Maker의 쓰기 소유. child 세션은 자기 parentId로 이 view를 찾는다.
+  // 실행 중 job은 소유 세션 기준 snapshot에만 보이므로 이 세션이 최근 받은 ctx로 읽는다.
+  const writers = createWriterClaimState();
+  let ownerCtx: unknown;
+  let ownerCwd = "";
+  let boundOwnerId = "";
+  const writerView: WriterOwnerView = {
+    get cwd() {
+      return ownerCwd;
+    },
+    state: writers,
+    running: () => readRunningTaskJobs(ownerCtx),
+  };
+  const bindWriterView = (ctx: { cwd?: string; agent?: { id?: string } }): void => {
+    ownerCtx = ctx;
+    ownerCwd = eventSessionCwd(ctx);
+    const id = (ctx.agent?.id ?? "").trim();
+    if (!id || id === boundOwnerId) return;
+    if (boundOwnerId) unbindWriterOwners(boundOwnerId, writerView);
+    bindWriterOwners(id, writerView);
+    boundOwnerId = id;
+  };
+
+  /** 소유 밖 변경·미관측 보고 한 건을 덧붙인다. 진단 기록 실패가 보고 전달을 막지 않는다. */
+  const recordOwnershipOutside = (
+    row: OwnershipOutsideRow,
+    ctx: { sessionManager?: { getSessionId?: () => string } } | undefined,
+  ): void => {
+    try {
+      const sessionId = (ctx?.sessionManager?.getSessionId?.() ?? "").trim();
+      appendFileSync(ownershipOutsideLog, `${JSON.stringify({ ts: new Date().toISOString(), sessionId, ...row })}\n`);
+    } catch (error) {
+      pi.logger?.debug("command-guard: ownership-outside 기록 실패", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  };
+
+  /**
+   * 공유 작업공간 Maker child의 edit·write가 같은 부모의 다른 활성 Maker 소유 경로를 건드리면 막을 이유를 돌린다.
+   * Main·Maker가 아닌 agent·격리 child(부모와 cwd가 다름)는 대상이 아니고, 부모 view나 job snapshot이 없어 소유자를
+   * 확정하지 못하면 debug 기록만 남기고 막지 않는다. bash 쓰기는 대상 경로를 믿을 만하게 풀 수 없어 보지 않는다.
+   */
+  const ownerWriteBlockReason = (
+    toolName: string,
+    input: unknown,
+    ctx: { cwd?: string; agent?: { kind?: string; id?: string; name?: string; parentId?: string } },
+  ): string | undefined => {
+    const agent = ctx.agent;
+    if (!agent) {
+      pi.logger?.debug("command-guard: OwnerWriteGuard 판정 생략(ctx.agent 없음)");
+      return undefined;
+    }
+    if (agent.kind !== "sub" || agent.name !== "maker") return undefined;
+    const skip = (why: string, detail?: Record<string, unknown>): undefined => {
+      pi.logger?.debug(`command-guard: OwnerWriteGuard 판정 생략(${why})`, { agentId: agent.id, ...detail });
+      return undefined;
+    };
+    const selfId = (agent.id ?? "").trim();
+    const parentId = (agent.parentId ?? "").trim();
+    if (!selfId || !parentId) return skip("agent id 미상");
+    const view = writerOwnersOf(parentId);
+    if (!view) return skip("부모 view 없음", { parentId });
+    const cwd = eventSessionCwd(ctx);
+    if (!view.cwd || normalizeRepositoryPath(cwd) !== normalizeRepositoryPath(view.cwd)) {
+      return skip("공유 checkout 아님", { cwd, parentCwd: view.cwd });
+    }
+    const targets: string[] = [];
+    for (const path of writeTargets(input)) {
+      let absolute: string;
+      try {
+        absolute = resolveToCwd(path, cwd);
+      } catch {
+        continue; // agent://·proc:// 같은 내부 URL은 작업 트리 파일이 아니다.
+      }
+      const rel = relative(view.cwd, absolute);
+      if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) continue;
+      targets.push(rel);
+    }
+    if (targets.length === 0) return undefined;
+    const decision = decideOwnerWrite(view, selfId, targets);
+    if (!decision) return skip("부모 job snapshot 없음", { parentId });
+    if (decision.unknown.length > 0) skip("소유 주장 없는 실행 중 child", { unknown: decision.unknown });
+    if (!decision.conflict) return undefined;
+    const { owner, path } = decision.conflict;
+    return (
+      `[OwnerWriteGuard] ${path}은(는) 지금 실행 중인 다른 Maker ${owner}의 OWNED_PATHS 안이라 ${toolName}을 막았습니다. ` +
+      `직접 고치지 말고 필요한 변경·이유·근거 위치를 write agent://${parentId}로 Main에 보고하세요. ` +
+      "자기 OWNED_PATHS 안이나 다른 실행 중 Maker가 소유하지 않은 경로는 그대로 쓸 수 있습니다."
+    );
+  };
 
   /**
    * 한 terminal event의 exact child들은 스냅샷 하나를 공유한다. await 중 reset되거나 다른
@@ -684,7 +835,7 @@ export default function commandGuard(pi: ExtensionAPI): void {
    */
   const reportPendingOwnedChildren = async (
     ids: readonly string[],
-    ctx: { cwd?: string } | undefined,
+    ctx: { cwd?: string; sessionManager?: { getSessionId?: () => string } } | undefined,
   ): Promise<string[]> => {
     const pendingKeys = exactUnreportedOwnedChildKeys(ownership, ids);
     if (pendingKeys.length === 0) return [];
@@ -696,7 +847,7 @@ export default function commandGuard(pi: ExtensionAPI): void {
       return entry !== undefined && !entry.reported;
     });
     if (stillPendingKeys.length === 0) return [];
-    return reportOwnedChildren(ownership, stillPendingKeys, tree);
+    return reportOwnedChildren(ownership, stillPendingKeys, tree, (row) => recordOwnershipOutside(row, ctx));
   };
 
   // tool-capable child가 실제로 뜨지 못했으면 첫 행동 계약을 다시 요구한다.
@@ -725,6 +876,8 @@ export default function commandGuard(pi: ExtensionAPI): void {
     outcome: TaskCallOutcome,
     progress: readonly { index: number; id: string }[],
   ): void => {
+    // 쓰기 소유 주장은 요청 경계와 무관하게 이 호출의 결과로 in-flight를 내리고 canonical id를 묶는다.
+    settleSharedWriters(writers, toolCallId, progress);
     const before = reservedMakers(taskGuard, toolCallId) ?? [];
     const settlement = settleTaskCall(taskGuard, toolCallId, outcome);
     if (!settlement) return;
@@ -760,6 +913,7 @@ export default function commandGuard(pi: ExtensionAPI): void {
       ownershipGeneration += 1;
       resetTaskGuardState(taskGuard);
       resetOwnershipState(ownership);
+      resetWriterClaimState(writers);
       summonCalls.clear();
       pendingSummons = [];
       bindSession(ctx);
@@ -768,6 +922,8 @@ export default function commandGuard(pi: ExtensionAPI): void {
   pi.on("session_shutdown", () => {
     if (boundSessionId) unbindTaskGuardSession(boundSessionId, taskGuard);
     boundSessionId = "";
+    if (boundOwnerId) unbindWriterOwners(boundOwnerId, writerView);
+    boundOwnerId = "";
   });
 
   // 실제 사용자 입력 하나를 budget 단위로 본다. extension 내부 주입은 같은 요청의
@@ -915,6 +1071,8 @@ export default function commandGuard(pi: ExtensionAPI): void {
           };
         }
         registerSpawnedMakers(ownership, event.toolCallId, currentMakers, snapshot);
+        claimSharedWriters(writers, event.toolCallId, currentMakers);
+        bindWriterView(ctx);
       }
       // task guard의 metadata 파생이 character summon brief보다 나중에 적용돼야 둘 다 보존된다.
       if (decision.input) return { input: decision.input };
@@ -922,6 +1080,11 @@ export default function commandGuard(pi: ExtensionAPI): void {
       return;
     }
 
+    if (event.toolName === "edit" || event.toolName === "write") {
+      const reason = ownerWriteBlockReason(event.toolName, event.input, ctx);
+      if (reason) return { block: true, reason };
+    }
+
     // 호출을 받은 뒤 모드·roster가 바뀌어 alias의 target을 더는 풀 수 없으면 우회하지 않고 막는다(다음 사용자 입력이 새로 정한다).
     const unresolvedSummons = pendingSummons.filter((alias) => characterTarget(alias) === undefined);
     if (unresolvedSummons.length > 0) return { block: true, reason: unresolvedSummonReason(unresolvedSummons) };
@@ -1108,3 +1271,9 @@ export default function commandGuard(pi: ExtensionAPI): void {
     );
   });
 }
+
+export function createCommandGuard(deps: CommandGuardDeps = {}): (pi: ExtensionAPI) => void {
+  return (pi) => commandGuardWith(pi, deps);
+}
+
+export default createCommandGuard();

package/Tools/OMP_Global_Config/agent/extensions/command-guard/task-guard.ts

@@ -64,6 +64,8 @@ export type MakerSpawn = {
   /** 원본 tasks[] 안의 위치. progress[].index가 같은 기준을 쓰므로 이 값으로 대응시킨다. */
   index: number;
   ownedPaths: string[];
+  /** 격리 worktree에서 실행한다(`isolated: true|"capture"`). 공유 checkout의 쓰기 소유자가 아니다. */
+  isolated?: true;
 };
 
 export type TaskGuardState = {
@@ -105,6 +107,8 @@ type SpawnItem = {
   name?: string;
   /** 호출이 agent를 생략했다. 위임 정의가 maker 하나뿐이라 maker로 해석하고 반환 input에도 기록한다. */
   agentOmitted?: true;
+  /** 항목 값이 있으면 그것, 없으면 상위 `isolated`가 격리를 요청했다(core spawnParamsFor와 같은 우선순위). */
+  isolated?: true;
 };
 
 export type TaskCallInput = Record<string, unknown>;
@@ -297,6 +301,11 @@ function canonicalizeTask(
   return task.slice(0, raw.span.start) + rendered + task.slice(raw.span.end);
 }
 
+/** `isolated: true`와 `"capture"`(patch만 보존)는 둘 다 별도 worktree scope다(maker-routing workspaceOf와 같은 기준). */
+function isolationRequested(value: unknown): boolean {
+  return value === true || value === "capture";
+}
+
 function normalizeSpawnItems(input: TaskCallInput): SpawnItem[] | string {
   if (Array.isArray(input.tasks)) {
     if (input.tasks.length === 0) return "[SpawnGuard] tasks[]가 비어 있습니다.";
@@ -316,6 +325,9 @@ function normalizeSpawnItems(input: TaskCallInput): SpawnItem[] | string {
         ...(typeof item.name === "string" && item.name.trim()
           ? { name: item.name.trim() }
           : {}),
+        ...(isolationRequested(item.isolated !== undefined ? item.isolated : input.isolated)
+          ? { isolated: true as const }
+          : {}),
       });
     }
     return items;
@@ -332,6 +344,7 @@ function normalizeSpawnItems(input: TaskCallInput): SpawnItem[] | string {
       ...(typeof input.name === "string" && input.name.trim()
         ? { name: input.name.trim() }
         : {}),
+      ...(isolationRequested(input.isolated) ? { isolated: true as const } : {}),
     },
   ];
 }
@@ -467,6 +480,7 @@ export function reserveTaskCall(
         ...(item.name ? { name: item.name } : {}),
         index,
         ownedPaths: metadata.ownedPaths,
+        ...(item.isolated ? { isolated: true as const } : {}),
       });
     }
 
@@ -907,10 +921,15 @@ function outsidePaths(ownedPaths: readonly string[], changedPaths: readonly stri
     .sort();
 }
 
+/** 정규화한 소유 경로와 소유 밖 변경. 스냅샷이 없으면 판정할 수 없어 `unobserved`다. */
+function ownershipOutcome(input: OwnershipReportInput): { owned: string[]; outside: string[] | "unobserved" } {
+  const owned = input.ownedPaths.map(normalizeOwnedPath).filter((entry) => entry.length > 0);
+  return { owned, outside: input.changedPaths === undefined ? "unobserved" : outsidePaths(owned, input.changedPaths) };
+}
+
 /** OwnershipGuard 보고 한 줄. 공백 구분 key=value이며 인용부호를 쓰지 않는다. */
 export function buildOwnershipReport(input: OwnershipReportInput): string {
-  const owned = input.ownedPaths.map(normalizeOwnedPath).filter((entry) => entry.length > 0);
-  const outside = input.changedPaths === undefined ? "unobserved" : outsidePaths(owned, input.changedPaths);
+  const { owned, outside } = ownershipOutcome(input);
   return (
     `[OwnershipGuard] child=${encodeReportToken(input.child)}` +
     ` owned=${owned.map(encodeReportToken).join(",")}` +
@@ -1103,14 +1122,29 @@ function findOwnedChildKey(state: OwnershipState, id: string): string | undefine
   return found;
 }
 
+/**
+ * 소유 밖 변경이 있었거나(`outside` 목록) 변경을 관측하지 못한(`unobserved`) 완료 보고 한 건.
+ * 보고 줄은 그 턴의 대화에만 남으므로 빈도를 셀 수 있게 index.ts가 이 행을 JSONL로 덧붙인다.
+ */
+export type OwnershipOutsideRow = {
+  child: string;
+  /** spawn 이름과 task 결과 progress id(canonical agent id). */
+  childIds: string[];
+  owned: string[];
+  outside: string[] | "unobserved";
+  concurrent: string[];
+};
+
 /**
  * 종료가 관측된 child들의 OwnershipGuard 줄을 만든다. child마다 정확히 한 번만 보고하고
- * (보고 후 스냅샷을 버리고 reported로 표시) 모르는 id는 무시한다.
+ * (보고 후 스냅샷을 버리고 reported로 표시) 모르는 id는 무시한다. `outside=none`이 아닌 보고는
+ * onOutside에도 넘긴다.
  */
 export function reportOwnedChildren(
   state: OwnershipState,
   ids: readonly string[],
   tree: TreeSnapshot | undefined,
+  onOutside?: (row: OwnershipOutsideRow) => void,
 ): string[] {
   const lines: string[] = [];
   for (const id of ids) {
@@ -1124,14 +1158,185 @@ export function reportOwnedChildren(
     const concurrent = concurrentChildNames(state, entry, entry.endOrder);
     const changedPaths = entry.snapshot && tree ? diffTreeSnapshots(entry.snapshot, tree) : undefined;
     entry.snapshot = undefined;
-    lines.push(
-      buildOwnershipReport({
-        child: entry.child,
-        ownedPaths: entry.ownedPaths,
-        ...(changedPaths ? { changedPaths } : {}),
-        concurrent,
-      }),
-    );
+    const input: OwnershipReportInput = {
+      child: entry.child,
+      ownedPaths: entry.ownedPaths,
+      ...(changedPaths ? { changedPaths } : {}),
+      concurrent,
+    };
+    lines.push(buildOwnershipReport(input));
+    const { owned, outside } = ownershipOutcome(input);
+    if (onOutside && (outside === "unobserved" || outside.length > 0)) {
+      onOutside({ child: entry.child, childIds: [...entry.aliases], owned, outside, concurrent });
+    }
   }
   return lines;
 }
+
+// ============================================================================
+// OwnerWriteGuard: 공유 작업공간 Maker child가 같은 부모의 다른 실행 중 Maker가 소유한 경로에 edit·write하는 것을 막는다.
+// OWNED_PATHS 겹침은 발주 때만(maker-routing) 검사됐고, 실행 중 범위 밖 쓰기는 완료 뒤 OwnershipGuard 보고로만 드러났다.
+// 다른 활성 owner가 없는 범위 밖 경로(직접 원인인 인접 파일)는 그대로 허용한다. 소유자를 확정하지 못하면 막지 않는다.
+// ============================================================================
+
+/** 공유 작업공간 maker spawn 하나의 쓰기 소유 주장. */
+type WriterClaim = {
+  /** 보고 라벨: tasks[].name 또는 `unnamed`. */
+  child: string;
+  name?: string;
+  ownedPaths: string[];
+  /** spawn한 task 호출 id와 원본 tasks[] 위치. */
+  callId: string;
+  index: number;
+  /** task 결과 progress가 준 canonical agent id. 실행 중 job과는 이 값으로만 대응시킨다. */
+  ids: string[];
+  /** 등록 순서. 같은 id를 가진 주장이 여럿이면 가장 최근 것이 그 job의 주장이다. */
+  order: number;
+  /** spawn한 task 호출이 아직 끝나지 않았다. foreground child는 job snapshot에 보이지 않으므로 이 표시로 실행 중이다. */
+  inFlight: boolean;
+};
+
+/**
+ * 한 부모 세션의 쓰기 소유 주장. 완료 보고용 OwnershipState와 달리 사용자 입력마다 비우지 않는다:
+ * 앞 요청이 띄운 Maker도 아직 실행 중이면 그 경로의 owner다. 세션이 바뀔 때만 비운다.
+ */
+export type WriterClaimState = { claims: Map<string, WriterClaim>; order: number };
+
+export function createWriterClaimState(): WriterClaimState {
+  return { claims: new Map(), order: 0 };
+}
+
+export function resetWriterClaimState(state: WriterClaimState): void {
+  state.claims.clear();
+  state.order = 0;
+}
+
+/** spawn 직전 공유 작업공간 maker 항목을 in-flight 주장으로 등록한다. 격리 항목은 공유 checkout을 쓰지 않아 주장하지 않는다. */
+export function claimSharedWriters(state: WriterClaimState, callId: string, makers: readonly MakerSpawn[]): void {
+  for (const maker of makers) {
+    if (maker.isolated) continue;
+    const key = ownedChildKey(callId, maker.index);
+    if (state.claims.has(key)) continue;
+    state.order += 1;
+    state.claims.set(key, {
+      child: maker.name ?? "unnamed",
+      ...(maker.name ? { name: maker.name } : {}),
+      ownedPaths: [...maker.ownedPaths],
+      callId,
+      index: maker.index,
+      ids: [],
+      order: state.order,
+      inFlight: true,
+    });
+  }
+}
+
+/**
+ * spawn한 task 호출이 끝났다(tool_result 또는 실행 전 종료). progress id를 canonical id로 묶고 in-flight를 내린다.
+ * 이후 활성 여부는 부모의 실행 중 job으로만 정하므로, 뜨지 못한 child의 주장은 저절로 비활성이다.
+ */
+export function settleSharedWriters(
+  state: WriterClaimState,
+  callId: string,
+  progress: readonly { index: number; id: string }[],
+): void {
+  for (const claim of state.claims.values()) {
+    if (claim.callId !== callId) continue;
+    claim.inFlight = false;
+    const id = progress.find((row) => row.index === claim.index)?.id;
+    if (id && !claim.ids.includes(id)) claim.ids.push(id);
+  }
+}
+
+/** 부모 세션이 소유한 실행 중 task job 한 건(core async job snapshot 행). */
+export type RunningTaskJob = { id: string; agentId?: string };
+
+/** child가 부모 agent id로 찾는 부모 세션의 쓰기 소유 창구. */
+export type WriterOwnerView = {
+  /** 부모 세션 cwd(절대경로). 같은 cwd의 child만 공유 checkout을 쓴다. */
+  cwd: string;
+  state: WriterClaimState;
+  /** 부모 세션이 소유한 실행 중 task job. 읽지 못하면 undefined(소유자 미상). */
+  running(): RunningTaskJob[] | undefined;
+};
+
+/** 부모와 child 세션은 같은 프로세스에서 확장 module을 공유한다. 여러 번 평가되어도 같은 map을 보도록 globalThis에 둔다. */
+const WRITER_OWNERS = Symbol.for("@oh-my-pi/omp/writer-owners/v1");
+const writerOwners: Map<string, WriterOwnerView> = (() => {
+  const existing = Reflect.get(globalThis, WRITER_OWNERS) as Map<string, WriterOwnerView> | undefined;
+  if (existing) return existing;
+  const created = new Map<string, WriterOwnerView>();
+  Reflect.set(globalThis, WRITER_OWNERS, created);
+  return created;
+})();
+
+export function bindWriterOwners(agentId: string, view: WriterOwnerView): void {
+  const key = agentId.trim();
+  if (key) writerOwners.set(key, view);
+}
+
+/** 자기 view일 때만 푼다. 같은 agent id를 이어받은 새 세션의 연결을 옛 인스턴스의 늦은 정리가 지우지 않는다. */
+export function unbindWriterOwners(agentId: string, view: WriterOwnerView): void {
+  const key = agentId.trim();
+  if (key && writerOwners.get(key) === view) writerOwners.delete(key);
+}
+
+export function writerOwnersOf(agentId: string): WriterOwnerView | undefined {
+  return writerOwners.get(agentId.trim());
+}
+
+export type OwnerWriteDecision = {
+  /** 다른 활성 owner가 가진 첫 대상. 없으면 허용이다. */
+  conflict?: { owner: string; path: string };
+  /** 소유 주장을 찾지 못한 실행 중 job·이름 없는 in-flight spawn. 막을 근거가 아니며 진단에만 쓴다. */
+  unknown: string[];
+};
+
+/**
+ * child `selfId`가 부모 cwd 기준 상대경로 `targets`에 쓰려 할 때 다른 활성 owner와 충돌하는지 본다. 부모의 job snapshot을
+ * 읽지 못하면 undefined(소유자 미상)다. 활성 owner는 spawn 호출이 아직 끝나지 않은 주장과, canonical id의 job이 지금
+ * 실행 중인 주장(REWORK 재개 포함)이다. 자기 소유 경로는 겹쳐도 허용하고, 자기일 수 있는 주장은 다른 owner로 보지 않는다.
+ */
+export function decideOwnerWrite(
+  view: WriterOwnerView,
+  selfId: string,
+  targets: readonly string[],
+): OwnerWriteDecision | undefined {
+  const running = view.running();
+  if (!running) return undefined;
+  const own: WriterClaim[] = [];
+  const others: WriterClaim[] = [];
+  const unknown: string[] = [];
+  for (const claim of view.state.claims.values()) {
+    if (!claim.inFlight) continue;
+    if (!claim.name) {
+      unknown.push(`in-flight:${claim.callId}#${claim.index}`);
+      continue;
+    }
+    // 이름 있는 child의 agent id는 이름이거나 충돌 변형(`이름-2`, `이름-3` …)이다. 자기일 수 있으면 자기로 본다.
+    const suffix = selfId.startsWith(`${claim.name}-`) ? selfId.slice(claim.name.length + 1) : "";
+    (selfId === claim.name || /^\d+$/.test(suffix) ? own : others).push(claim);
+  }
+  for (const job of running) {
+    // job id는 실행 handle이라 agent id와 다를 수 있다(충돌 시 `이름-2` 등). 주장과 자기 판정은 canonical agent id로만 하고,
+    // snapshot에 agentId가 없는 옛 행만 job id를 대신 쓴다.
+    const agentId = job.agentId ?? job.id;
+    let match: WriterClaim | undefined;
+    for (const claim of view.state.claims.values()) {
+      if (!claim.ids.includes(agentId)) continue;
+      if (!match || claim.order > match.order) match = claim;
+    }
+    if (!match) {
+      if (agentId !== selfId) unknown.push(agentId);
+      continue;
+    }
+    (agentId === selfId ? own : others).push(match);
+  }
+  const ownPaths = own.flatMap((claim) => claim.ownedPaths);
+  for (const path of targets) {
+    if (isPathOwned(ownPaths, path)) continue;
+    const owner = others.find((claim) => isPathOwned(claim.ownedPaths, path));
+    if (owner) return { conflict: { owner: owner.child, path: collapseOwnedPath(path) }, unknown };
+  }
+  return { unknown };
+}