agentlas 1.0.22 → 1.0.24

package/engine/agentlas.cjs

@@ -136,11 +136,8 @@ function main() {
   }
 
   if (code === undefined) {
-    // 알 수 없는 토큰: 에이전트 이름이면 그 에이전트와의 REPL로 점프,
-    // 아니면 전체를 하나의 작업으로 보고 원샷 실행(run) — v1과 동일한 UX.
-    const { findAgent } = require("./agents/registry.cjs");
-    let agent = null;
-    try { agent = findAgent(ctx.db(), normalized[0]); } catch { /* db unavailable → run이 진단 */ }
+    // 알 수 없는 토큰은 프로젝트 작업으로 실행한다. 에이전트 이름 하나가
+    // 전역 대화 소유권으로 바뀌는 암묵 경로는 없다.
     /*
      * 오타 가드: 인자가 "공백 없는 한 단어" 하나뿐이고 명령도 에이전트도 아니면
      * 그건 작업 지시가 아니라 명령 오타일 가능성이 압도적이다. 그대로 프롬프트로
@@ -148,7 +145,7 @@ function main() {
      * 에서 ls -la 실행 실증). 가장 가까운 명령을 제안하고 정직하게 멈춘다.
      * 진짜 한 단어 작업은 따옴표+run -p 로 그대로 실행된다.
      */
-    if (!agent && normalized.length === 1 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(normalized[0])) {
+    if (normalized.length === 1 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(normalized[0])) {
       const token = normalized[0];
       const names = Object.keys(commands.COMMANDS)
         .concat(Object.keys(commands.COMMAND_ALIASES || {}))
@@ -163,13 +160,6 @@ function main() {
         : `See: agentlas help  ·  to run it as a task: agentlas run -p "${token}"`);
       process.exit(1);
     }
-    if (agent && normalized.length === 1) {
-      const { startRepl } = require("./ui/repl.cjs");
-      return startRepl(ctx, { agent: agent.slug }).then(
-        (replCode) => process.exit(replCode || 0),
-        (e) => { ctx.err(String((e && e.message) || e)); process.exit(1); },
-      );
-    }
     code = commands.COMMANDS.run().run(ctx, normalized);
   }
 

package/engine/agents/router.cjs

@@ -144,7 +144,6 @@ async function resolveAutoRoute(db, task, opts = {}) {
       ...roster,
     ].join("\n"),
     multi: false,
-    fallback: [],
     signal: opts.signal,
     timeoutMs: opts.timeoutMs || 40000,
   });

package/engine/architecture.data.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.5.36",
-  "emitterBlock": "## Memory (Agentlas curated memory)\n\nIf — and only if — this turn produced something durable (a decision, a stable fact,\na user preference, a risk, a reusable procedure), end your reply with a Memory Events\nblock. Emit nothing when nothing durable was learned.\n\nRules:\n- Never include secrets, credentials, API keys, raw logs, or full transcripts.\n- Real credential values may live only in local project .env/.env.local,\n  ignored signing/ or credentials/ files, or a local keychain/vault. Memory\n  Events may mention env names and local relative paths only.\n- For deploy, release, store, billing, auth, API, or cloud work, first read the\n  project's .agentlas/local-credentials.map.json and the top\n  \"Local Credential Index\" section of .agentlas/project-soul-memory.md\n  before saying a credential is missing.\n- One event per durable item. Keep \"content\" to one or two sentences.\n- \"memory_kind\": fact | decision | preference | risk | procedure | hypothesis | evidence | deprecation | conflict\n- \"suggested_scope\": user_identity | team_memory | project (this folder) | agent_repo | session (temporary) | discard\n- \"agent_team\" is accepted only as a legacy alias for team_memory.\n- Add \"request_context\" when it improves future recall: user_intent, trigger_terms,\n  cwd_at_request, target_project, target_path, cross_context, outcome.\n- Never put the raw user prompt or transcript in request_context.\n- Suggest a scope; the Memory Curator decides the final destination.\n\nFormat (omit entirely if empty):\n\n## Memory Events\n```json\n[\n  {\n    \"memory_kind\": \"decision\",\n    \"content\": \"...\",\n    \"suggested_scope\": \"project\",\n    \"confidence\": \"high\",\n    \"evidence_refs\": [],\n    \"request_context\": {\n      \"user_intent\": \"...\",\n      \"trigger_terms\": [\"...\"],\n      \"cwd_at_request\": null,\n      \"target_project\": null,\n      \"target_path\": null,\n      \"cross_context\": false,\n      \"outcome\": \"...\"\n    }\n  }\n]\n```",
+  "version": "1.6.0",
+  "emitterBlock": "## Memory (Agentlas curated memory)\n\nAt the end of EVERY completed normal reply, emit exactly one hidden Memory Events\nenvelope. The runtime removes it before display. This envelope is the per-turn receipt:\nalways include a compact safe turn_summary, and use an empty candidates array when\nnothing durable was learned. Do not skip the envelope.\n\nRules:\n- Never include secrets, credentials, API keys, raw logs, or full transcripts.\n- Real credential values may live only in local project .env/.env.local,\n  ignored signing/ or credentials/ files, or a local keychain/vault. Memory\n  Events may mention env names and local relative paths only.\n- For deploy, release, store, billing, auth, API, or cloud work, first read the\n  project's .agentlas/local-credentials.map.json and the top\n  \"Local Credential Index\" section of .agentlas/project-soul-memory.md\n  before saying a credential is missing.\n- One candidate per durable item. Keep \"content\" to one or two sentences.\n- \"memory_kind\": fact | decision | preference | risk | procedure | hypothesis | evidence | deprecation | conflict\n- \"suggested_scope\": user_identity | team_memory | project (this folder) | agent_repo | session (temporary) | discard\n- Use user_identity for a stable operator preference or personal fact (their name, role, language, tone,\n  how they want you to behave) — these must outlive any one project. The curator only files user_identity\n  when you label it so with \"confidence\": \"high\"; it never promotes into that scope, so a preference emitted\n  at lower confidence is demoted to a throwaway session note.\n- \"agent_team\" is accepted only as a legacy alias for team_memory.\n- Add \"request_context\" when it improves future recall: user_intent, trigger_terms,\n  cwd_at_request, target_project, target_path, cross_context, outcome.\n- Never put the raw user prompt or transcript in request_context.\n- Suggest a scope; the separate Memory Curator decides the final destination.\n- turn_summary is one value-free sentence about the completed outcome. It is not the\n  user prompt, a transcript, raw log, secret, or absolute local path.\n\nFormat (always emit, including an empty candidates array):\n\n## Memory Events\n```json\n{\n  \"schema_version\": \"agentlas.memory-ticket.v1\",\n  \"turn_summary\": \"Completed outcome in one safe sentence.\",\n  \"candidates\": [\n    {\n      \"memory_kind\": \"decision\",\n      \"content\": \"...\",\n      \"suggested_scope\": \"project\",\n      \"confidence\": \"high\",\n      \"sensitivity\": \"internal\",\n      \"evidence_refs\": [],\n      \"request_context\": {\n        \"user_intent\": \"...\",\n        \"trigger_terms\": [\"...\"],\n        \"cwd_at_request\": null,\n        \"target_project\": null,\n        \"target_path\": null,\n        \"cross_context\": false,\n        \"outcome\": \"...\"\n      }\n    }\n  ]\n}\n```",
   "eventsHeading": "## Memory Events",
   "memoryDir": ".agentlas",
   "soulFile": "project-soul-memory.md",
@@ -72,12 +72,12 @@
       "slug": "agentlas-orchestrator",
       "name": "Agentlas 오케스트레이터",
       "nameEn": "Agentlas Orchestrator",
-      "tagline": "에이전트를 지정하지 않아도 요청을 읽고 알맞은 역할로 라우팅",
-      "taglineEn": "Routes plain-language requests when no agent is specified",
+      "tagline": "프로젝트 컨트롤러를 지원하는 작업 단위 오케스트레이션",
+      "taglineEn": "Task-scoped orchestration under a project controller",
       "role": "orchestrator",
       "visibility": "background",
       "tone": "blue",
-      "systemPrompt": "# Agentlas Orchestrator (built-in)\n\nYou are the default front door for Agentlas Desktop and the Agentlas terminal. Your\njob is NOT to be the best specialist. Your job is to route the user's plain-language\nrequest to the right installed agent, company, or skill when the user did not name one.\n\nThe Agentlas host will usually inject a roster and may pre-select a concrete agent\nbefore your turn starts. Follow that host routing. If you receive the task directly,\napply the same policy yourself.\n\n## Global routing policy\n- Before substantial work, inspect the user's request and the available roster.\n- If the user explicitly names an agent, company, runtime, or skill, honor that.\n- If no agent is named, choose the smallest capable route by capability, trigger\n  terms, required tools, project context, and safety risk.\n- Announce the route before doing the work:\n  \"사용 에이전트: <name>. 이유: <short reason>.\"\n  Use English instead when the interface/user language is English.\n- Then proceed immediately. Do not ask the user to choose an agent unless the choice\n  changes money movement, destructive actions, public publishing, legal/medical risk,\n  access to private data, or whether Agentlas should create a dedicated App.\n- For multi-step work, route top-down only. Do not create a loop where a worker calls\n  back into you.\n\n## Canonical routes\n- App creation, Apps Generate, \"generate app\", \"make an app\", \"앱 만들어줘\",\n  \"내부 앱\", \"앱 빌더\", or generated app factory work -> Agentlas App Builder.\n  Use this route only for explicit app requests or app-worthy workflows with durable\n  state, editing, export, automation, scheduling, approvals, or repeated runs.\n  Do not ask about making an App for greetings, one-off answers, simple chat,\n  or lightweight content requests. If Apps Generate mode was not explicitly selected,\n  ask the user whether they want a dedicated Agentlas App before emitting manifests\n  or creating files.\n- Agent creation, team design, skill generation, AGENTS.md/CLAUDE.md/GEMINI.md\n  packaging, Codex compatibility, or \"make me an agent\" -> Agentlas Core Engine\n  Meta-Agent (built-in). If the full public core package is also installed, use it\n  as the file-rich contract source; otherwise use the embedded contract. Route by mode:\n  single-agent-creator for one worker, team-builder for multi-role teams, and\n  agentlas-packager for existing agents/teams/repos/ZIPs that need Agentlas\n  architecture, public/private cleanup, runtime adapters, and verification.\n  Do not require Web-only SaaS billing/account/session code for local packaging.\n- Durable project continuity, decision logs, project memory, and workstream ownership\n  -> Project PM Soul.\n- Memory write quality, request_context, scope conflicts, or \"why can't it remember?\"\n  -> Memory Curator.\n- Sitemap, task-selection bias, stale surfaces, completion evidence, or validation\n  gaps -> Task Bias Curator.\n- If an imported local team/company matches the request, prefer its CEO route over a\n  generic built-in.\n\n## Codex-style skill behavior\nWhen the selected route has skills, read their descriptions/triggers and auto-select\nthe relevant skills even if the user did not name them. State the selected skill(s)\nand reason before acting, then continue."
+      "systemPrompt": "# Agentlas Orchestrator (built-in)\n\nYou are a project-bound orchestration capability, never a global chat owner.\n\nThe host supplies one connected Work project, its system prompt, ordered agent pool,\nmemory and the current WorkOrder. The first agent in that ordered pool owns the task.\nYou may act only when you are that first agent or when the owning controller delegates\nthis bounded WorkOrder to you.\n\n## Ownership and staffing\n- Preserve the project's ordered Orch/Worker model priorities.\n- Select task-scoped sub-agents from the project's explicit pool by full semantic\n  judgment. Do not route by regex, keyword lists, trigger-term dictionaries or glossaries.\n- Every sub-agent remains subordinate to the project controller and exists only for\n  its assignment. Never transfer session or project ownership.\n- Pin and validate exact releases before execution. Never silently substitute a\n  missing, expired or incompatible agent.\n- An explicit named-agent call affects only that turn.\n\n## Recovery\n- Observe failures as private evidence, decide the safest available recovery with the\n  connected model, execute reversible recovery automatically, and verify the outcome.\n- Do not expose raw errors, codes, stack traces, paths or internal component language.\n- Code provides state, evidence and finite capabilities only. You author the concise\n  summary, question and action labels for the actual situation.\n- If model judgment is unavailable, remain unresolved. Never fabricate a semantic\n  fallback or present a guessed diagnosis as success.\n\n## Completion\nReturn the verified project result and compact evidence. Record durable project memory\nwithout binding that memory to one replaceable agent release."
     },
     {
       "id": "builtin-agentlas-app-builder",

package/engine/bootstrap-schema.sql

@@ -1,6 +1,6 @@
 -- Agentlas first-run bootstrap schema (project-first Work contract)
--- Source DB user_version=85. Desktop remains the migration authority.
-PRAGMA user_version=85;
+-- Source DB user_version=86. Desktop remains the migration authority.
+PRAGMA user_version=86;
 CREATE TABLE active_runtime (
         id INTEGER PRIMARY KEY CHECK(id = 1),
         kind TEXT NOT NULL
@@ -35,7 +35,7 @@ CREATE TABLE chats (
         agent_id TEXT NOT NULL,
         title TEXT NOT NULL DEFAULT '새 채팅',
         created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL, firm_id TEXT REFERENCES firms(id) ON DELETE SET NULL, archived_at TEXT, working_folder TEXT, kind TEXT NOT NULL DEFAULT 'user', parent_chat_id TEXT, used_at TEXT, continuous_mode INTEGER NOT NULL DEFAULT 0, swarm_mode INTEGER NOT NULL DEFAULT 0, last_viewed_at TEXT, hired_agents TEXT, origin_surface TEXT NOT NULL DEFAULT 'work', runtime_selection_json TEXT,
+        updated_at TEXT NOT NULL, firm_id TEXT REFERENCES firms(id) ON DELETE SET NULL, archived_at TEXT, working_folder TEXT, kind TEXT NOT NULL DEFAULT 'user', parent_chat_id TEXT, used_at TEXT, continuous_mode INTEGER NOT NULL DEFAULT 0, swarm_mode INTEGER NOT NULL DEFAULT 0, last_viewed_at TEXT, origin_surface TEXT NOT NULL DEFAULT 'work', runtime_selection_json TEXT,
         FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE SET NULL,
         FOREIGN KEY(agent_id) REFERENCES installed_agents(id) ON DELETE CASCADE
       );

package/engine/commands/doctor.cjs

@@ -1,9 +1,9 @@
 "use strict";
 /*
  * doctor — 런타임·데이터·자격증명 건강 점검.
- * 진단/수리 규칙 자체는 engine/agentlas-doctor.cjs(3제품 패리티 계약)에 있고,
- * 이 명령은 "현재 상태 관측"만 한다. 여기서 관측 항목을 바꿔도 패리티 게이트와
- * 무관하지만, 실패 분류·수리 로직을 건드리려면 반드시 sync-runtime-doctor.sh를 통과시켜라.
+ * 이 명령은 사용자가 명시적으로 요청한 현재 상태 관측만 한다.
+ * 자동 복구는 프로젝트 컨트롤러와 저장된 모델 우선순위가 맡으며, 이 명령은
+ * 오류 문자열을 분류하거나 설정을 자동 변경하지 않는다.
  */
 const fs = require("node:fs");
 const path = require("node:path");

package/engine/commands/firm.cjs

@@ -12,7 +12,7 @@ const { rowToAgent } = require("../agents/registry.cjs");
 function findFirm(db, token) {
   const q = String(token || "").trim().toLowerCase();
   if (!q) return null;
-  return db.prepare("SELECT * FROM firms WHERE lower(slug)=? OR lower(name)=?").get(q, q)
+  return db.prepare("SELECT * FROM firms WHERE lower(id)=? OR lower(slug)=? OR lower(name)=?").get(q, q, q)
     || db.prepare("SELECT * FROM firms WHERE lower(slug) LIKE ? ORDER BY slug LIMIT 1").get(`%${q}%`)
     || null;
 }
@@ -158,6 +158,8 @@ async function run(ctx, args) {
       onEvent: (ev) => {
         if (ev.phase === "plan") ctx.err(dim(ko ? `${firm.name} · CEO가 작업을 분배하는 중…` : `${firm.name} · CEO is planning the work…`));
         else if (ev.phase === "delegate") ctx.err(dim((ko ? "위임 → " : "delegating → ") + ev.targets.map((t) => t.name || t.role).join(", ")));
+        else if (ev.phase === "repair") ctx.err(dim(ko ? "검증 결함 확인 → 수정 후 재검증" : "Verification blocker found → repairing before re-check"));
+        else if (ev.phase === "verify") ctx.err(dim(ko ? "구현 결과 준비 완료 → 독립 검증 시작" : "Implementation ready → starting independent verification"));
         else if (ev.phase === "division-done") ctx.err(dim(`  ${ev.role}: ${ev.ok ? "ok" : "failed"}`));
         else if (ev.phase === "synthesize") ctx.err(dim(ko ? "팀 결과를 종합하는 중…" : "Synthesizing team results…"));
       },

package/engine/commands/help.cjs

@@ -4,14 +4,11 @@
 const HELP = `agentlas — the operating system for agents, in your terminal
 
   agentlas                 open the terminal (REPL)
-  agentlas <agent>         jump into a chat with one agent
-  agentlas "<task>"        auto-route to the best agent and run once
+  agentlas "<task>"        run once with this project's controller
 
-TALK & RUN
-  <agent> · chat <agent>   jump into a chat with one agent
-  run [agent] [prompt]     one-shot (-p · --runtime · --model · --effort · --permission)
+PROJECT WORK
+  run [agent] [prompt]     project-first one-shot; exact agent is an explicit advanced override
   firm <firm> [task]       delegate to a CEO (--runtime · --model · --effort)
-  chats [n] · open <id>    recent conversations · resume one
 
 AGENTS & HUB
   search "<what you need>" discover agents in the Hub
@@ -52,7 +49,7 @@ ACCOUNT & OPS
 
 IN-REPL (agentlas → interactive, Orca multi-session)
   /spawn <agent> [task] · /sessions · /tree · /s <n> · /steer <n> <msg> ·
-  /kill <n> · /rm <n> · /broadcast <msg> · /use · /runtime · /model · /effort · /permission
+  /kill <n> · /rm <n> · /broadcast <msg> · /runtime · /model · /effort · /permission
   typing during a running turn queues steering; ctrl-c interrupts the turn
 
 Options: -p|--print · --runtime claude-code|codex|gemini · --model <exact-id> ·

package/engine/commands/index.cjs

@@ -12,7 +12,6 @@ const path = require("node:path");
 const COMMANDS = {
   version: () => require("./version.cjs"),
   list: () => require("./list.cjs"),
-  chats: () => require("./chats.cjs"),
   doctor: () => require("./doctor.cjs"),
   mcp: () => require("./mcp.cjs"),
   help: () => require("./help.cjs"),
@@ -32,10 +31,8 @@ const COMMANDS = {
   install: () => require("./install.cjs"),
   plugin: () => require("./plugin.cjs"),
   plugins: () => require("./plugin.cjs"),
-  open: () => require("./open.cjs"),
   automation: () => require("./automation.cjs"),
   native: () => require("./native.cjs"),
-  chat: () => require("./chat.cjs"),
   multimodal: () => require("./multimodal.cjs"),
   workforce: () => require("./workforce.cjs"),
   network: () => require("./workforce.cjs"),
@@ -94,11 +91,9 @@ const DESKTOP_ONLY_SURFACES = {
   trex: "T-rex slide studio is Desktop-only.",
   slides: "T-rex slide studio is Desktop-only.",
   prompts: "Prompt Store is Desktop-only.",
-  dashboard: "Dashboard is Desktop-only — use: agentlas doctor · usage · list · chats",
+  dashboard: "Dashboard is Desktop-only — use: agentlas doctor · usage · list",
   marketplace: "Marketplace browsing is Desktop-only — use: agentlas search \"<what you need>\"",
   library: "Library is Desktop-only — use: agentlas list · env · mcp",
-  groups: "Agent groups (조합) are Desktop-only.",
-  "agent-groups": "Agent groups (조합) are Desktop-only.",
   settings: "Settings UI is Desktop-only — use: agentlas setup · env · creds · multimodal · doctor",
   apps: "Apps surface is Desktop-only.",
   quests: "Quests are Desktop-only.",

package/engine/commands/list.cjs

@@ -31,7 +31,7 @@ function run(ctx) {
     slug: a.slug, name: a.name, name_en: a.nameEn, tagline: a.tagline, tagline_en: a.taglineEn, builtin: a.builtin,
   }));
   const firms = ctx.tableExists(db, "firms")
-    ? db.prepare("SELECT id, name FROM firms ORDER BY name").all()
+    ? db.prepare("SELECT id, slug, name FROM firms ORDER BY name").all()
     : [];
 
   const en = ctx.lang === "en";
@@ -47,7 +47,13 @@ function run(ctx) {
   if (firms.length) {
     ctx.out("");
     ctx.out(ctx.ui.bold(en ? "Companies" : "회사"));
-    for (const f of firms) ctx.out(`  ${ctx.ui.accent(String(f.id).padEnd(24))} ${f.name}`);
+    for (const f of firms) {
+      const callable = String(f.slug || f.id);
+      ctx.out(`  ${ctx.ui.accent(callable.padEnd(28))} ${f.name}`);
+    }
+    ctx.out(ctx.ui.dim(en
+      ? "  Run one with: agentlas firm <company-key> \"<task>\""
+      : "  실행: agentlas firm <회사 키> \"<작업>\""));
   }
 
   const active = activeRuntimeRow(db);

package/engine/firms/orchestrate.cjs

@@ -71,13 +71,21 @@ function loadDelegateParser() {
 /** 표시/전달용 텍스트에서 제어 펜스를 제거한다(파싱만 — 부작용 없음). 실패 시 원문. */
 function cleanFenceText(text) {
   const raw = String(text || "");
+  let cleaned;
   try {
     const fences = require("../sessions/fences.cjs");
     if (fences && typeof fences.parseReplyFences === "function") {
-      return fences.parseReplyFences(raw).cleanText;
+      cleaned = fences.parseReplyFences(raw).cleanText;
     }
   } catch { /* fences 미존재/파서 실패 — 원문 보존 */ }
-  return parseDelegationsLocal(raw).cleanedText;
+  if (cleaned == null) cleaned = parseDelegationsLocal(raw).cleanedText;
+  return cleaned
+    .replace(/<!--\s*[\s\S]*?## Memory Events[\s\S]*?-->/gi, "")
+    .replace(/^\s*(?:사용 스킬|Skills used)\s*:[^\n.!?]*[.!?]?\s*(?:(?:이유|Reason)\s*:[^.!?]*[.!?]\s*)?/i, "")
+    .replace(/^\s*I(?:'|’)m using (?:the )?`?[^`.\n]+`? skill because [^.]*\.\s*/i, "")
+    .replace(/^\s*Execution mode:\s*`?appbridge-ceo-orchestrator`?[^\n]*\n?/gim, "")
+    .replace(/<verification_verdict>\s*(?:PASS|FAIL)\s*<\/verification_verdict>/gi, "")
+    .trim();
 }
 
 /** 리더(CEO) 시스템 프롬프트에 주입할 위임 가이드 (데스크탑 buildDelegateProtocol 동형 축약). */
@@ -91,6 +99,9 @@ function buildDelegateProtocol(reports) {
     "You lead a team. For THIS task, engage ONLY the direct reports actually needed —",
     "never all of them. Give each a focused brief (goal + specifics). If none are needed,",
     "do the work yourself and emit no Delegate block.",
+    "This is the only delegation planning round. Include every role required to finish the request now,",
+    "including downstream independent QA or verification roles. State dependencies in their briefs;",
+    "the host will delay verification until production results exist. Never defer a needed role to synthesis.",
     "",
     "Your direct reports:",
     list,
@@ -102,7 +113,7 @@ function buildDelegateProtocol(reports) {
     '{ "delegations": [ { "target": "<report role or name above>", "brief": "<what they should do>" } ] }',
     "```",
     "",
-    "After delegating, STOP — their results come back to you to synthesize. Don't do their work yourself.",
+    "After delegating, STOP — their results come back to you to synthesize. Synthesis is final and cannot start new work.",
   ].join("\n");
 }
 
@@ -196,6 +207,58 @@ async function parallelCap(items, cap, fn) {
   return out;
 }
 
+function isVerificationDivision(node) {
+  const label = `${node && node.role || ""} ${node && node.name || ""} ${node && node.key || ""}`
+    .toLowerCase()
+    .replace(/[_-]+/g, " ");
+  return /\b(?:eval|qa|quality|test|verification|verifier)\b|policy\s+gate/.test(label);
+}
+
+function isIntegrationDivision(item, siblingProductionCount) {
+  if (!item || siblingProductionCount < 2 || isVerificationDivision(item.node)) return false;
+  const label = `${item.node && item.node.role || ""} ${item.node && item.node.name || ""}`
+    .toLowerCase()
+    .replace(/[_-]+/g, " ");
+  const brief = String(item.brief || "").toLowerCase();
+  if (/\bdesign\b/.test(label)) return false;
+  return /\b(?:web|frontend|integration|integrator|release)\b/.test(label)
+    || /\b(?:integrat(?:e|ion)|wire|combine|merge)\b/.test(brief)
+    || /\bafter\b[\s\S]{0,80}\b(?:game|design|production|upstream|implementation)\b/.test(brief)
+    || /\b(?:once|when)\b[\s\S]{0,80}\b(?:complete|ready|finish)/.test(brief);
+}
+
+function stageTargets(targets) {
+  const nonVerification = targets.filter((m) => !isVerificationDivision(m.node));
+  const integration = nonVerification.filter((m) => isIntegrationDivision(m, nonVerification.length));
+  const integrationKeys = new Set(integration.map((m) => m.node.key));
+  return {
+    production: nonVerification.filter((m) => !integrationKeys.has(m.node.key)),
+    integration,
+    verification: targets.filter((m) => isVerificationDivision(m.node)),
+  };
+}
+
+function resultStatusContext(results) {
+  return results.length
+    ? results.map((r) => `- ${r.name}: ${r.ok ? "completed" : "failed"}`).join("\n")
+    : "- No upstream production slot was selected; inspect the current folder honestly.";
+}
+
+function verificationResultOk(text, sessionOk) {
+  if (!sessionOk) return false;
+  const source = String(text || "").trim();
+  const explicit = source.match(/<verification_verdict>\s*(PASS|FAIL)\s*<\/verification_verdict>/i);
+  if (explicit) return explicit[1].toUpperCase() === "PASS";
+  const opening = source.slice(0, 900);
+  return !/(?:\bverdict\s*:\s*fail\b|\brelease[- ]blocking\b|\bnot complete\b|\bcannot truthfully\b|\bno[- ]go\b|\bblocking defect\b)/i.test(opening);
+}
+
+function latestResultsAllOk(results) {
+  const latest = new Map();
+  for (const result of results) latest.set(result.key || `${result.role}:${result.name}`, result.ok);
+  return [...latest.values()].every(Boolean);
+}
+
 function turnText(res) {
   return ((res && (res.finalText || res.text)) || "").trim();
 }
@@ -267,10 +330,13 @@ async function runFirmTurn(p) {
     };
   }
 
-  // 2) DELEGATE — 매칭된 본부만 병렬 실행. 본부 세션은 CEO 세션의 자식으로 스폰되어
-  // kind='division' + parent_chat_id(CEO 챗)로 영속된다. 한 본부의 실패는 격리한다.
+  // 2) DELEGATE — 구현/디자인은 병렬로 실행하되 독립 검증 본부는 그 결과가 실제
+  // 작업 폴더에 반영된 뒤 실행한다. QA를 구현과 동시에 시작하면 "코드 없음"을 정상
+  // 결과로 반환해 CEO가 뒤늦게 충돌을 수습하게 된다. 병렬성은 의존성이 없는 슬롯에만
+  // 적용하고, 검증 슬롯은 명시적인 2단계 WorkOrder로 보존한다.
   onEvent({ phase: "delegate", targets: matched.map((m) => ({ role: m.node.role, name: m.node.name, brief: m.brief })) });
-  const divisionResults = await parallelCap(matched, maxParallel(), async (m) => {
+  const initialStages = stageTargets(matched);
+  const runTargets = async (targets, stageContext, stageKind) => parallelCap(targets, maxParallel(), async (m) => {
     const divisionRuntime = typeof p.resolveWorkerRuntime === "function"
       ? p.resolveWorkerRuntime(m.node)
       : workerRuntime;
@@ -293,17 +359,61 @@ async function runFirmTurn(p) {
     let text = "";
     let ok = false;
     try {
-      const res = await session.send(m.brief || task);
+      const prompt = stageKind === "verification"
+        ? `${m.brief || task}\n\n[Independent verification stage]\nAll upstream production and integration WorkOrders have finished. Inspect and exercise the current project folder as it exists now. Do not rely on an earlier empty-workspace observation.\n${stageContext}\n\nEnd the response with exactly <verification_verdict>PASS</verification_verdict> only when every requested acceptance condition passes after fixes. Otherwise end with <verification_verdict>FAIL</verification_verdict> and identify the remaining blocker.`
+        : stageKind === "integration"
+          ? `${m.brief || task}\n\n[Integration stage]\nThe upstream production WorkOrders have finished. Inspect their actual files in the current project, integrate every relevant implementation and design deliverable into the runnable product, then verify the integrated launch surface before returning. Do not report a missing or late upstream package without re-reading the current folder.\n${stageContext}`
+          : stageKind === "repair"
+            ? `${m.brief || task}\n\n[Release-blocking repair stage]\nIndependent verification found the following failures in the current integrated product. Inspect the evidence and current files, repair the actual shipped experience, and rerun the relevant checks before returning. Do not merely describe the fix.\n${stageContext}`
+            : (m.brief || task);
+      const res = await session.send(prompt);
       text = cleanFenceText(turnText(res));
-      ok = session.status === "done";
+      ok = stageKind === "verification"
+        ? verificationResultOk(text, session.status === "done")
+        : session.status === "done";
       if (!ok && !text) text = session.lastError || "no response";
     } catch (e) {
       text = (e && e.message) || String(e);
       ok = false;
     }
     onEvent({ phase: "division-done", role: m.node.role, ok });
-    return { role: m.node.role, name: m.node.name, ok, text, chatId: session.chatId };
+    return { key: m.node.key, role: m.node.role, name: m.node.name, ok, text, chatId: session.chatId };
   });
+  const productionResults = await runTargets(initialStages.production, "", "production");
+  let integrationResults = [];
+  if (initialStages.integration.length) {
+    onEvent({ phase: "integrate", targets: initialStages.integration.map((m) => ({ role: m.node.role, name: m.node.name })) });
+    integrationResults = await runTargets(initialStages.integration, resultStatusContext(productionResults), "integration");
+  }
+  let verificationResults = [];
+  if (initialStages.verification.length) {
+    const upstreamResults = [...productionResults, ...integrationResults];
+    verificationResults = await runTargets(initialStages.verification, resultStatusContext(upstreamResults), "verification");
+  }
+  const divisionResults = [...productionResults, ...integrationResults, ...verificationResults];
+
+  // Verification is a release gate, not a terminal report. When it finds a
+  // blocker, run one bounded repair cycle with the implementation/integration
+  // slots that produced the build, then independently verify the repaired
+  // product again. This closes the common "QA says FAIL and the command ends"
+  // gap while keeping retries finite.
+  if (initialStages.verification.length && verificationResults.some((result) => !result.ok)) {
+    const repairContext = verificationResults
+      .filter((result) => !result.ok)
+      .map((result) => `## ${result.name} (${result.role})\n${result.text}`)
+      .join("\n\n");
+    const repairTargets = [...initialStages.production, ...initialStages.integration];
+    if (repairTargets.length) {
+      onEvent({ phase: "repair", targets: repairTargets.map((m) => ({ role: m.node.role, name: m.node.name })) });
+      const repairResults = await runTargets(repairTargets, repairContext, "repair");
+      divisionResults.push(...repairResults);
+      const recheckContext = resultStatusContext([...productionResults, ...integrationResults, ...repairResults]);
+      const recheckResults = await runTargets(initialStages.verification, recheckContext, "verification");
+      divisionResults.push(...recheckResults);
+    }
+  }
+  const usedDivisionKeys = new Set(matched.map((m) => m.node.key));
+  const divisionAttempts = new Map(matched.map((m) => [m.node.key, 1]));
 
   // 3) SYNTHESIZE — CEO 세션의 두 번째 턴. status:failed 표기로 오류 문자열이 산출물로
   // 오독되는 것을 막는다(데스크탑 CONFLICT_SYNTHESIS_GUIDANCE 계약).
@@ -314,15 +424,54 @@ async function runFirmTurn(p) {
     divisionResults
       .map((r) => `## ${r.name} (${r.role})\nstatus: ${r.ok ? "ok" : "failed"}\n${r.text}`)
       .join("\n\n");
-  const finalRes = await ceoSession.send(synthPrompt);
-  const finalText = cleanFenceText(turnText(finalRes));
+  let finalRes = await ceoSession.send(synthPrompt);
+  let finalRaw = turnText(finalRes);
+
+  // A controller may discover the next required role only after reading the
+  // first results (for example PM -> Game/Design -> Eval). Execute bounded,
+  // previously-unused follow-up delegations instead of printing "starting"
+  // prose and ending the command without doing the work.
+  for (let round = 0; round < divisions.length; round += 1) {
+    const followupParsed = parseDelegations(finalRaw);
+    const hasFailedResult = !latestResultsAllOk(divisionResults);
+    const followup = matchTargets(followupParsed.delegations, divisions)
+      .filter((m) => !usedDivisionKeys.has(m.node.key) || (hasFailedResult && (divisionAttempts.get(m.node.key) || 0) < 2));
+    if (!followup.length) break;
+    for (const item of followup) {
+      usedDivisionKeys.add(item.node.key);
+      divisionAttempts.set(item.node.key, (divisionAttempts.get(item.node.key) || 0) + 1);
+    }
+    onEvent({ phase: "delegate", targets: followup.map((m) => ({ role: m.node.role, name: m.node.name, brief: m.brief })) });
+    const followupStages = stageTargets(followup);
+    const followupProductionResults = await runTargets(followupStages.production, "", "production");
+    let followupIntegrationResults = [];
+    if (followupStages.integration.length) {
+      const upstream = [...divisionResults, ...followupProductionResults];
+      onEvent({ phase: "integrate", targets: followupStages.integration.map((m) => ({ role: m.node.role, name: m.node.name })) });
+      followupIntegrationResults = await runTargets(followupStages.integration, resultStatusContext(upstream), "integration");
+    }
+    let followupVerificationResults = [];
+    if (followupStages.verification.length) {
+      const upstream = [...divisionResults, ...followupProductionResults, ...followupIntegrationResults];
+      followupVerificationResults = await runTargets(followupStages.verification, resultStatusContext(upstream), "verification");
+    }
+    divisionResults.push(...followupProductionResults, ...followupIntegrationResults, ...followupVerificationResults);
+    onEvent({ phase: "synthesize" });
+    finalRes = await ceoSession.send(
+      `${task}\n\n[Updated results from your team — continue orchestration only if a still-unused required role is missing; otherwise return the final user result.]\n` +
+      `${CONFLICT_SYNTHESIS_GUIDANCE}\n\n` +
+      divisionResults.map((r) => `## ${r.name} (${r.role})\nstatus: ${r.ok ? "ok" : "failed"}\n${r.text}`).join("\n\n"),
+    );
+    finalRaw = turnText(finalRes);
+  }
+  const finalText = cleanFenceText(finalRaw);
   const finalOk = ceoSession.status === "done";
   onEvent({ phase: "final", delegated: true, ok: finalOk });
 
   // CEO 종합 턴의 성공은 팀의 성공이 아니다 — 자식 결과를 집계해 부분 완료가 성공으로
   // 둔갑하지 않게 한다(데스크탑 동일 수리).
   return {
-    ok: finalOk && divisionResults.every((r) => r.ok),
+    ok: finalOk && latestResultsAllOk(divisionResults),
     text: finalText,
     chatId: ceoSession.chatId,
     plan: { text: cleanedText, delegations },

package/engine/sessions/orchestrator.cjs

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * sessions/orchestrator — 오르카 계층: 멀티세션 스폰/전환/스티어/킬/브로드캐스트.
+ * sessions/orchestrator — 프로젝트 Work의 컨트롤러/서브에이전트 실행 트리.
  *
  * 세션 번호는 s1, s2, … 로 붙는다(사람이 한 키로 지목할 수 있는 안정 번호).
  * 활성 세션 하나만 터미널에 스트리밍되고, 나머지는 백그라운드에서 이벤트를
@@ -67,14 +67,12 @@ class Orchestrator extends EventEmitter {
 
     session.on("event", (ev) => {
       this.emit("session-event", { key, session, ev });
-      if (ev.type === "turn-end" && this.activeKey !== key) {
+      if (ev.type === "turn-end" && ev.ok && this.activeKey !== key) {
         this.emit("notice", {
           key,
           session,
-          text: ev.ok
-            ? `${key} ${session.agent.slug}: done`
-            : `${key} ${session.agent.slug}: ${ev.error || "failed"}`,
-          ok: !!ev.ok,
+          text: `${key} ${session.agent.slug}: done`,
+          ok: true,
         });
       }
     });
@@ -157,21 +155,6 @@ class Orchestrator extends EventEmitter {
    * 그래서 실패는 세션 단위로 모으고, 실제 전달된 목록은 무슨 일이 있어도 반환한다.
    * (sendTo/spawn의 "상한 초과는 정직한 거부" 계약 자체는 그대로 둔다.)
    */
-  broadcast(prompt) {
-    const sent = [];
-    const skipped = [];
-    for (const [key, session] of this.sessions) {
-      if (session.status === "killed") continue;
-      try {
-        this.sendTo(key, prompt);
-        sent.push(key);
-      } catch (e) {
-        skipped.push({ key, error: String((e && e.message) || e) });
-      }
-    }
-    return { sent, skipped };
-  }
-
   /** 세션 표: [{key, active, agent, status, elapsed, lastLine, parentKey, depth}] */
   list() {
     const rows = [];