@angar2/taskery 1.0.3 → 1.1.0

package/bin/hosts/orca.js

@@ -0,0 +1,199 @@
+// Orca 호스트 — Orca(작업 폴더마다 AI 탭을 여는 터미널 앱)의 방식. 계약은 hosts/index.js
+// 워크트리는 taskery가 만든다. Orca 목록에는 저장소 설정 '밖에서 만든 워크트리 보이기'를 켜고 부모 브랜치의 하위로 붙인다
+const { execFileSync } = require('child_process');
+const L = require('../lib');
+
+// 첫 지시문을 보낸 뒤 턴 시작을 지켜보는 시간(orca terminal send --wait-submit)
+const SUBMIT_WAIT_SEC = 30;
+// 턴 시작 미관측 뒤 Enter를 보내고 화면을 읽기 전 기다리는 시간
+const SCREEN_SETTLE_MS = 2000;
+
+// orca 명령을 --json으로 부르고 result를 돌려준다. 종료 코드가 0이 아니어도 JSON이 ok면 돌려준다(terminal wait 미충족)
+function orca(args) {
+  let out = '';
+  let err = '';
+  try {
+    out = execFileSync('orca', [...args, '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  } catch (e) {
+    out = (e.stdout || '').toString();
+    err = ((e.stderr || '').toString().trim() || e.message).split('\n')[0];
+  }
+  let j = null;
+  try {
+    j = JSON.parse(out);
+  } catch (e) {
+    j = null;
+  }
+  if (j && j.ok) return j.result;
+  const why = (j && j.error && (j.error.message || j.error.code)) || err || out.trim() || '알 수 없는 오류';
+  throw new L.TaskeryError(`orca ${args.slice(0, 2).join(' ')} 실패: ${why}`);
+}
+
+// orca() 오류 문구에서 명령 머리를 떼고 이유만
+function reason(e) {
+  return e.message.replace(/^orca \S+ \S+ 실패: /, '');
+}
+
+// 부모 브랜치가 열려 있는 폴더 — 없으면 본진. Orca의 branch: 선택자는 등록된 모든 저장소에서 찾아 같은 이름(dev)이 겹치면 고르지 못한다(실측)
+function parentPath(main, parent) {
+  let at = null;
+  for (const line of L.git(main, ['worktree', 'list', '--porcelain']).split('\n')) {
+    if (line.startsWith('worktree ')) at = line.slice('worktree '.length);
+    else if (line === `branch refs/heads/${parent}`) return at;
+  }
+  return main;
+}
+
+// taskery가 만든 워크트리를 Orca 목록에 부모 브랜치의 하위로 붙인다. Orca는 밖에서 만든 워크트리를 저장소 설정이 켜져 있어야 보여 준다.
+// 붙이지 못해도 탭은 열 수 있어 멈추지 않고 알린다
+function attach(main, { worktree, parent }) {
+  const notes = [];
+  try {
+    const r = orca(['repo', 'show', '--repo', `path:${main}`]);
+    if ((r && r.repo && r.repo.externalWorktreeVisibility) !== 'show') {
+      orca(['repo', 'set', '--repo', `path:${main}`, '--external-worktree-visibility', 'show']);
+      notes.push("Orca 저장소 설정 '밖에서 만든 워크트리 보이기'를 켰다");
+    }
+    orca(['worktree', 'set', '--worktree', `path:${worktree}`, '--parent-worktree', `path:${parentPath(main, parent)}`]);
+  } catch (e) {
+    notes.push(`Orca 목록에 워크트리를 붙이지 못했다(${reason(e)})`);
+  }
+  return notes;
+}
+
+// 탭이 입력을 받을 준비(tui-idle)가 됐나
+function waitIdle(id) {
+  const r = orca(['terminal', 'wait', '--terminal', id, '--for', 'tui-idle']);
+  if (r && r.wait && r.wait.satisfied === false) return `준비(tui-idle)가 되지 않았다 — ${r.wait.reason || r.wait.status || '준비 대기 미충족'}`;
+  return null;
+}
+
+function open({ dir, label, command }) {
+  const created = orca(['terminal', 'create', '--worktree', `path:${dir}`, '--title', label, '--command', command]);
+  const id = created && created.terminal && created.terminal.handle;
+  if (!id) L.fail("Orca가 탭 handle을 돌려주지 않았다. 'orca terminal list'로 확인한다.");
+  // 탭은 열렸으므로 준비를 기다리지 못해도 던지지 않는다 — 기록해 두고 다시 부를 때 이어 간다
+  try {
+    return { id, blocked: waitIdle(id) };
+  } catch (e) {
+    return { id, blocked: `준비를 기다리지 못했다(${reason(e)})` };
+  }
+}
+
+// 닫힌 탭도 한동안 terminal show에 남는다 — orphaned(연결 끊김)면 없는 것으로 본다(실측)
+function closed(r) {
+  return !r || !r.terminal || r.terminal.orphaned === true;
+}
+
+function alive(id) {
+  try {
+    return !closed(orca(['terminal', 'show', '--terminal', id]));
+  } catch (e) {
+    return false;
+  }
+}
+
+function ready(id) {
+  try {
+    const why = waitIdle(id);
+    return why ? { ok: false, why } : { ok: true };
+  } catch (e) {
+    return { ok: false, why: `준비를 확인하지 못했다(${reason(e)})` };
+  }
+}
+
+function read(id) {
+  const r = orca(['terminal', 'read', '--terminal', id, '--screen']);
+  return ((r && r.terminal && r.terminal.tail) || []).join('\n');
+}
+
+// 지시문을 보내고 턴 시작이 관측됐는지 돌려준다. 받지 않았으면 던진다. 관측할 수 없는 곳(영수증 없음·provider가 보고 못 함)은 보낸 것으로 본다
+function sendPrompt(id, text) {
+  let r;
+  try {
+    r = orca(['terminal', 'send', '--terminal', id, '--text', text, '--enter', '--wait-submit', String(SUBMIT_WAIT_SEC)]);
+  } catch (e) {
+    L.fail(`첫 지시문을 보내지 못했다(${reason(e)})`);
+  }
+  const send = (r && r.send) || {};
+  if (send.accepted === false) L.fail(`탭이 첫 지시문을 받지 않았다(${send.refusedReason || '거부'})`);
+  const p = send.prompt;
+  return !p || (p.stages || []).includes('turn_started') || ['unsupported', 'old-host'].includes(p.provider);
+}
+
+// 탭 화면에 첫 지시문 첫머리가 보이나 — 보이면 들어간 것이라 다시 보내지 않는다
+function onScreen(id, text) {
+  const marker = text.split('\n')[0].split(' ').slice(0, 4).join(' ').replace(/\s+/g, '');
+  try {
+    return read(id).replace(/\s+/g, '').includes(marker);
+  } catch (e) {
+    return false;
+  }
+}
+
+function sendFirst(id, text) {
+  // Orca가 턴 시작을 관측했다고 답해도 지시문이 입력창에 제출되지 않은 채 남은 적이 있다(stash TASK-105).
+  // 그래서 관측 여부와 무관하게 Enter만 한 번 더 보낸다 — 입력창이 비었거나 이미 진행 중이면 영향이 없다
+  const observed = sendPrompt(id, text);
+  let note = null;
+  try {
+    orca(['terminal', 'send', '--terminal', id, '--enter']);
+  } catch (e) {
+    if (observed) note = `확인용 Enter를 보내지 못했다(${reason(e)}) — 탭에서 진행을 확인한다.`;
+    else L.fail(`턴 시작이 관측되지 않았고 확인용 Enter도 보내지 못했다(${reason(e)})`);
+  }
+  if (observed) return { note };
+  // 관측되지 않았으면 화면을 본다 — 지시문이 보이면 Enter로 들어간 것이고, 없으면 준비 전에 사라진 것이라 한 번 더 보낸다
+  L.sleepSync(SCREEN_SETTLE_MS);
+  if (onScreen(id, text)) return { note: '턴 시작이 관측되지 않아 Enter를 한 번 더 보냈고, 탭 화면에 첫 지시문이 보인다 — 탭에서 진행을 확인한다.' };
+  if (sendPrompt(id, text)) return { note: '첫 전송은 턴 시작이 관측되지 않고 Enter 뒤 화면에도 없어 한 번 더 보냈다.' };
+  L.fail('두 번 보냈지만 턴 시작이 관측되지 않았다');
+}
+
+function send(id, text) {
+  let r;
+  try {
+    r = orca(['terminal', 'send', '--terminal', id, '--text', text, '--enter']);
+  } catch (e) {
+    L.fail(`보내지 못했다(${reason(e)})`);
+  }
+  const s = (r && r.send) || {};
+  if (s.accepted === false) L.fail(`탭이 받지 않았다(${s.refusedReason || '거부'})`);
+}
+
+// 탭을 닫는다 — 이미 없으면 false
+function close(id) {
+  if (!alive(id)) return false;
+  orca(['terminal', 'close', '--terminal', id]);
+  return true;
+}
+
+// 마지막 출력이 quietMs 넘게 지났으면 그 시간
+function check(id, quietMs) {
+  let r;
+  try {
+    r = orca(['terminal', 'show', '--terminal', id]);
+  } catch (e) {
+    L.fail(reason(e));
+  }
+  if (closed(r)) return '탭이 닫혔다';
+  const last = r.terminal.lastOutputAt;
+  return last && Date.now() - last >= quietMs ? `마지막 출력 ${L.minutes(Date.now() - last)} 전` : null;
+}
+
+module.exports = {
+  name: 'orca',
+  label: 'Orca',
+  envKeys: ['ORCA_TERMINAL_HANDLE'],
+  detect: (env) => !!env.ORCA_TERMINAL_HANDLE,
+  legacyTab: true,
+  open,
+  alive,
+  ready,
+  sendFirst,
+  send,
+  read,
+  check,
+  attach,
+  close,
+};

package/bin/lib.js

@@ -118,9 +118,9 @@ function ensureExclude(main, extra = []) {
   return missing;
 }
 
-// Orca 탭 안인가 — Orca가 탭에 넣는 환경 변수로 판단한다
-function inOrca() {
-  return !!process.env.ORCA_TERMINAL_HANDLE;
+// 동기 대기 — 동기 함수로 된 터미널 앱 명령 사이에서 쓴다
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
 // ─── 셸 명령 실행 (코드 테스트) ───────────────────────
@@ -688,7 +688,7 @@ module.exports = {
   branchExists,
   fingerprint,
   ensureExclude,
-  inOrca,
+  sleepSync,
   runShell,
   tail,
   OLD_MANIFEST_NAME,

package/bin/orche.js

@@ -1,17 +1,14 @@
-// orca-dispatch-task · report-task · wait-reports — 오케스트레이션의 띄우기·보고·보고 받기(§5-3, §5-4)
+// dispatch-task · send-task · read-task · report-task · wait-reports — 오케스트레이션의 띄우기·탭에 말하기·보고·보고 받기(§5-3, §5-4)
+// 탭을 다루는 일은 이 세션이 도는 터미널 앱의 호스트 파일(hosts/)이 한다 — 여기서는 앱 이름을 모른다
 const fs = require('fs');
 const path = require('path');
-const { execFileSync } = require('child_process');
 const L = require('./lib');
+const H = require('./hosts');
 
 const AGENTS = ['claude', 'codex'];
-// 보고 없이 기다리는 시간이자 '오래 조용한 탭'의 기준. 환경 변수는 시험 전용 통로다
+// 보고 없이 기다리는 시간이자 '살펴볼 탭'의 조용한 시간 기준. 환경 변수는 시험 전용 통로다
 const WAIT_MS = Number(process.env.TASKERY_WAIT_REPORTS_MS) || 60 * 60 * 1000;
 const POLL_MS = Math.min(1000, WAIT_MS);
-// 첫 지시문을 보낸 뒤 턴 시작을 지켜보는 시간(orca terminal send --wait-submit)
-const SUBMIT_WAIT_SEC = 30;
-// 턴 시작 미관측 뒤 Enter를 보내고 화면을 읽기 전 기다리는 시간
-const SCREEN_SETTLE_MS = 2000;
 
 function reportsFile(main) {
   return path.join(main, '.taskery', 'reports.log');
@@ -21,36 +18,20 @@ function readPosFile(main) {
   return path.join(L.stateDir(main), 'reports-read.json');
 }
 
-// orca 명령을 --json으로 부르고 result를 돌려준다. 종료 코드가 0이 아니어도 JSON이 ok면 돌려준다(terminal wait 미충족)
-function orca(args) {
-  let out = '';
-  let err = '';
-  try {
-    out = execFileSync('orca', [...args, '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  } catch (e) {
-    out = (e.stdout || '').toString();
-    err = ((e.stderr || '').toString().trim() || e.message).split('\n')[0];
-  }
-  let j = null;
-  try {
-    j = JSON.parse(out);
-  } catch (e) {
-    j = null;
-  }
-  if (j && j.ok) return j.result;
-  const why = (j && j.error && (j.error.message || j.error.code)) || err || out.trim() || '알 수 없는 오류';
-  throw new L.TaskeryError(`orca ${args.slice(0, 2).join(' ')} 실패: ${why}`);
-}
-
-// 셸에 그대로 넘길 수 있게 감싼다(--command는 탭의 셸에 입력된다)
+// 셸에 그대로 넘길 수 있게 감싼다(실행 한 줄은 탭의 셸에 입력된다)
 function shq(v) {
   return /^[A-Za-z0-9_.\/:=@%+-]+$/.test(v) ? v : `'${String(v).replace(/'/g, `'\\''`)}'`;
 }
 
-// 에이전트 실행 명령 — 권한·승인 옵션은 붙이지 않는다(사용자 설정 그대로, I5). 모델이 없으면 모델 옵션을 뺀다
-function agentCommand(main, agent, model) {
-  if (agent === 'claude') return model ? `claude --model ${shq(model)}` : 'claude';
-  return `codex ${model ? `-m ${shq(model)} ` : ''}--add-dir ${shq(path.join(main, '.taskery'))}`;
+// 에이전트 실행 — 권한·승인 옵션은 붙이지 않는다(사용자 설정 그대로, I5). 모델이 없으면 모델 옵션을 뺀다
+function agentLaunch(main, agent, model) {
+  if (agent === 'claude') return { agent, args: model ? ['--model', model] : [] };
+  return { agent, args: [...(model ? ['-m', model] : []), '--add-dir', path.join(main, '.taskery')] };
+}
+
+// 실행 한 줄 — 손 전달 안내와 셸 한 줄로 띄우는 호스트가 쓴다
+function shellLine(launch) {
+  return [launch.agent, ...launch.args].map(shq).join(' ');
 }
 
 // 단계 표에서 비어 있는 첫 단계의 스킬 — 새 태스크면 task-plan
@@ -101,135 +82,171 @@ function firstInstruction(st, brief = {}) {
   return blocks.map((b) => (Array.isArray(b) ? b.join('\n') : b)).join('\n\n');
 }
 
-// 지시문을 보내고 턴 시작이 관측됐는지 돌려준다. 받지 않았으면 refused. 관측할 수 없는 곳(영수증 없음·provider가 보고 못 함)은 보낸 것으로 본다
-function sendPrompt(handle, text) {
-  const r = orca(['terminal', 'send', '--terminal', handle, '--text', text, '--enter', '--wait-submit', String(SUBMIT_WAIT_SEC)]);
-  const send = (r && r.send) || {};
-  if (send.accepted === false) return { refused: send.refusedReason || '거부' };
-  const p = send.prompt;
-  return { observed: !p || (p.stages || []).includes('turn_started') || ['unsupported', 'old-host'].includes(p.provider) };
+// 탭 기록을 .state에 쓴다(null이면 지운다) — 태스크 세션이 쓰는 칸과 겹치지 않게 그때의 .state를 읽어 고친다
+function saveTab(main, num, tab) {
+  const st = L.readState(main, num);
+  if (tab) st.tab = tab;
+  else delete st.tab;
+  L.writeState(main, st);
+  L.syncDoc(main, st);
+  return st;
 }
 
-// 탭 화면에 첫 지시문 첫머리가 보이나 — 보이면 들어간 것이라 다시 보내지 않는다
-function onScreen(handle, marker) {
-  try {
-    const r = orca(['terminal', 'read', '--terminal', handle, '--screen']);
-    const screen = ((r && r.terminal && r.terminal.tail) || []).join('').replace(/\s+/g, '');
-    return screen.includes(marker.replace(/\s+/g, ''));
-  } catch (e) {
-    return false;
-  }
+// 기록된 탭의 호스트 — 이 taskery가 모르는 이름이면 멈춘다
+function hostOf(cmd, label, tab) {
+  const host = H.byName(tab.host);
+  if (!host) L.fail(`${cmd}: ${label} 탭을 띄운 터미널 앱 '${tab.host}'을 이 taskery가 모른다.`);
+  return host;
 }
 
 // 손 전달(--manual) — 탭을 띄우지 않고 사용자에게 전할 작업 폴더·실행 안내·첫 지시문을 돌려준다
 function manualDispatch(main, st, a, brief) {
-  const prevTab = st.tab;
-  // 남은 탭 기록을 지운다 — 남겨 두면 wait-reports가 그 handle을 계속 확인한다
-  if (prevTab) {
-    delete st.tab;
-    L.writeState(main, st);
-    L.syncDoc(main, st);
-  }
-  const run = a.agent ? agentCommand(main, a.agent, a.model && String(a.model)) : `Claude Code는 claude, Codex는 ${agentCommand(main, 'codex')}`;
+  const prevTab = H.tabOf(st);
+  // 남은 탭 기록을 지운다 — 남겨 두면 wait-reports가 그 탭을 계속 확인한다
+  if (prevTab) saveTab(main, st.num, null);
+  const run = a.agent
+    ? shellLine(agentLaunch(main, a.agent, a.model && String(a.model)))
+    : `Claude Code는 claude, Codex는 ${shellLine(agentLaunch(main, 'codex'))}`;
   return [
     '손 전달 — 탭을 띄우지 않았다. 사용자에게 아래를 전하고, 사용자가 작업 폴더에서 에이전트 세션을 열어 첫 지시문을 그대로 붙여 넣게 한다.',
     `- 작업 폴더: ${L.workDir(main, st)}`,
     `- 실행: ${run}`,
-    ...(prevTab ? [`- 앞서 연 탭 ${prevTab}은 기록에서 지웠다. 그 탭에서 세션이 이미 일을 시작하지 않았는지 확인하고 닫는다.`] : []),
+    ...(prevTab ? [`- 앞서 연 탭 ${prevTab.id}은 기록에서 지웠다. 그 탭에서 세션이 이미 일을 시작하지 않았는지 확인하고 닫는다.`] : []),
     '--- 첫 지시문 ---',
     firstInstruction(st, brief),
   ].join('\n');
 }
 
-async function orcaDispatchTask(ctx, a) {
+// 멈춤 ② — 탭은 열렸지만 에이전트가 첫 지시를 받을 준비가 안 됐다
+function notReady(label, id, why) {
+  return [
+    `dispatch-task: ${label} 탭 ${id}을 열었지만 ${why}. 첫 지시문은 아직 보내지 않았다.`,
+    `- read-task ${label}로 화면을 읽고, 사용자에게 그 탭에서 확인해 달라고 부탁한다.`,
+    `- 사용자가 확인하면 dispatch-task ${label}를 같은 칸 인자(--scope·--avoid·--read·--extra)로 다시 부른다 — 열린 탭에 첫 지시만 보낸다.`,
+  ].join('\n');
+}
+
+// 띄우기(§7-2) — 탭 기록이 있으면 그 탭으로 이어 가고, 없으면 지금 호스트에 새 탭을 연다
+async function dispatchTask(ctx, a) {
   const main = ctx.main;
   L.requireInstalled(main);
-  if (!a.task) L.fail('orca-dispatch-task: 빠진 입력이 있다.\n- <task> — 태스크 번호 (첫 번째 인자)');
+  if (!a.task) L.fail('dispatch-task: 빠진 입력이 있다.\n- <task> — 태스크 번호 (첫 번째 인자)');
   const num = L.parseTaskNum(a.task);
   const st = L.readState(main, num);
   const label = L.taskLabel(num);
   if (st.closed) L.fail(`${label}은 이미 닫혔다.`);
   const dir = L.workDir(main, st);
-  if (!fs.existsSync(dir)) L.fail(`orca-dispatch-task: ${label}의 워크트리가 없다(${dir}). 'status'로 확인한다.`);
-  if (a.agent && !AGENTS.includes(a.agent)) L.fail(`orca-dispatch-task: --agent '${a.agent}'을 모른다. ${AGENTS.join(' · ')} 중 하나를 넣는다.`);
+  if (!fs.existsSync(dir)) L.fail(`dispatch-task: ${label}의 워크트리가 없다(${dir}). 'status'로 확인한다.`);
+  if (a.agent && !AGENTS.includes(a.agent)) L.fail(`dispatch-task: --agent '${a.agent}'을 모른다. ${AGENTS.join(' · ')} 중 하나를 넣는다.`);
   const brief = { scope: a.scope, avoid: a.avoid, read: a.read, extra: a.extra };
   if (a.manual) return manualDispatch(main, st, a, brief);
-  if (!L.inOrca()) {
-    L.fail(
-      'orca-dispatch-task: Orca 탭 안이 아니라 태스크 세션을 띄울 수 없다(Orca 환경 변수 ORCA_TERMINAL_HANDLE이 없다). ' +
-        'Orca 탭 안에서 불렀다면 MCP 도구가 아니라 CLI(npx @angar2/taskery orca-dispatch-task …)로 다시 부른다. ' +
-        'Orca를 쓸 수 없으면 --manual로 다시 불러 사용자에게 손 전달한다.',
-    );
-  }
-  const missing = [];
-  if (!a.agent) missing.push(`--agent — ${AGENTS.join(' · ')}`);
-  if (!a.model) missing.push('--model — 에이전트 모델 (사용자가 정한 것)');
-  if (missing.length) L.fail(`orca-dispatch-task: 빠진 입력이 있다.\n${missing.map((m) => `- ${m}`).join('\n')}`);
 
-  const command = agentCommand(main, a.agent, String(a.model));
-  const created = orca(['terminal', 'create', '--worktree', `path:${dir}`, '--title', label, '--command', command]);
-  const handle = created && created.terminal && created.terminal.handle;
-  if (!handle) L.fail(`orca-dispatch-task: ${label} 탭을 열었지만 Orca가 탭 handle을 돌려주지 않았다. 'orca terminal list'로 확인한다.`);
-
-  // 탭 handle을 .state에 기록한다 — 첫 지시문을 보내기 전이라 태스크 세션의 기록과 겹치지 않는다
-  const fresh = L.readState(main, num);
-  fresh.tab = handle;
-  L.writeState(main, fresh);
-  L.syncDoc(main, fresh);
-
-  const text = firstInstruction(fresh, brief);
-  const manual = `탭 화면을 'orca terminal read --terminal ${handle}'로 확인하고, 준비되면 아래 첫 지시문을 'orca terminal send --terminal ${handle} --text "<첫 지시문>" --enter'로 보낸다.\n--- 첫 지시문 ---\n${text}`;
-  let waited;
-  try {
-    waited = orca(['terminal', 'wait', '--terminal', handle, '--for', 'tui-idle']);
-  } catch (e) {
-    L.fail(`orca-dispatch-task: ${label} 탭(${handle})을 열었지만 준비를 기다리지 못해 첫 지시문을 보내지 않았다 — ${e.message}\n${manual}`);
-  }
-  if (waited && waited.wait && waited.wait.satisfied === false) {
-    const why = waited.wait.reason || waited.wait.status || '준비 대기 미충족';
-    L.fail(`orca-dispatch-task: ${label} 탭(${handle})을 열었지만 준비(tui-idle)가 되지 않아 첫 지시문을 보내지 않았다 — ${why}\n${manual}`);
+  let tab = H.tabOf(st);
+  let host = null;
+  if (tab) {
+    host = hostOf('dispatch-task', label, tab);
+    if (!host.alive(tab.id)) {
+      // 사용자가 닫은 탭 — 기록을 지우고 새로 띄운다
+      saveTab(main, num, null);
+      tab = null;
+    } else if (tab.sent) {
+      L.fail(`dispatch-task: ${label} 탭 ${tab.id}에 이미 첫 지시를 보냈다. read-task ${label}로 화면을 확인한다. 새로 띄워야 하면 사용자가 그 탭을 닫은 뒤 다시 부른다.`);
+    } else {
+      const r = host.ready(tab.id);
+      if (!r.ok) L.fail(notReady(label, tab.id, r.why));
+    }
   }
-  const send = () => {
-    let r;
+
+  let launch = null;
+  if (!tab) {
+    host = H.current();
+    if (!host) {
+      L.fail(
+        `dispatch-task: 태스크 탭을 띄울 터미널 앱 안이 아니다(판정 환경 변수 ${H.envKeys().join('·')}가 모두 없다). ` +
+          '터미널 앱 탭 안에서 불렀다면 MCP 도구가 아니라 CLI(npx @angar2/taskery dispatch-task …)로 다시 부른다. ' +
+          '쓸 수 없으면 --manual로 다시 불러 사용자에게 손 전달한다.',
+      );
+    }
+    const missing = [];
+    if (!a.agent) missing.push(`--agent — ${AGENTS.join(' · ')}`);
+    if (!a.model) missing.push('--model — 에이전트 모델 (사용자가 정한 것)');
+    if (missing.length) L.fail(`dispatch-task: 빠진 입력이 있다.\n${missing.map((m) => `- ${m}`).join('\n')}`);
+    launch = agentLaunch(main, a.agent, String(a.model));
+    let opened;
     try {
-      r = sendPrompt(handle, text);
+      opened = host.open({ main, dir, label, agent: launch.agent, args: launch.args, command: shellLine(launch) });
     } catch (e) {
-      L.fail(`orca-dispatch-task: ${label} 탭(${handle})에 첫 지시문을 보내지 못했다 — ${e.message}\n${manual}`);
+      L.fail(`dispatch-task: ${label} 탭을 열지 못했다 — ${e.message}`);
     }
-    if (r.refused) L.fail(`orca-dispatch-task: ${label} 탭(${handle})이 첫 지시문을 받지 않았다 — ${r.refused}\n${manual}`);
-    return r.observed;
-  };
-  // Orca가 턴 시작을 관측했다고 답해도 지시문이 입력창에 제출되지 않은 채 남은 적이 있다(stash TASK-105).
-  // 그래서 관측 여부와 무관하게 Enter만 한 번 더 보낸다 — 입력창이 비었거나 이미 진행 중이면 영향이 없다
-  const observed = send();
-  let sendNote = null;
+    // 탭 기록을 .state에 남긴다 — 첫 지시문을 보내기 전이라 태스크 세션의 기록과 겹치지 않는다
+    tab = { host: host.name, id: opened.id, sent: false };
+    saveTab(main, num, tab);
+    if (opened.blocked) L.fail(notReady(label, tab.id, opened.blocked));
+  }
+
+  // 첫 지시문은 저장하지 않는다 — 다시 부를 때는 같은 칸 인자로 다시 만든다
+  const fresh = L.readState(main, num);
+  let sent;
   try {
-    orca(['terminal', 'send', '--terminal', handle, '--enter']);
+    sent = host.sendFirst(tab.id, firstInstruction(fresh, brief));
   } catch (e) {
-    if (observed) sendNote = `확인용 Enter를 보내지 못했다(${e.message}) — 탭에서 진행을 확인한다.`;
-    else L.fail(`orca-dispatch-task: ${label} 탭(${handle})에서 첫 지시문의 턴 시작이 관측되지 않았고, Enter도 보내지 못했다 — ${e.message}\n'orca terminal read --terminal ${handle}'로 화면을 읽어, 지시문이 입력창에 남아 있으면 Enter를, 없으면 아래 첫 지시문을 보낸다.\n--- 첫 지시문 ---\n${text}`);
-  }
-  // 관측되지 않았으면 화면을 본다 — 지시문이 보이면 Enter로 들어간 것이고, 없으면 준비 전에 사라진 것이라 한 번 더 보낸다
-  if (!observed) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, SCREEN_SETTLE_MS);
-    if (onScreen(handle, text.split('\n')[0].split(' ').slice(0, 4).join(' '))) {
-      sendNote = '턴 시작이 관측되지 않아 Enter를 한 번 더 보냈고, 탭 화면에 첫 지시문이 보인다 — 탭에서 진행을 확인한다.';
-    } else if (send()) {
-      sendNote = '첫 전송은 턴 시작이 관측되지 않고 Enter 뒤 화면에도 없어 한 번 더 보냈다.';
-    } else {
-      L.fail(`orca-dispatch-task: ${label} 탭(${handle})에 첫 지시문을 두 번 보냈지만 턴 시작이 관측되지 않았다.\n${manual}`);
-    }
+    L.fail(
+      [
+        `dispatch-task: ${label} 탭 ${tab.id}에 첫 지시문을 보냈지만 제출을 확인하지 못했다 — ${e.message}.`,
+        `- read-task ${label}로 화면을 읽는다. 지시문으로 일을 시작했으면 그대로 둔다. 지시문이 입력창에 남아 있으면 사용자에게 그 탭에서 Enter를 부탁한다. 화면에 없으면 dispatch-task ${label}를 같은 칸 인자로 다시 부른다.`,
+      ].join('\n'),
+    );
   }
+  saveTab(main, num, { ...tab, sent: true });
   return [
-    `${label} 태스크 세션을 띄웠다 — 탭 ${handle}`,
-    `- 실행: ${command}`,
+    `${label} 태스크 세션을 띄웠다 — ${host.label} 탭 ${tab.id}`,
+    launch ? `- 실행: ${shellLine(launch)}` : '- 앞서 연 탭에 첫 지시만 보냈다.',
     `- 폴더: ${dir}`,
     `- 첫 지시문을 보냈다(시작: ${startSkill(fresh)}, 범위: ${fresh.range}).`,
-    ...(sendNote ? [`- 알림: ${sendNote}`] : []),
+    ...(sent && sent.note ? [`- 알림: ${sent.note}`] : []),
     '다음: wait-reports가 걸려 있지 않으면 백그라운드 셸로 걸어 둔다.',
   ].join('\n');
 }
 
+// send-task·read-task가 쓰는 탭 기록 — 없으면 멈춘다
+function recordedTab(cmd, main, task) {
+  L.requireInstalled(main);
+  const num = L.parseTaskNum(task);
+  const st = L.readState(main, num);
+  const label = L.taskLabel(num);
+  if (st.closed) L.fail(`${label}은 이미 닫혔다.`);
+  const tab = H.tabOf(st);
+  if (!tab) L.fail(`${cmd}: ${label}에는 띄운 탭 기록이 없다. 손 전달한 태스크면 사용자에게 전달을 부탁한다.`);
+  return { label, tab, host: hostOf(cmd, label, tab) };
+}
+
+const ORCHE_TAG = '[오케스트레이션]';
+
+async function sendTask(ctx, a) {
+  if (!a.task || !a.text || !String(a.text).trim()) L.fail('send-task: 태스크 번호와 보낼 말을 넣는다. 예: send-task TASK-012 "색은 파랑으로 한다"');
+  const { label, tab, host } = recordedTab('send-task', ctx.main, a.task);
+  const said = String(a.text).trim();
+  const text = said.startsWith(ORCHE_TAG) ? said : `${ORCHE_TAG} ${said}`;
+  try {
+    host.send(tab.id, text);
+  } catch (e) {
+    L.fail(`send-task: ${label} 탭(${tab.id}) — ${e.message}`);
+  }
+  return `${label} 탭 ${tab.id}에 보냈다.`;
+}
+
+async function readTask(ctx, a) {
+  if (!a.task) L.fail('read-task: 빠진 입력이 있다.\n- <task> — 태스크 번호 (첫 번째 인자)');
+  const { label, tab, host } = recordedTab('read-task', ctx.main, a.task);
+  let screen;
+  try {
+    screen = host.read(tab.id);
+  } catch (e) {
+    L.fail(`read-task: ${label} 탭(${tab.id}) — ${e.message}`);
+  }
+  return `${label} 탭 ${tab.id} 화면 (${host.label}):\n${screen}`;
+}
+
 async function reportTask(ctx, a) {
   const main = ctx.main;
   L.requireInstalled(main);
@@ -262,18 +279,23 @@ function takeUnread(main) {
   return lines;
 }
 
-// 오래 조용한 태스크 탭 — 열린 태스크 중 탭 기록이 있고 마지막 출력이 기다린 시간보다 오래된 것
-function quietTabs(main) {
+// 살펴볼 태스크 탭 — 열린 태스크 중 탭 기록이 있고, 그 호스트가 살펴볼 이유를 알려 준 것과 읽지 못한 것
+function checkTabs(main) {
   const out = [];
   for (const st of L.listStates(main)) {
-    if (st.closed || !st.tab) continue;
-    const label = L.taskLabel(st.num);
+    const tab = H.tabOf(st);
+    if (st.closed || !tab) continue;
+    const head = `- ${L.taskLabel(st.num)} 탭 ${tab.id} — `;
+    const host = H.byName(tab.host);
+    if (!host) {
+      out.push(`${head}탭을 읽지 못했다(터미널 앱 '${tab.host}'을 모른다)`);
+      continue;
+    }
     try {
-      const r = orca(['terminal', 'show', '--terminal', st.tab]);
-      const last = r && r.terminal && r.terminal.lastOutputAt;
-      if (last && Date.now() - last >= WAIT_MS) out.push(`- ${label} 탭 ${st.tab} — 마지막 출력 ${L.minutes(Date.now() - last)} 전`);
+      const why = host.check(tab.id, WAIT_MS);
+      if (why) out.push(head + why);
     } catch (e) {
-      out.push(`- ${label} 탭 ${st.tab} — 탭을 읽지 못했다(${e.message.replace(/^orca terminal show 실패: /, '')})`);
+      out.push(`${head}탭을 읽지 못했다(${e.message})`);
     }
   }
   return out;
@@ -295,8 +317,8 @@ async function waitReports(ctx) {
     if (Date.now() >= until) break;
     await new Promise((r) => setTimeout(r, Math.min(POLL_MS, Math.max(0, until - Date.now()))));
   }
-  const quiet = quietTabs(main);
-  return withRearm(main, [`보고 없이 ${L.minutes(WAIT_MS)}이 지났다.`, `오래 조용한 탭: ${quiet.length ? '' : '없음'}`.trimEnd(), ...quiet]);
+  const tabs = checkTabs(main);
+  return withRearm(main, [`보고 없이 ${L.minutes(WAIT_MS)}이 지났다.`, `살펴볼 탭: ${tabs.length ? '' : '없음'}`.trimEnd(), ...tabs]);
 }
 
-module.exports = { orcaDispatchTask, reportTask, waitReports, firstInstruction };
+module.exports = { dispatchTask, sendTask, readTask, reportTask, waitReports, firstInstruction };