cuelo 0.5.0 → 0.5.1

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

@@ -659,8 +659,10 @@ function parseGitInvocation(tokens: ShellToken[], invocation: Invocation): GitIn
   };
 }
 
+// `~`는 단어 맨 앞이나 assignment 꼴의 `=`·`:` 뒤에서만 셸이 확장한다. 경로 중간의 literal
+// `~`(8.3 짧은 이름 `RUNNER~1` 등)는 확장이 아니므로 저장소 판정으로 넘긴다.
 function hasShellExpansion(value: string): boolean {
-  return /[$%`~*?]/.test(value);
+  return /[$%`*?]|(?:^|[=:])~/.test(value);
 }
 
 function finalizerTargetDirectory(

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

@@ -800,12 +800,14 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
     const settledAttempts = new Set<string>();
     /** settle로 이미 소비한 async jobId. 채널(via)과 무관하게 중복 소비하지 않는다. */
     const consumedJobs = new Set<string>();
-    /** 명시 REWORK 전송이 성공해 열린 재개 attempt. agentId → 그 전송 직후 관측한 정확한 새 jobId. */
-    const resumeByAgent = new Map<string, { attemptId: string; jobId: string }>();
+    /** 명시 REWORK 전송이 성공해 열린 재개 attempt. agentId → 그 전송 직후 관측한 정확한 새 jobId와 전송 시각. */
+    const resumeByAgent = new Map<string, { attemptId: string; jobId: string; sentAt: number }>();
     /** 전송별 snapshot을 보존해 같은 actor로 겹친 DM도 서로의 기준선을 덮지 않는다. */
-    const preWriteJobs = new Map<string, Set<string>>();
+    const preWriteJobs = new Map<string, { known: Set<string>; sentAt: number }>();
     /** 성공한 REWORK receipt. 새 job이 실제 snapshot에 나타나기 전에는 attempt를 만들지 않는다. */
-    const pendingResume = new Map<string, { priorJobs: ReadonlySet<string>; sourceAttemptId: string }>();
+    const pendingResume = new Map<string, { priorJobs: ReadonlySet<string>; sourceAttemptId: string; sentAt: number }>();
+    /** 재사용 jobId로 온 재개 실행 중 이미 검수한 실행(`jobId@startTime`). 같은 실행은 채널과 무관하게 한 번만 본다. */
+    const judgedResumeRuns = new Set<string>();
     const VERDICTS = ["accepted", "rework", "held"] as const;
     type VerdictInput = {
       sessionId: string; assignmentId: string; attemptId: string; verdict: string;
@@ -953,6 +955,36 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
         else liveMakers.delete(ref.callId);
       }
     }
+    /**
+     * core는 task job을 `id: agentId`로 등록하고 소비된 row를 곧 evict하므로 재개(IRC wake) 실행이 같은 jobId를 다시 받는다.
+     * async-result에는 agentId도 없다. 그래서 agentId는 현재 snapshot row(id 정확 일치)에서만 읽고, 열린 REWORK receipt의
+     * 전송 시각 이후 시작된 row만 재개 실행(resumeKey)으로 본다. row가 없거나(evict) 전송 전 row면 재개가 아니다.
+     */
+    function settledRun(job: SettledJobMeta, ctx: ExtensionContext): { agentId?: string; resumeKey?: string } {
+      const snapshot = ctx.getAsyncJobSnapshot?.();
+      const row = [...(snapshot?.running ?? []), ...(snapshot?.recent ?? [])].find((entry) => entry.id === job.jobId);
+      const agentId = job.agentId ?? row?.agentId;
+      if (!row || !agentId || row.agentId !== agentId || typeof row.startTime !== "number") return { agentId };
+      const sentAt = pendingResume.get(agentId)?.sentAt ?? resumeByAgent.get(agentId)?.sentAt;
+      return sentAt !== undefined && row.startTime >= sentAt
+        ? { agentId, resumeKey: `${job.jobId}@${row.startTime}` }
+        : { agentId };
+    }
+    /** 처음 보는 jobId이거나, 재사용 jobId라도 아직 검수하지 않은 재개 실행이면 검수 대상이다. */
+    function takeUnjudged(jobs: SettledJobMeta[], ctx: ExtensionContext): SettledJobMeta[] {
+      return jobs.filter((job) => {
+        if (!judgedReviews.has(job.jobId)) {
+          judgedReviews.add(job.jobId);
+          const { resumeKey } = settledRun(job, ctx);
+          if (resumeKey) judgedResumeRuns.add(resumeKey);
+          return true;
+        }
+        const { resumeKey } = settledRun(job, ctx);
+        if (!resumeKey || judgedResumeRuns.has(resumeKey)) return false;
+        judgedResumeRuns.add(resumeKey);
+        return true;
+      });
+    }
     async function runPreReview(
       ctx: ExtensionContext,
       via: "async-result" | "wait" | "read proc://",
@@ -968,15 +1000,21 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
           : undefined;
         const todoMetadata = spawned?.guard.progress;
         // 재개 바인딩은 그 전송 직후 관측한 정확한 새 jobId에만 소비된다. 다른 job(늦은 원 실행·stale)은 소비하지 않는다.
-        const binding = job.agentId ? resumeByAgent.get(job.agentId) : undefined;
-        let resumeAttemptId = binding && binding.jobId === job.jobId ? binding.attemptId : undefined;
+        // 이미 소비한 jobId의 재사용은 전송 뒤 시작된 snapshot row(resumeKey)일 때만 새 실행으로 본다.
+        const run = settledRun(job, ctx);
+        const agentId = run.agentId;
+        const newRun = !consumedJobs.has(job.jobId) || run.resumeKey !== undefined;
+        const binding = agentId ? resumeByAgent.get(agentId) : undefined;
+        let resumeAttemptId = binding && binding.jobId === job.jobId && newRun ? binding.attemptId : undefined;
         // 늦은 이벤트 자체를 새 실행으로 간주하지 않는다. 현재 snapshot에서 확인한 유일한 새 job만 잇는다.
-        if (!resumeAttemptId && job.agentId && !spawned?.identity && !consumedJobs.has(job.jobId)) {
-          const pending = pendingResume.get(job.agentId);
+        if (!resumeAttemptId && agentId && !spawned?.identity && newRun) {
+          const pending = pendingResume.get(agentId);
           const source = pending ? observedAttempts.get(pending.sourceAttemptId) : undefined;
           const snapshot = pending ? ctx.getAsyncJobSnapshot?.() : undefined;
           const candidates = new Set([...(snapshot?.running ?? []), ...(snapshot?.recent ?? [])]
-            .filter((entry) => entry.agentId === job.agentId && !pending!.priorJobs.has(entry.id) && !consumedJobs.has(entry.id))
+            .filter((entry) => entry.agentId === agentId && (
+              (typeof entry.startTime === "number" && entry.startTime >= pending!.sentAt)
+              || (!pending!.priorJobs.has(entry.id) && !consumedJobs.has(entry.id))))
             .map((entry) => entry.id));
           if (pending && source && candidates.size === 1 && candidates.has(job.jobId)) {
             const attempt = source.attempt + 1;
@@ -985,7 +1023,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
               assignmentId: source.assignmentId,
               attempt,
               attemptId: `${source.assignmentId}#a${attempt}`,
-              agentId: job.agentId,
+              agentId,
               jobId: job.jobId,
             };
             const sourceDispatch = baseLedger.read()
@@ -1007,20 +1045,20 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
               purpose: sourceDispatch?.purpose ?? null,
             });
             observedAttempts.set(identity.attemptId, { ...identity, name: source.name, status: "running" });
-            pendingResume.delete(job.agentId);
+            pendingResume.delete(agentId);
             resumeAttemptId = identity.attemptId;
           }
         }
         // session_start에서 복원한 in-flight dispatch도 실제 jobId·agentId로 정산한다.
         const identity = resumeAttemptId ? observedAttempts.get(resumeAttemptId)
           : spawned?.identity ?? [...observedAttempts.values()].find((entry) =>
-            entry.status === "running" && entry.jobId === job.jobId && entry.agentId === job.agentId);
+            entry.status === "running" && entry.jobId === job.jobId && entry.agentId === agentId);
         // 채널과 무관하게 이미 소비한 jobId는 다시 처리하지 않고, 같은 attempt도 한 번만 소비한다.
-        if (identity && !consumedJobs.has(job.jobId) && !settledAttempts.has(identity.attemptId)
+        if (identity && (!consumedJobs.has(job.jobId) || resumeAttemptId !== undefined) && !settledAttempts.has(identity.attemptId)
           && (spawned?.agent === undefined || spawned.agent === "maker")) {
           consumedJobs.add(job.jobId);
           settledAttempts.add(identity.attemptId);
-          if (resumeAttemptId && job.agentId) resumeByAgent.delete(job.agentId);
+          if (resumeAttemptId && agentId) resumeByAgent.delete(agentId);
           const status: OutcomeRecord["status"] = job.status === "cancelled" ? "cancelled" : job.hasError ? "failed" : "completed";
           baseLedger.append({
             type: "outcome",
@@ -1160,6 +1198,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
       knownMakers.clear();
       routing.reset();
       judgedReviews.clear();
+      judgedResumeRuns.clear();
       advisedOwnerMessages.clear();
       advisedMissingVerdicts.clear();
       pendingCheckpoints.clear();
@@ -1211,11 +1250,8 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
       // pre-review: async-result 자동 전달이 Main에 도착하는 가장 이른 경계.
       // async-result는 attribution:"agent"로 오므로 attribution 필터보다 먼저 본다.
       if (message.role !== "custom" || message.customType !== "async-result") return;
-      const settled = readSettledTaskJobs(message.details, message.content).filter(
-        (job) => !judgedReviews.has(job.jobId),
-      );
+      const settled = takeUnjudged(readSettledTaskJobs(message.details, message.content), ctx);
       if (settled.length === 0) return;
-      for (const job of settled) judgedReviews.add(job.jobId);
       await runPreReview(
         ctx,
         "async-result",
@@ -1275,7 +1311,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
           for (const entry of observedAttempts.values()) {
             if (entry.agentId === target && entry.jobId) known.add(entry.jobId);
           }
-          preWriteJobs.set(event.toolCallId, known);
+          preWriteJobs.set(event.toolCallId, { known, sentAt: Date.now() });
         }
         // canonical child id가 agent:// 대상이다. 표시용 task name으로 판정 대상을 추측하지 않는다.
         const owner = target ? knownMakerForTarget(target) : undefined;
@@ -1373,12 +1409,14 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
         if (targetAgentId && previous && /(?:^|\n)\s*REWORK\s+task_id=\S+/i.test(message)
           && previous.status !== "running" && !resumeByAgent.has(targetAgentId) && !pendingResume.has(targetAgentId) && beforeWrite) {
           // 성공 receipt와 전송 전 snapshot이 있는 경우에만 실제 새 job을 바인딩한다.
-          const prior = beforeWrite;
+          const { known: prior, sentAt } = beforeWrite;
           const snapshot = ctx.getAsyncJobSnapshot?.();
           const fresh = [...new Set([...(snapshot?.running ?? []), ...(snapshot?.recent ?? [])]
             .flatMap((job) => {
-              const record = job as { id?: unknown; agentId?: unknown };
-              if (typeof record.id !== "string" || !record.id || prior.has(record.id)) return [];
+              const record = job as { id?: unknown; agentId?: unknown; startTime?: unknown };
+              if (typeof record.id !== "string" || !record.id) return [];
+              // 전송 전 집합의 id라도 전송 뒤 시작된 row면 같은 id를 재사용한 새 실행이다.
+              if (prior.has(record.id) && !(typeof record.startTime === "number" && record.startTime >= sentAt)) return [];
               // 관측된 canonical agentId가 정확히 같은 job만 후보다. agentId 없는 낯선 job은 승격하지 않는다.
               if (record.agentId !== targetAgentId) return [];
               return [record.id];
@@ -1414,7 +1452,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
           });
           observedAttempts.set(identity.attemptId, { ...identity, name: previous.name, status: "running" });
           // 바인딩에 전송 직후 관측한 정확한 새 jobId를 둔다. 다른 job이 먼저 정산돼도 이 attempt를 소비하지 않는다.
-          resumeByAgent.set(targetAgentId, { attemptId: identity.attemptId, jobId: fresh[0]! });
+          resumeByAgent.set(targetAgentId, { attemptId: identity.attemptId, jobId: fresh[0]!, sentAt });
           sendAdvisory(
             "rework-attempt",
             renderAdvisory(
@@ -1426,7 +1464,7 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
           );
           } else if (fresh.length === 0) {
             // 새 job이 아직 스냅샷에 없다. 성공 receipt를 보관하고 다음 기존 관측(settle)에서 실제 새 job을 묶는다.
-            pendingResume.set(targetAgentId, { priorJobs: prior, sourceAttemptId: previous.attemptId });
+            pendingResume.set(targetAgentId, { priorJobs: prior, sourceAttemptId: previous.attemptId, sentAt });
           }
         }
       }
@@ -1549,11 +1587,8 @@ export function createJevRuntime(deps: JevRuntimeDeps = {}) {
       } else {
         return;
       }
-      const settled = readSettledTaskJobs(jobDetails, event.content).filter(
-        (job) => !judgedReviews.has(job.jobId),
-      );
+      const settled = takeUnjudged(readSettledTaskJobs(jobDetails, event.content), ctx);
       if (settled.length === 0) return;
-      for (const job of settled) judgedReviews.add(job.jobId);
       await runPreReview(
         ctx,
         via,

package/Tools/OMP_Global_Config/agent/extensions/todo-nudge.ts

@@ -1,56 +1,56 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
-import { readPersistedTodoProgress, readTodoSnapshot, type TodoSnapshotItem } from "./lib/task-progress";
-
-// 여러 단계 요청에서 Main 이 todo 없이 도구만 이어 부르면 한 번 안내한다(2026-09-26: GPT 계열은 todo 를
-// 잘 쓰는데 Claude Main 은 생략하는 일이 잦아, 사용자가 화면에서 Main 이 무엇을 하는지 알 수 없었다).
-// 도구는 막지 않고, 사용자 직접 입력이 있을 때만 켜지므로 그런 입력을 받지 않는 child 세션에는 개입하지 않는다.
-
-/** todo 없이 이만큼 도구를 부르면 3단계 이상 작업으로 본다(AGENTS 「3단계 이상이면 todo」와 같은 기준). */
-const TOOL_CALLS_BEFORE_NUDGE = 3;
-
-const REMINDER =
-  "이번 사용자 요청에서 todo 목록 없이 도구를 여러 번 이어 부르고 있다. 사용자는 todo 목록으로 지금 무엇을 하는지 본다. 3단계 이상이거나 사용자가 여러 항목을 요청한 작업이면 지금 todo 를 init 해서 요청 항목을 빠짐없이 나누고, 진행에 맞춰 상태를 갱신하며 이어 가라. 조회 한두 번으로 끝나는 일이면 이 안내는 무시한다.";
-
-const isActive = (items: readonly TodoSnapshotItem[]) =>
-  items.some((item) => item.status === "pending" || item.status === "in_progress");
-
-export default function todoNudge(pi: ExtensionAPI): void {
-  let armed = false;
-  let usedTodo = false;
-  let nudged = false;
-  let calls = 0;
-  let todos: readonly TodoSnapshotItem[] = [];
-
-  pi.on("session_start", (_event, ctx) => {
-    armed = false;
-    todos = readPersistedTodoProgress(ctx.sessionManager.getBranch()).currentTodos;
-  });
-  pi.on("input", (event) => {
-    if (event.source !== "interactive" && event.source !== "rpc") return;
-    armed = true;
-    usedTodo = false;
-    nudged = false;
-    calls = 0;
-  });
-  pi.on("tool_result", (event) => {
-    if (event.toolName !== "todo" || event.isError) return;
-    const snapshot = readTodoSnapshot(event.details);
-    if (snapshot) todos = snapshot;
-  });
-  pi.on("tool_call", (event) => {
-    if (!armed || nudged || usedTodo) return;
-    if (event.toolName === "todo") {
-      usedTodo = true;
-      return;
-    }
-    // 이전 요청의 진행 중 목록이 있으면 이미 추적 중이다. 끼어든 짧은 지시마다 새 목록을 강요하지 않는다.
-    if (isActive(todos)) return;
-    calls += 1;
-    if (calls < TOOL_CALLS_BEFORE_NUDGE) return;
-    nudged = true;
-    pi.sendMessage(
-      { customType: "todo-nudge", content: REMINDER, display: false, attribution: "agent" },
-      { deliverAs: "aside" },
-    );
-  });
-}
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { readPersistedTodoProgress, readTodoSnapshot, type TodoSnapshotItem } from "./lib/task-progress";
+
+// 여러 단계 요청에서 Main 이 todo 없이 도구만 이어 부르면 한 번 안내한다(2026-09-26: GPT 계열은 todo 를
+// 잘 쓰는데 Claude Main 은 생략하는 일이 잦아, 사용자가 화면에서 Main 이 무엇을 하는지 알 수 없었다).
+// 도구는 막지 않고, 사용자 직접 입력이 있을 때만 켜지므로 그런 입력을 받지 않는 child 세션에는 개입하지 않는다.
+
+/** todo 없이 이만큼 도구를 부르면 3단계 이상 작업으로 본다(AGENTS 「3단계 이상이면 todo」와 같은 기준). */
+const TOOL_CALLS_BEFORE_NUDGE = 3;
+
+const REMINDER =
+  "이번 사용자 요청에서 todo 목록 없이 도구를 여러 번 이어 부르고 있다. 사용자는 todo 목록으로 지금 무엇을 하는지 본다. 3단계 이상이거나 사용자가 여러 항목을 요청한 작업이면 지금 todo 를 init 해서 요청 항목을 빠짐없이 나누고, 진행에 맞춰 상태를 갱신하며 이어 가라. 조회 한두 번으로 끝나는 일이면 이 안내는 무시한다.";
+
+const isActive = (items: readonly TodoSnapshotItem[]) =>
+  items.some((item) => item.status === "pending" || item.status === "in_progress");
+
+export default function todoNudge(pi: ExtensionAPI): void {
+  let armed = false;
+  let usedTodo = false;
+  let nudged = false;
+  let calls = 0;
+  let todos: readonly TodoSnapshotItem[] = [];
+
+  pi.on("session_start", (_event, ctx) => {
+    armed = false;
+    todos = readPersistedTodoProgress(ctx.sessionManager.getBranch()).currentTodos;
+  });
+  pi.on("input", (event) => {
+    if (event.source !== "interactive" && event.source !== "rpc") return;
+    armed = true;
+    usedTodo = false;
+    nudged = false;
+    calls = 0;
+  });
+  pi.on("tool_result", (event) => {
+    if (event.toolName !== "todo" || event.isError) return;
+    const snapshot = readTodoSnapshot(event.details);
+    if (snapshot) todos = snapshot;
+  });
+  pi.on("tool_call", (event) => {
+    if (!armed || nudged || usedTodo) return;
+    if (event.toolName === "todo") {
+      usedTodo = true;
+      return;
+    }
+    // 이전 요청의 진행 중 목록이 있으면 이미 추적 중이다. 끼어든 짧은 지시마다 새 목록을 강요하지 않는다.
+    if (isActive(todos)) return;
+    calls += 1;
+    if (calls < TOOL_CALLS_BEFORE_NUDGE) return;
+    nudged = true;
+    pi.sendMessage(
+      { customType: "todo-nudge", content: REMINDER, display: false, attribution: "agent" },
+      { deliverAs: "aside" },
+    );
+  });
+}

package/Tools/OMP_Global_Config/agent/prompt-copies/AGENTS.en.md

@@ -1,4 +1,4 @@
-<!-- source-fingerprint: a40686cf83c6d49d -->
+<!-- source-fingerprint: 13a662daf067abc8 -->
 # Global Agent Instructions
 
 (Model-facing English copy of the Korean source `AGENTS.md`. All user-facing prose stays Korean.)
@@ -7,7 +7,7 @@
 
 This section overrides every rule and Skill. For any user message or interjection, **reply briefly in that same turn first**, then continue with investigation, tools, delegation, or verification. Never delay the answer to wait for complete results; on a change of direction, state progress in one line and follow the new instruction. Keep the selected character voice not only in the first reply but in tool narration, failures, risks, unverified items, progress, and the final answer. Unless the user asked about procedure, do not list roles, providers, or investigation order as a kickoff report, and do not turn verification/evidence/status contracts into a routine answer format. State facts, risks, and uncertainty precisely; preserve code, commands, paths, APIs, and raw errors.
 
-Keep the user oriented during long turns where you chain tools alone. **When you find a cause, when a check passes or fails, and when you move to the next step**, first write that fact and the next action in one or two sentences, then call the next tool. Never chain tool calls with no prose in between. When relaying a child report you did not verify, say it is unverified.
+Keep the user oriented during long turns where you chain tools alone. **When you find a cause, when a check passes or fails, and when you move to the next step**, first write that fact and the next action in one or two sentences, then call the next tool. Never chain tool calls with no prose in between. When relaying a child report you did not verify, say it is unverified. Write everything addressed to the user (immediate replies, progress, results) as visible response text, never inside reasoning/thinking: sentences inside thinking never reach the user's screen or the session record.
 
 **Observe only at the four moments below, and then completely. With no live child, background job, or `bash` `name` service, this does not apply.**
 
@@ -90,8 +90,8 @@ Alias + `교체` switches the current Main session; alias + `호출`·`불러`·
 |---|---|---|---|
 |**YUKI(유키)**|`openai-codex/gpt-6-astra`|task child on this model|switch current session only|
 |**ISANA(이사나)**|`b-ai/deepseek-v4.1-flash`|task child on this model|switch current session only|
-|**RIN(린)**|`anthropic/claude-opus-5-5`, 지정 계정|task child pinned to its account|pin its account, then switch current session|
-|**MIO(미오)**|`anthropic/claude-opus-5-5`, 지정 계정|task child pinned to its account|pin its account, then switch current session|
+|**RIN(린)**|`anthropic/claude-opus-5-5`, OAuth position `0`|task child pinned to position 0|pin position 0, then switch current session|
+|**MIO(미오)**|`anthropic/claude-opus-5-5`, OAuth position `1`|task child pinned to position 1|pin position 1, then switch current session|
 |**NOVA(노바)**|`opencode-go/muse-spark-1.3-contributor`|task child on this model|switch current session only|
 |**SHION(시온)**|`web6/gpt-6-pro`|`rule://web6-consult` consult (not a child)|forbidden|