claudecode-omc 4.8.4 → 4.9.3

package/skills/trace/SKILL.md

@@ -0,0 +1,262 @@
+---
+name: trace
+description: Evidence-driven tracing lane that orchestrates competing tracer hypotheses in Claude built-in team mode
+agent: tracer
+level: 2
+---
+
+# Trace Skill
+
+Use this skill for ambiguous, causal, evidence-heavy questions where the goal is to explain **why** an observed result happened, not to jump directly into fixing or rewriting code.
+
+This is the orchestration layer on top of the built-in `tracer` agent. The goal is to make tracing feel like a reusable OMC operating lane: restate the observation, generate competing explanations, gather evidence in parallel, rank the explanations, and propose the next probe that would collapse uncertainty fastest.
+
+## Good entry cases
+
+Use `/oh-my-claudecode:trace` when the problem is:
+
+- ambiguous
+- causal
+- evidence-heavy
+- best answered by exploring competing explanations in parallel
+
+Examples:
+- runtime bugs and regressions
+- performance / latency / resource behavior
+- architecture / premortem / postmortem analysis
+- scientific or experimental result tracing
+- config / routing / orchestration behavior explanation
+- “given this output, trace back the likely causes”
+
+## Core tracing contract
+
+Always preserve these distinctions:
+
+1. **Observation** -- what was actually observed
+2. **Hypotheses** -- competing explanations
+3. **Evidence For** -- what supports each explanation
+4. **Evidence Against / Gaps** -- what contradicts it or is still missing
+5. **Current Best Explanation** -- the leading explanation right now
+6. **Critical Unknown** -- the missing fact keeping the top explanations apart
+7. **Discriminating Probe** -- the highest-value next step to collapse uncertainty
+
+Do **not** collapse into:
+- a generic fix-it coding loop
+- a generic debugger summary
+- a raw dump of worker output
+- fake certainty when evidence is incomplete
+
+## Evidence strength hierarchy
+
+Treat evidence as ranked, not flat.
+
+From strongest to weakest:
+
+1. **Controlled reproductions / direct experiments / uniquely discriminating artifacts**
+2. **Primary source artifacts with tight provenance** (trace events, logs, metrics, benchmark outputs, configs, git history, file:line behavior)
+3. **Multiple independent sources converging on the same explanation**
+4. **Single-source code-path or behavioral inference**
+5. **Weak circumstantial clues** (timing, naming, stack order, resemblance to prior bugs)
+6. **Intuition / analogy / speculation**
+
+Explicitly down-rank hypotheses that depend mostly on lower tiers when stronger contradictory evidence exists.
+
+## Strong falsification / disconfirmation rules
+
+Every serious `/trace` run must try to falsify its own favorite explanation.
+
+For each top hypothesis:
+
+- collect evidence **for** it
+- collect evidence **against** it
+- state what distinctive prediction it makes
+- state what observation would be hard to reconcile with it
+- identify the cheapest probe that would discriminate it from the next-best alternative
+
+Down-rank a hypothesis when:
+
+- direct evidence contradicts it
+- it survives only by adding new unverified assumptions
+- it makes no distinctive prediction compared with rivals
+- a stronger alternative explains the same facts with fewer assumptions
+- its support is mostly circumstantial while the rival has stronger evidence tiers
+
+## Team-mode orchestration shape
+
+Use **Claude built-in team mode** for `/trace`.
+
+The lead should:
+
+1. Restate the observed result or “why” question precisely
+2. Extract the tracing target
+3. Generate multiple deliberately different candidate hypotheses
+4. Spawn **3 tracer lanes by default** in team mode
+5. Assign one tracer worker per lane
+6. Instruct each tracer worker to gather evidence **for** and **against** its lane
+7. Run a **rebuttal round** between the leading hypothesis and the strongest remaining alternative
+8. Detect whether the top lanes genuinely differ or actually converge on the same root cause
+9. Merge findings into a ranked synthesis with an explicit critical unknown and discriminating probe
+
+Important: workers should pursue deliberately different explanations, not the same explanation in parallel.
+
+## Default hypothesis lanes for v1
+
+Unless the prompt strongly suggests a better partition, use these 3 default lanes:
+
+1. **Code-path / implementation cause**
+2. **Config / environment / orchestration cause**
+3. **Measurement / artifact / assumption mismatch cause**
+
+These defaults are intentionally broad so the first slice works across bug, performance, architecture, and experiment tracing.
+
+## Mandatory cross-check lenses
+
+After the initial evidence pass, pressure-test the leaders with these lenses when relevant:
+
+- **Systems lens** -- queues, retries, backpressure, feedback loops, upstream/downstream dependencies, boundary failures, coordination effects
+- **Premortem lens** -- assume the current best explanation is incomplete or wrong; what failure mode would embarrass the trace later?
+- **Science lens** -- controls, confounders, measurement bias, alternative variables, falsifiable predictions
+
+These lenses are not filler. Use them when they can surface a missed explanation, hidden dependency, or weak inference.
+
+## Worker contract
+
+Each worker should be a **`tracer`** lane owner, not a generic executor.
+
+Each worker must:
+
+- own exactly one hypothesis lane
+- restate its lane hypothesis explicitly
+- gather evidence **for** the lane
+- gather evidence **against** the lane
+- rank the evidence strength behind its case
+- call out missing evidence, failed predictions, and remaining uncertainty
+- name the **critical unknown** for the lane
+- recommend the best lane-specific **discriminating probe**
+- avoid collapsing into implementation unless explicitly told to do so
+
+Useful evidence sources include:
+
+- relevant code, tests, configs, docs, logs, outputs, and benchmark artifacts
+- existing trace artifacts via `trace_timeline`
+- existing aggregate trace evidence via `trace_summary`
+
+Recommended worker return structure:
+
+1. **Lane**
+2. **Hypothesis**
+3. **Evidence For**
+4. **Evidence Against / Gaps**
+5. **Evidence Strength**
+6. **Critical Unknown**
+7. **Best Discriminating Probe**
+8. **Confidence**
+
+## Leader synthesis contract
+
+The final `/trace` answer should synthesize, not just concatenate.
+
+Return:
+
+1. **Observed Result**
+2. **Ranked Hypotheses**
+3. **Evidence Summary by Hypothesis**
+4. **Evidence Against / Missing Evidence**
+5. **Rebuttal Round**
+6. **Convergence / Separation Notes**
+7. **Most Likely Explanation**
+8. **Critical Unknown**
+9. **Recommended Discriminating Probe**
+10. **Additional Trace Lanes** (optional, only if uncertainty remains high)
+
+Preserve a ranked shortlist even if one explanation is currently dominant.
+
+## Rebuttal round and convergence detection
+
+Before closing the trace:
+
+- let the strongest non-leading lane present its best rebuttal to the current leader
+- force the leader to answer the rebuttal with evidence, not assertion
+- if the rebuttal materially weakens the leader, re-rank the table
+- if two “different” hypotheses reduce to the same underlying mechanism, merge them and say so explicitly
+- if two hypotheses still imply different next probes, keep them separate even if they sound similar
+
+Do not claim convergence just because multiple workers use similar language. Convergence requires either:
+
+- the same root causal mechanism, or
+- independent evidence streams pointing to the same explanation
+
+## Explicit down-ranking guidance
+
+The lead should explicitly say why a hypothesis moved down:
+
+- contradicted by stronger evidence
+- lacks the observation it predicted
+- requires extra ad hoc assumptions
+- explains fewer facts than the leader
+- lost the rebuttal round
+- converged into a stronger parent explanation
+
+This is important because `/trace` should teach the reader **why** one explanation outranks another, not just present a final table.
+
+## Suggested lead prompt skeleton
+
+Use a team-oriented orchestration prompt along these lines:
+
+1. “Restate the observation exactly.”
+2. “Generate 3 deliberately different hypotheses.”
+3. “Create one tracer lane per hypothesis using Claude built-in team mode.”
+4. “For each lane, gather evidence for and against, rank evidence strength, and name the critical unknown plus best discriminating probe.”
+5. “Apply systems, premortem, and science lenses to the leaders if useful.”
+6. “Run a rebuttal round between the top two explanations.”
+7. “Return a ranked explanation table, convergence notes, the critical unknown, and the single best discriminating probe.”
+
+## Output quality bar
+
+Good `/trace` output is:
+
+- evidence-backed
+- concise but rigorous
+- skeptical of premature certainty
+- explicit about missing evidence
+- practical about the next action
+- explicit about why weaker explanations were down-ranked
+
+## Example final synthesis shape
+
+### Observed Result
+[What happened]
+
+### Ranked Hypotheses
+| Rank | Hypothesis | Confidence | Evidence Strength | Why it leads |
+|------|------------|------------|-------------------|--------------|
+| 1 | ... | High / Medium / Low | Strong / Moderate / Weak | ... |
+
+### Evidence Summary by Hypothesis
+- Hypothesis 1: ...
+- Hypothesis 2: ...
+- Hypothesis 3: ...
+
+### Evidence Against / Missing Evidence
+- Hypothesis 1: ...
+- Hypothesis 2: ...
+- Hypothesis 3: ...
+
+### Rebuttal Round
+- Best rebuttal to leader: ...
+- Why leader held / failed: ...
+
+### Convergence / Separation Notes
+- ...
+
+### Most Likely Explanation
+[Current best explanation]
+
+### Critical Unknown
+[Single missing fact keeping uncertainty open]
+
+### Recommended Discriminating Probe
+[Single next probe]
+
+### Additional Trace Lanes
+[Only if uncertainty remains high]

package/skills/ultraqa/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: ultraqa
 description: QA cycling workflow - test, verify, fix, repeat until goal met
+level: 3
 ---
 
 # UltraQA Skill

package/skills/ultrawork/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: ultrawork
 description: Parallel execution engine for high-throughput task completion
+level: 4
 ---
 
 <Purpose>

package/skills/visual-verdict/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: visual-verdict
+description: Structured visual QA verdict for screenshot-to-reference comparisons
+level: 2
+---
+
+<Purpose>
+Use this skill to compare generated UI screenshots against one or more reference images and return a strict JSON verdict that can drive the next edit iteration.
+</Purpose>
+
+<Use_When>
+- The task includes visual fidelity requirements (layout, spacing, typography, component styling)
+- You have a generated screenshot and at least one reference image
+- You need deterministic pass/fail guidance before continuing edits
+</Use_When>
+
+<Inputs>
+- `reference_images[]` (one or more image paths)
+- `generated_screenshot` (current output image)
+- Optional: `category_hint` (e.g., `hackernews`, `sns-feed`, `dashboard`)
+</Inputs>
+
+<Output_Contract>
+Return **JSON only** with this exact shape:
+
+```json
+{
+  "score": 0,
+  "verdict": "revise",
+  "category_match": false,
+  "differences": ["..."],
+  "suggestions": ["..."],
+  "reasoning": "short explanation"
+}
+```
+
+Rules:
+- `score`: integer 0-100
+- `verdict`: short status (`pass`, `revise`, or `fail`)
+- `category_match`: `true` when the generated screenshot matches the intended UI category/style
+- `differences[]`: concrete visual mismatches (layout, spacing, typography, colors, hierarchy)
+- `suggestions[]`: actionable next edits tied to the differences
+- `reasoning`: 1-2 sentence summary
+
+<Threshold_And_Loop>
+- Target pass threshold is **90+**.
+- If `score < 90`, continue editing and rerun `/oh-my-claudecode:visual-verdict` before any further visual review pass.
+- Do **not** treat the visual task as complete until the next screenshot clears the threshold.
+</Threshold_And_Loop>
+
+<Debug_Visualization>
+When mismatch diagnosis is hard:
+1. Keep `$visual-verdict` as the authoritative decision.
+2. Use pixel-level diff tooling (pixel diff / pixelmatch overlay) as a **secondary debug aid** to localize hotspots.
+3. Convert pixel diff hotspots into concrete `differences[]` and `suggestions[]` updates.
+</Debug_Visualization>
+
+<Example>
+```json
+{
+  "score": 87,
+  "verdict": "revise",
+  "category_match": true,
+  "differences": [
+    "Top nav spacing is tighter than reference",
+    "Primary button uses smaller font weight"
+  ],
+  "suggestions": [
+    "Increase nav item horizontal padding by 4px",
+    "Set primary button font-weight to 600"
+  ],
+  "reasoning": "Core layout matches, but style details still diverge."
+}
+```
+</Example>
+
+Task: {{ARGUMENTS}}

package/skills/writer-memory/SKILL.md

@@ -2,6 +2,7 @@
 name: writer-memory
 description: Agentic memory system for writers - track characters, relationships, scenes, and themes
 argument-hint: "init|char|rel|scene|query|validate|synopsis|status|export [args]"
+level: 7
 ---
 
 # Writer Memory - Agentic Memory System for Writers

package/templates/hooks/keyword-detector.mjs

@@ -85,6 +85,17 @@ Perform a focused security review of the relevant changes or target area. Check
 ---
 `;
 
+const SEARCH_MESSAGE = `<search-mode>
+MAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:
+- explore agents (codebase patterns, file structures)
+- document-specialist agents (remote repos, official docs, GitHub examples)
+Plus direct tools: Grep, Glob
+NEVER stop at first result - be exhaustive.
+</search-mode>
+
+---
+`;
+
 // Extract prompt from various JSON structures
 function extractPrompt(input) {
   try {
@@ -131,16 +142,68 @@ function sanitizeForKeywordDetection(text) {
     .replace(/`[^`]+`/g, '');
 }
 
+const INFORMATIONAL_INTENT_PATTERNS = [
+  /\b(?:what(?:'s|\s+is)|what\s+are|how\s+(?:to|do\s+i)\s+use|explain|explanation|tell\s+me\s+about|describe)\b/i,
+  /(?:뭐야|뭔데|무엇(?:이야|인가요)?|어떻게|설명|사용법|알려\s?줘|알려줄래|소개해?\s?줘|소개\s*부탁|설명해\s?줘|뭐가\s*달라|어떤\s*기능|기능\s*(?:알려|설명|뭐)|방법\s*(?:알려|설명|뭐))/u,
+  /(?:とは|って何|使い方|説明)/u,
+  /(?:什么是|什麼是|怎(?:么|樣)用|如何使用|解释|說明|说明)/u,
+];
+const INFORMATIONAL_CONTEXT_WINDOW = 80;
+
+function isInformationalKeywordContext(text, position, keywordLength) {
+  const start = Math.max(0, position - INFORMATIONAL_CONTEXT_WINDOW);
+  const end = Math.min(text.length, position + keywordLength + INFORMATIONAL_CONTEXT_WINDOW);
+  const context = text.slice(start, end);
+  return INFORMATIONAL_INTENT_PATTERNS.some((pattern) => pattern.test(context));
+}
+
+function hasActionableKeyword(text, pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  const globalPattern = new RegExp(pattern.source, flags);
+
+  for (const match of text.matchAll(globalPattern)) {
+    if (match.index === undefined) {
+      continue;
+    }
+
+    if (isInformationalKeywordContext(text, match.index, match[0].length)) {
+      continue;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 // Create state file for a mode
 function activateState(directory, prompt, stateName, sessionId) {
-  const state = {
-    active: true,
-    started_at: new Date().toISOString(),
-    original_prompt: prompt,
-    session_id: sessionId || undefined,
-    reinforcement_count: 0,
-    last_checked_at: new Date().toISOString()
-  };
+  let state;
+
+  if (stateName === 'ralph') {
+    // Ralph needs 'prompt' field (not 'original_prompt') — persistent-mode.mjs reads ralph.state.prompt
+    state = {
+      active: true,
+      iteration: 1,
+      max_iterations: 100,
+      started_at: new Date().toISOString(),
+      prompt: prompt,
+      session_id: sessionId || undefined,
+      reinforcement_count: 0,
+      awaiting_confirmation: true,
+      last_checked_at: new Date().toISOString()
+    };
+  } else {
+    state = {
+      active: true,
+      started_at: new Date().toISOString(),
+      original_prompt: prompt,
+      session_id: sessionId || undefined,
+      reinforcement_count: 0,
+      awaiting_confirmation: true,
+      last_checked_at: new Date().toISOString()
+    };
+  }
 
   // Write to local .omc/state directory
   const localDir = join(directory, '.omc', 'state');
@@ -360,17 +423,17 @@ async function main() {
     const matches = [];
 
     // Cancel keywords
-    if (/\b(cancelomc|stopomc)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(cancelomc|stopomc)\b/i)) {
       matches.push({ name: 'cancel', args: '' });
     }
 
     // Ralph keywords
-    if (/\b(ralph)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ralph)\b|(랄프)/i)) {
       matches.push({ name: 'ralph', args: '' });
     }
 
     // Autopilot keywords
-    if (/\b(autopilot|auto[\s-]?pilot|fullsend|full\s+auto)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(autopilot|auto[\s-]?pilot|fullsend|full\s+auto)\b|(오토파일럿)/i)) {
       matches.push({ name: 'autopilot', args: '' });
     }
 
@@ -378,23 +441,23 @@ async function main() {
     // This prevents infinite spawning when Claude workers receive prompts containing "team".
 
     // Ultrawork keywords
-    if (/\b(ultrawork|ulw)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ultrawork|ulw)\b|(울트라워크)/i)) {
       matches.push({ name: 'ultrawork', args: '' });
     }
 
 
     // CCG keywords (Claude-Codex-Gemini tri-model orchestration)
-    if (/\b(ccg|claude-codex-gemini)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ccg|claude-codex-gemini)\b|(씨씨지)/i)) {
       matches.push({ name: 'ccg', args: '' });
     }
 
     // Ralplan keyword
-    if (/\b(ralplan)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ralplan)\b|(랄플랜)/i)) {
       matches.push({ name: 'ralplan', args: '' });
     }
 
     // Deep interview keywords
-    if (/\b(deep[\s-]interview|ouroboros)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(deep[\s-]interview|ouroboros)\b|(딥인터뷰)/i)) {
       matches.push({ name: 'deep-interview', args: '' });
     }
 
@@ -404,36 +467,36 @@ async function main() {
     }
 
     // TDD keywords
-    if (/\b(tdd)\b/i.test(cleanPrompt) ||
-        /\btest\s+first\b/i.test(cleanPrompt) ||
-        /\bred\s+green\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(tdd)\b|(테스트\s?퍼스트)/i) ||
+        hasActionableKeyword(cleanPrompt, /\btest\s+first\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\bred\s+green\b/i)) {
       matches.push({ name: 'tdd', args: '' });
     }
 
     // Code review keywords
-    if (/\b(code\s+review|review\s+code)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(code\s+review|review\s+code)\b|(코드\s?리뷰)(?!어)/i)) {
       matches.push({ name: 'code-review', args: '' });
     }
 
     // Security review keywords
-    if (/\b(security\s+review|review\s+security)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(security\s+review|review\s+security)\b|(보안\s?리뷰)(?!어)/i)) {
       matches.push({ name: 'security-review', args: '' });
     }
 
     // Ultrathink keywords
-    if (/\b(ultrathink)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ultrathink)\b|(울트라씽크)/i)) {
       matches.push({ name: 'ultrathink', args: '' });
     }
 
     // Deepsearch keywords
-    if (/\b(deepsearch)\b/i.test(cleanPrompt) ||
-        /\bsearch\s+the\s+codebase\b/i.test(cleanPrompt) ||
-        /\bfind\s+in\s+(the\s+)?codebase\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(deepsearch)\b|(딥\s?서치)/i) ||
+        hasActionableKeyword(cleanPrompt, /\bsearch\s+the\s+codebase\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\bfind\s+in\s+(the\s+)?codebase\b/i)) {
       matches.push({ name: 'deepsearch', args: '' });
     }
 
     // Analyze keywords
-    if (/\b(deep[\s-]?analyze|deepanalyze)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(deep[\s-]?analyze|deepanalyze)\b|(딥\s?분석)/i)) {
       matches.push({ name: 'analyze', args: '' });
     }
 
@@ -480,6 +543,7 @@ async function main() {
     const additionalContextParts = [];
     for (const [keywordName, message] of [
       ['ultrathink', ULTRATHINK_MESSAGE],
+      ['deepsearch', SEARCH_MESSAGE],
       ['analyze', ANALYZE_MESSAGE],
       ['tdd', TDD_MESSAGE],
       ['code-review', CODE_REVIEW_MESSAGE],

package/templates/hooks/persistent-mode.mjs

@@ -12,6 +12,7 @@ import {
   existsSync,
   readFileSync,
   writeFileSync,
+  renameSync,
   readdirSync,
   mkdirSync,
   unlinkSync,
@@ -39,16 +40,15 @@ function readJsonFile(path) {
 
 function writeJsonFile(path, data) {
   try {
-    // Ensure directory exists
     const dir = dirname(path);
     if (dir && dir !== "." && !existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
     }
-    writeFileSync(path, JSON.stringify(data, null, 2));
+    const tmpPath = path + '.tmp.' + process.pid;
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    renameSync(tmpPath, path);
     return true;
-  } catch {
-    return false;
-  }
+  } catch { return false; }
 }
 
 /**
@@ -193,6 +193,10 @@ function getSafeReinforcementCount(value) {
     : 0;
 }
 
+function isAwaitingConfirmation(state) {
+  return state?.awaiting_confirmation === true;
+}
+
 /**
  * Check if a skill active state is stale based on its per-skill TTL.
  * Unlike mode states (which use the global 2-hour threshold), skill states
@@ -349,6 +353,18 @@ function readStateFileWithSession(stateDir, globalStateDir, filename, sessionId)
   return readStateFile(stateDir, globalStateDir, filename);
 }
 
+function getActiveSubagentCount(stateDir) {
+  try {
+    const tracking = readJsonFile(join(stateDir, "subagent-tracking.json"));
+    if (!tracking || !Array.isArray(tracking.agents)) {
+      return 0;
+    }
+    return tracking.agents.filter((agent) => agent?.status === "running").length;
+  } catch {
+    return 0;
+  }
+}
+
 /**
  * Count incomplete Tasks from Claude Code's native Task system.
  */
@@ -628,7 +644,7 @@ async function main() {
     // Priority 1: Ralph Loop (explicit persistence mode)
     // Skip if state is stale (older than 2 hours) - prevents blocking new sessions
     if (
-      ralph.state?.active &&
+      ralph.state?.active && !isAwaitingConfirmation(ralph.state) &&
       !isStaleState(ralph.state) &&
       isStateForCurrentProject(ralph.state, directory, ralph.isGlobal)
     ) {
@@ -681,7 +697,7 @@ async function main() {
 
     // Priority 2: Autopilot (high-level orchestration)
     if (
-      autopilot.state?.active &&
+      autopilot.state?.active && !isAwaitingConfirmation(autopilot.state) &&
       !isStaleState(autopilot.state) &&
       isStateForCurrentProject(autopilot.state, directory, autopilot.isGlobal)
     ) {
@@ -700,7 +716,10 @@ async function main() {
             autopilot.state.last_checked_at = new Date().toISOString();
             writeJsonFile(autopilot.path, autopilot.state);
 
-            let reason = `[AUTOPILOT - Phase: ${phase}] Autopilot not complete. Continue working. When all phases are complete, run /oh-my-claudecode:cancel to cleanly exit and clean up state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.`;
+            const cancelGuidance = hasValidSessionId && autopilot.state.session_id === sessionId
+              ? " When all phases are complete, run /oh-my-claudecode:cancel to cleanly exit and clean up this session's autopilot state files. If cancel fails, retry with /oh-my-claudecode:cancel --force."
+              : "";
+            let reason = `[AUTOPILOT - Phase: ${phase}] Autopilot not complete. Continue working.${cancelGuidance}`;
             if (errorGuidance) {
               reason = errorGuidance + reason;
             }
@@ -912,7 +931,7 @@ async function main() {
     // Session isolation: only block if state belongs to this session (issue #311)
     // If state has session_id, it must match. If no session_id (legacy), allow.
     if (
-      ultrawork.state?.active &&
+      ultrawork.state?.active && !isAwaitingConfirmation(ultrawork.state) &&
       !isStaleState(ultrawork.state) &&
       (hasValidSessionId
         ? ultrawork.state.session_id === sessionId
@@ -981,6 +1000,11 @@ async function main() {
         const maxReinforcements = skillState.state.max_reinforcements || 3;
 
         if (count < maxReinforcements) {
+          if (getActiveSubagentCount(stateDir) > 0) {
+            console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+            return;
+          }
+
           const toolError = readLastToolError(stateDir);
           const errorGuidance = getToolErrorRetryGuidance(toolError);
 

package/templates/hooks/post-tool-use-failure.mjs

@@ -28,11 +28,8 @@ function isPathContained(targetPath, basePath) {
 
 // Initialize .omc directory if needed
 function initOmcDir(directory) {
-  const cwd = process.cwd();
-  // Validate directory is contained within cwd
-  if (!isPathContained(directory, cwd)) {
-    // Fallback to cwd if directory attempts traversal
-    directory = cwd;
+  if (!directory || typeof directory !== 'string') {
+    directory = process.cwd();
   }
   const omcDir = join(directory, '.omc');
   const stateDir = join(omcDir, 'state');