agentlas 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## 1.0.3 — 2026-07-27
+
+Live `workforce` runs surfaced four defects that no unit gate could reach.
+
+- **A slash after Korean/Japanese/Chinese text no longer reads as a file
+  path.** The hub-boundary guard's absolute-path lookbehind excluded only
+  ASCII, so ordinary phrases ("진단/멱등키", "한국어/영어") were rejected as
+  private paths — and the phrase being the task itself meant no repair was
+  possible. Shared fixtures now pin this in both this engine and the server
+  (`scripts/sync-privacy-guard.sh`).
+- **Bundle preparation is no longer killed by the connect timeout.** The
+  15s "connect" budget actually measured time-to-response-headers, and the
+  server computes a multi-slot roster before its first byte, so preparation
+  died as a transport error. Workforce calls now use their own budget.
+- **Selection cycle rules match the Hub exactly.** Local validation only
+  checked handsOffTo/reportsTo, so a `reviews` cycle passed locally and came
+  back as a Hub rejection. All relations and self-edges now count.
+- **A worker that exits non-zero reports its stdout tail too**, so a failure
+  whose stderr holds only unrelated warnings is no longer a dead end.
+
+Also in this release:
+
+- **Live narration**: a `workforce` run now prints the slot count and hub
+  menu size, the picked agent per slot by name, hub acceptance, each worker
+  as it starts, and the synthesis→verification transition.
+- **One name per feature across platforms**: `hep-network`, `hep-cloud`,
+  `hep-build`, `hep-call`, `hep-search`, `hep-upload`, `hep-storm`,
+  `hep-browser`, `hep-connect` now work as terminal commands, matching the
+  skill names used from Claude Code and Codex. The typo guard suggests them.
+
+## 1.0.2 — 2026-07-27
+
+Workforce execution-contract fixes. Every worker in a `workforce` run now
+knows its exact execution authority, and the run recovers honestly instead
+of shipping broken output:
+
+- Tool-less (no-authority) workers are told explicitly that zero tools are
+  granted and that the deliverable must be authored directly in the reply.
+  Previously a borrowed worker was silently stripped of tools, tried to
+  call them anyway, leaked raw tool-call markup into deliverables, and
+  produced empty output on content-type tasks.
+- Worker handoffs are gated: leaked tool-call markup or an empty
+  deliverable triggers exactly one corrective re-run with a repair
+  directive; a repeat violation stops the run honestly with
+  `worker_output_contract_violation` (never a silent cleanup).
+- A verifier rejection now triggers exactly one corrective synthesis pass
+  with the verifier's issues attached, then a re-verification. A second
+  rejection still fails honestly (`workforce_verification_failed`), now
+  reporting both attempts' issues.
+- Selection handoff graphs are validated locally for circular
+  handsOffTo/reportsTo chains, so the structured repair loop fixes a cyclic
+  task force before the Hub sees it (previously a `task_force_cycle`
+  round-trip rejection).
+- Failure display: verifier/server `issues` arrays are printed line by line
+  instead of being truncated inside a capped JSON blob.
+
 ## 1.0.1 — 2026-07-27
 
 - Fixes the two gates that failed on the v1.0.0 tag (never published):

package/engine/agentlas-workforce.cjs

@@ -33,6 +33,15 @@ const MAX_SLOTS = 32;
 const MAX_ASSIGNMENTS = 64;
 const MAX_MODEL_OUTPUT = 2 * 1024 * 1024;
 const MAX_STRUCTURED_MODEL_ATTEMPTS = 2;
+// 도구가 0개인 워커가 도구 호출을 시도하면 그 문법이 산출물에 그대로 남는다.
+// 속성 형태까지 요구해 산문에서 마크업을 "언급"만 한 경우의 오탐을 줄인다.
+const HANDOFF_TOOL_MARKUP_RE = /<(?:antml:)?invoke\s+name=|<(?:antml:)?parameter\s+name=|<\/(?:antml:)?(?:invoke|parameter)>|<(?:antml:)?function_calls>/i;
+
+function handoffContractViolation(text) {
+  if (HANDOFF_TOOL_MARKUP_RE.test(text)) return "tool_markup";
+  if (String(text).replace(/[\s`#*_>\-|:.~]+/g, "").length < 12) return "empty_deliverable";
+  return null;
+}
 const MAX_REPAIR_PRIOR_OUTPUT = 64 * 1024;
 const MAX_WORK_ORDER_REFINEMENTS = 2;
 const MAX_SEARCH_TRANSPORT_ATTEMPTS = 2;
@@ -91,7 +100,11 @@ const HUB_PATH_PATTERNS = [
   /(?:^|[\s"'`()\[\]{}=:,;])~[/\\](?=\S)/,
   /(?<![A-Za-z0-9])[A-Za-z]:[/\\](?=\S)/,
   /(?:^|[\s"'`()\[\]{}=:,;])\\\\[^\\/\s]+[\\/][^\\/\s]+/,
-  /(?<![A-Za-z0-9$])\/(?!\/|\s)(?:[^/\s"'`<>]+\/)*[^/\s"'`<>]+/,
+  // lookbehind가 ASCII만 제외하면 한글 단어 뒤 슬래시("진단/멱등키", "한국어/영어")가
+  // 절대경로로 오탐된다(2026-07-27 실측 — 한국어 워크오더 전멸 원인). 문자·숫자
+  // 전반(\p{L}\p{N})을 제외해 "A/B" 표기는 통과시키고, 공백·행머리 뒤 실제 경로는
+  // 그대로 잡는다.
+  /(?<![\p{L}\p{N}$])\/(?!\/|\s)(?:[^/\s"'`<>]+\/)*[^/\s"'`<>]+/u,
 ];
 const HUB_SECRET_PATTERNS = [
   ["provider_token", /\b(?:sk-[A-Za-z0-9_-]{20,}|gh[pousr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,})\b/],
@@ -1124,6 +1137,32 @@ function validateSelection(value, candidateSet, workOrder, identity, options = {
     if (!["reportsTo", "handsOffTo", "reviews", "coordinatesWith"].includes(edge.relation)) fail("selection_invalid", "selection edge relation is invalid");
     assertIds(edge.artifactKinds, "selection edge artifactKinds");
   }
+  // 엣지 사이클은 Hub validate가 task_force_cycle로 거절한다. 서버 규칙과 동일하게:
+  // 관계 종류 불문 모든 엣지 + 자기참조가 사이클이다(reviews 맞교환도 거절 —
+  // 2026-07-27 실측: handsOffTo만 검사하던 로컬 검증이 reviews 사이클을 통과시켜
+  // 서버 거절로 되돌아왔다). 로컬에서 먼저 걸어야 재시도 루프가 왕복 없이 교정한다.
+  {
+    const adjacency = new Map();
+    for (const edge of selection.edges) {
+      if (edge.fromSlot === edge.toSlot) {
+        fail("selection_invalid", `edges form a circular task force: ${edge.fromSlot} points at itself`);
+      }
+      if (!adjacency.has(edge.fromSlot)) adjacency.set(edge.fromSlot, []);
+      adjacency.get(edge.fromSlot).push(edge.toSlot);
+    }
+    const states = new Map();
+    const walk = (slot, trail) => {
+      const state = states.get(slot);
+      if (state === "done") return;
+      if (state === "visiting") {
+        fail("selection_invalid", `edges form a circular task force: ${[...trail, slot].join(" -> ")}`);
+      }
+      states.set(slot, "visiting");
+      for (const next of adjacency.get(slot) || []) walk(next, [...trail, slot]);
+      states.set(slot, "done");
+    };
+    for (const slot of adjacency.keys()) walk(slot, []);
+  }
   for (const releaseId of assertIds(selection.alternativesConsidered, "selection.alternativesConsidered")) {
     if (!maps.all.has(releaseId)) fail("selection_invalid", `alternative ${releaseId} was outside the candidate set`);
   }
@@ -1597,6 +1636,7 @@ function buildPrompts(task, identity) {
     `Exact direct Selection example: ${stableJson(selectionShape)}`,
     "decisionAuthor must contain exactly kind, modelId, and runtimeId. Every required slot must have exactly its cardinality in assignments. Every assignment must contain exactly slotId, an exact candidate agentReleaseId, and a non-empty reasonCodes array.",
     "edges, alternativesConsidered, and requestExpansionForSlots must be explicitly authored arrays. Every edge must contain exactly fromSlot, toSlot, relation (one of reportsTo|handsOffTo|reviews|coordinatesWith), and artifactKinds. The host will not add or normalize fields.",
+    "edges must form an acyclic directed graph regardless of relation — reviews and coordinatesWith count too, and a slot may never point at itself. Never author a circular chain (for example A reviews B while B reviews A); the Hub rejects circular task forces.",
   ].join("\n");
   const plannerSchemaRequirements = [
     `Return exactly one object: ${stableJson(plannerShape)}`,
@@ -2669,10 +2709,28 @@ function create(deps = {}) {
         workOrderInvocationId,
       };
 
+      // 실황 내레이션: 사용자는 "누가 소집됐고 지금 뭘 하는지"를 보면서 신뢰를
+      // 형성한다(2026-07-27 오너 요구). 결과에 영향 없는 표시 전용 — silent 존중.
+      if (!ctx.silent) {
+        const nameByRelease = new Map();
+        for (const slotRow of candidateSet.slots) {
+          for (const cand of slotRow.candidates) nameByRelease.set(cand.agentReleaseId, cand.name || cand.agentReleaseId);
+        }
+        const menuCount = candidateSet.slots.reduce((sum, slotRow) => sum + slotRow.candidates.length, 0);
+        ui.info(ui.lang === "ko"
+          ? `워크오더 ${workOrder.roleSlots.length}슬롯 · 허브 후보 ${menuCount}명 메뉴 수신`
+          : `work order: ${workOrder.roleSlots.length} slot(s) · hub menu of ${menuCount} candidates`);
+        for (const row of selection.assignments) {
+          ui.info(ui.lang === "ko"
+            ? `  선발 ${row.slotId} ← ${nameByRelease.get(row.agentReleaseId) || row.agentReleaseId}`
+            : `  picked ${row.slotId} ← ${nameByRelease.get(row.agentReleaseId) || row.agentReleaseId}`);
+        }
+      }
       const validationRaw = await hubStage("workforce.validate_selection", { workOrder, candidateSet, selection });
       validationReceipt = validateSelectionReceipt(validationRaw, selection, candidateSet, workOrder);
       benchmarkState.selectionValidation = validationReceipt;
       receipt.selectionReceiptId = validationReceipt.selectionReceiptId;
+      if (!ctx.silent) ui.info(ui.lang === "ko" ? "허브 검증 수락 — 번들 준비 중" : "hub validation accepted — preparing bundles");
 
       const preparedRaw = await hubStage("workforce.prepare_execution", { workOrder, candidateSet, selection, validationReceipt });
       ({ prepared, rosterByPair } = validatePreparedExecution(preparedRaw, workOrder, selection, candidateSet, validationReceipt));
@@ -2864,7 +2922,13 @@ function create(deps = {}) {
 
       const runPinnedInvocation = async ({ pinned, system, prompt, label, grantedToolIds, extra = {} }) => {
         const invocationId = `workforce-invocation:${crypto.randomUUID()}`;
-        const text = assertString(await runModel(runtime, system, prompt, {
+        // 워커는 도구 상태를 스스로 알 수 없다. 고지 없이 잠그면 존재하지 않는 도구를
+        // 부르다 호출 문법이 산출물에 그대로 새고, 코드 저장소 워크플로를 가정한 채
+        // 본 작업 없이 끝난다(2026-07-27 실측). 결정적 문자열만 사용(3-OS 바이트 패리티).
+        const authorityDirective = grantedToolIds.length
+          ? `EXECUTION AUTHORITY: only these exact granted tools exist for this invocation: ${grantedToolIds.join(", ")}. Every other tool, file, shell, or web access is unavailable; never emit a call to anything else.`
+          : "EXECUTION AUTHORITY: zero tools are granted to this invocation — no file system, no shell, no web, no MCP, no subagents. Never emit tool-call syntax or XML-like invocation markup, and never explore or wait for a workspace. Author the complete deliverable directly in this reply as plain text or markdown, using only the packet inputs provided.";
+        const text = assertString(await runModel(runtime, [system, authorityDirective].join("\n\n"), prompt, {
           ...modelContext,
           authorityMode: grantedToolIds.length ? "policy-filtered" : "no-authority",
           grantedToolIds,
@@ -2887,6 +2951,31 @@ function create(deps = {}) {
         };
       };
 
+      // 핸드오프 산출물 전용 게이트: 도구 마크업/빈 산출물이면 교정 지시로 1회 재실행,
+      // 재발 시 조용한 완화 대신 정직 정지(silent-default 금지 원칙).
+      const runHandoffInvocation = async (args) => {
+        const first = await runPinnedInvocation(args);
+        const violation = handoffContractViolation(first.text);
+        if (!violation) return first;
+        const repairDirective = violation === "tool_markup"
+          ? "HANDOFF REPAIR MODE: your previous reply contained raw tool-call markup, but no tools exist in this invocation. Rewrite the complete deliverable as plain text or markdown only, with zero tool-call syntax."
+          : "HANDOFF REPAIR MODE: your previous reply contained no usable deliverable. You have everything you need in the packet inputs; author the complete concrete handoff artifact now, directly in this reply.";
+        const retried = await runPinnedInvocation({
+          ...args,
+          system: [args.system, repairDirective].join("\n\n"),
+          extra: { ...(args.extra || {}), handoffContractRetry: violation },
+        });
+        const repeat = handoffContractViolation(retried.text);
+        if (repeat) {
+          fail("worker_output_contract_violation", `${args.label} kept violating the handoff contract (${repeat}) after one corrective retry`, {
+            violation: repeat,
+            firstViolation: violation,
+            label: args.label,
+          });
+        }
+        return retried;
+      };
+
       const runNestedManagerPlan = async ({ pinned, packet, grantedToolIds }) => {
         const graph = pinned.executionGraph;
         const exactWorkerIds = graph.workers.map((row) => row.id);
@@ -2933,6 +3022,7 @@ function create(deps = {}) {
           const packet = delegationPlan.packets[index];
           const pair = `${packet.slotId}\0${packet.agentReleaseId}`;
           const pinned = rosterByPair.get(pair);
+          if (!ctx.silent) ui.info(ui.lang === "ko" ? `  워커 실행 중: ${packet.slotId}` : `  worker running: ${packet.slotId}`);
           const capabilityBindings = bindingsByPair.get(pair) || [];
           const grantedToolIds = [...new Set(capabilityBindings.map((row) => row.toolId))].sort();
           const startedAt = nowIso(D.now);
@@ -2941,7 +3031,7 @@ function create(deps = {}) {
             let directInvocation = null;
             let nestedExecutionId = null;
             if (pinned.entityKind === "agent") {
-              const direct = await runPinnedInvocation({
+              const direct = await runHandoffInvocation({
                 pinned,
                 grantedToolIds,
                 label: `worker ${packet.packetId}`,
@@ -2962,7 +3052,7 @@ function create(deps = {}) {
               const manager = await runNestedManagerPlan({ pinned, packet, grantedToolIds });
               const graphWorkerOutputs = await Promise.all(pinned.executionGraph.workers.map(async (graphWorker, workerIndex) => {
                 const graphPacket = manager.plan.packets[workerIndex];
-                const invoked = await runPinnedInvocation({
+                const invoked = await runHandoffInvocation({
                   pinned,
                   grantedToolIds,
                   label: `nested worker ${graphWorker.id}`,
@@ -2978,7 +3068,7 @@ function create(deps = {}) {
                 });
                 return { graphWorker, graphPacket, text: invoked.text, invocation: invoked.invocation };
               }));
-              const managerSynthesis = await runPinnedInvocation({
+              const managerSynthesis = await runHandoffInvocation({
                 pinned,
                 grantedToolIds,
                 label: `nested manager synthesis ${packet.packetId}`,
@@ -3080,55 +3170,87 @@ function create(deps = {}) {
       if (rejectedWorker) throw rejectedWorker.reason;
 
       const synthesisAssignment = selection.assignments.find((row) => row.slotId === delegationPlan.synthesis.slotId && row.agentReleaseId === delegationPlan.synthesis.agentReleaseId);
-      const synthesisStarted = nowIso(D.now);
-      const synthesisInvocationId = `workforce-invocation:${crypto.randomUUID()}`;
-      const finalText = assertString(await runModel(runtime, [
-        "You are the top-level host LLM synthesizer for this immutable Agentlas workforce run.",
-        "Integrate the separate worker handoffs into one coherent deliverable. Preserve disagreements and explicitly name incomplete work. Do not claim a tool or worker ran unless its handoff is present.",
-      ].join("\n\n"), stableJson({ workOrder, synthesis: delegationPlan.synthesis, handoffs: outputs }), modelContext), "synthesis output", 1_000_000);
-      receipt.synthesis = {
-        schemaVersion: "agentlas.workforce-synthesis-receipt.v1",
-        receiptId: synthesisInvocationId,
-        invocationId: synthesisInvocationId,
-        modelId: identity.modelId,
-        runtimeId: identity.runtimeId,
-        provider,
-        status: "completed",
-        agentReleaseId: synthesisAssignment.agentReleaseId,
-        startedAt: synthesisStarted,
-        completedAt: nowIso(D.now),
-        inputChildReceiptIds: receipt.workers.filter((row) => row.status === "completed").map((row) => row.receiptId),
-        outputDigest: sha256(finalText),
-      };
-
       const verifierAssignment = selection.assignments.find((row) => row.slotId === delegationPlan.verifier.slotId && row.agentReleaseId === delegationPlan.verifier.agentReleaseId);
-      const verifierStarted = nowIso(D.now);
-      const verifierInvocationId = `workforce-invocation:${crypto.randomUUID()}`;
-      const verifierRaw = await runModel(runtime, [
-        "You are the top-level host LLM verifier for this Agentlas workforce run.",
-        'Evaluate the synthesis against every criterion and worker handoff. Return exactly one JSON object: {"schemaVersion":"agentlas.workforce-verification.v1","status":"passed|failed","checks":[{"checkId":"check:<id>","status":"passed|failed","evidence":"..."}],"issues":[]}.',
-        "Use double-quoted valid JSON. Passing requires evidence for every criterion; do not rubber-stamp.",
-      ].join("\n\n"), stableJson({ workOrder, criteria: delegationPlan.verifier.criteria, handoffs: outputs, synthesis: finalText }), modelContext);
-      const verification = validateVerifierResult(parseModelObject(verifierRaw, "workforce verifier"));
-      receipt.verifier = {
-        schemaVersion: "agentlas.workforce-verifier-receipt.v1",
-        receiptId: verifierInvocationId,
-        invocationId: verifierInvocationId,
-        modelId: identity.modelId,
-        runtimeId: identity.runtimeId,
-        provider,
-        status: "completed",
-        agentReleaseId: verifierAssignment.agentReleaseId,
-        startedAt: verifierStarted,
-        completedAt: nowIso(D.now),
-        inputSynthesisReceiptId: receipt.synthesis.receiptId,
-        outputDigest: sha256(verification),
-        result: verification,
-        verdict: verification.status === "passed" ? "pass" : "fail",
-      };
+      // 검증자가 불합격을 내면 그 지적을 들고 합성을 1회 교정 후 재검증한다.
+      // 첫 시도의 영수증도 correctiveHistory로 보존한다(감사 추적 진실성).
+      let finalText = null;
+      let verification = null;
+      let synthesisInvocationId = null;
+      let verifierInvocationId = null;
+      let priorAttempt = null;
+      receipt.correctiveHistory = [];
+      if (!ctx.silent) ui.info(ui.lang === "ko" ? "합성 → 검증 단계" : "synthesis → verification");
+      for (let verifyAttempt = 1; verifyAttempt <= 2; verifyAttempt += 1) {
+        const synthesisStarted = nowIso(D.now);
+        synthesisInvocationId = `workforce-invocation:${crypto.randomUUID()}`;
+        finalText = assertString(await runModel(runtime, [
+          "You are the top-level host LLM synthesizer for this immutable Agentlas workforce run.",
+          "Integrate the separate worker handoffs into one coherent deliverable. Preserve disagreements and explicitly name incomplete work. Do not claim a tool or worker ran unless its handoff is present.",
+          verifyAttempt > 1 ? "CORRECTIVE SYNTHESIS MODE: a pinned verifier rejected the prior synthesis. Repair the deliverable so every criterion is satisfied using only the existing worker handoffs. Never invent work that did not run." : "",
+        ].filter(Boolean).join("\n\n"), stableJson(verifyAttempt > 1
+          ? { workOrder, synthesis: delegationPlan.synthesis, handoffs: outputs, priorSynthesis: priorAttempt.text, verifierRejection: priorAttempt.verification }
+          : { workOrder, synthesis: delegationPlan.synthesis, handoffs: outputs }), modelContext), "synthesis output", 1_000_000);
+        receipt.synthesis = {
+          schemaVersion: "agentlas.workforce-synthesis-receipt.v1",
+          receiptId: synthesisInvocationId,
+          invocationId: synthesisInvocationId,
+          modelId: identity.modelId,
+          runtimeId: identity.runtimeId,
+          provider,
+          status: "completed",
+          agentReleaseId: synthesisAssignment.agentReleaseId,
+          startedAt: synthesisStarted,
+          completedAt: nowIso(D.now),
+          inputChildReceiptIds: receipt.workers.filter((row) => row.status === "completed").map((row) => row.receiptId),
+          outputDigest: sha256(finalText),
+          attempt: verifyAttempt,
+        };
+
+        const verifierStarted = nowIso(D.now);
+        verifierInvocationId = `workforce-invocation:${crypto.randomUUID()}`;
+        const verifierRaw = await runModel(runtime, [
+          "You are the top-level host LLM verifier for this Agentlas workforce run.",
+          'Evaluate the synthesis against every criterion and worker handoff. Return exactly one JSON object: {"schemaVersion":"agentlas.workforce-verification.v1","status":"passed|failed","checks":[{"checkId":"check:<id>","status":"passed|failed","evidence":"..."}],"issues":[]}.',
+          "Use double-quoted valid JSON. Passing requires evidence for every criterion; do not rubber-stamp.",
+        ].join("\n\n"), stableJson({ workOrder, criteria: delegationPlan.verifier.criteria, handoffs: outputs, synthesis: finalText }), modelContext);
+        verification = validateVerifierResult(parseModelObject(verifierRaw, "workforce verifier"));
+        receipt.verifier = {
+          schemaVersion: "agentlas.workforce-verifier-receipt.v1",
+          receiptId: verifierInvocationId,
+          invocationId: verifierInvocationId,
+          modelId: identity.modelId,
+          runtimeId: identity.runtimeId,
+          provider,
+          status: "completed",
+          agentReleaseId: verifierAssignment.agentReleaseId,
+          startedAt: verifierStarted,
+          completedAt: nowIso(D.now),
+          inputSynthesisReceiptId: receipt.synthesis.receiptId,
+          outputDigest: sha256(verification),
+          result: verification,
+          verdict: verification.status === "passed" ? "pass" : "fail",
+          attempt: verifyAttempt,
+        };
+        if (verification.status === "passed") break;
+        if (verifyAttempt === 1) {
+          priorAttempt = { text: finalText, verification };
+          receipt.correctiveHistory.push({
+            synthesisReceiptId: synthesisInvocationId,
+            verifierReceiptId: verifierInvocationId,
+            synthesisOutputDigest: sha256(finalText),
+            verification,
+          });
+        }
+      }
 
       receipt.benchmarkAudit = auditBenchmarkReceipt(receipt);
-      if (verification.status !== "passed") fail("workforce_verification_failed", "pinned verifier rejected the synthesis", { issues: verification.issues });
+      if (verification.status !== "passed") {
+        fail("workforce_verification_failed", "pinned verifier rejected the synthesis twice (initial and one corrective retry)", {
+          issues: verification.issues,
+          correctiveRetryUsed: true,
+          firstAttemptIssues: receipt.correctiveHistory[0]?.verification?.issues || [],
+        });
+      }
       if (ctx.benchmark === true && !receipt.benchmarkAudit.passed) fail("benchmark_receipt_incomplete", "benchmark mode requires planner, every child, synthesis, verifier, and no planner fallback", receipt.benchmarkAudit);
 
       receipt.status = "passed";
@@ -3236,10 +3358,20 @@ function create(deps = {}) {
       if (!ctx.silent) {
         // 서버/검증 거절 사유(details)는 영수증에만 남고 화면에서 누락되던 표시 결함 —
         // 정직 중계 원칙상 사유를 원문 그대로 병기한다(실사용 network 테스트에서 실증).
-        const detailText = receipt.failure.details
-          ? ` — ${JSON.stringify(receipt.failure.details).slice(0, 600)}`
+        // issues 배열은 JSON 캡에 잘리지 않도록 항목별로 온전히 표시한다.
+        const details = receipt.failure.details;
+        const issues = Array.isArray(details?.issues) ? details.issues : null;
+        const otherDetails = details && typeof details === "object" && !Array.isArray(details)
+          ? Object.fromEntries(Object.entries(details).filter(([key]) => key !== "issues"))
+          : details;
+        const detailText = otherDetails && (typeof otherDetails !== "object" || Object.keys(otherDetails).length)
+          ? ` — ${JSON.stringify(otherDetails).slice(0, 1_200)}`
           : "";
         ui.error(`${receipt.failure.code}: ${receipt.failure.message}${detailText}`);
+        if (issues) {
+          for (const issue of issues.slice(0, 16)) ui.error(`  - ${String(issue).slice(0, 400)}`);
+          if (issues.length > 16) ui.error(`  … ${issues.length - 16} more issues in the persisted receipt`);
+        }
       }
       return { ok: false, error: receipt.failure, receipt, benchmarkArtifactPath };
     }

package/engine/agentlas.cjs

@@ -127,7 +127,9 @@ function main() {
      */
     if (!agent && 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(commands.NOT_YET_PORTED || []);
+      const names = Object.keys(commands.COMMANDS)
+        .concat(Object.keys(commands.COMMAND_ALIASES || {}))
+        .concat(commands.NOT_YET_PORTED || []);
       const near = nearestCommands(token, names);
       const ko = ctx.lang === "ko";
       ctx.err(ko

package/engine/commands/index.cjs

@@ -103,9 +103,32 @@ const DESKTOP_ONLY_SURFACES = {
 // 무인자 호출이 프롬프트로 오라우팅되면 안 되는 명령 (smoke 가드 대상)
 const GUARDED_NO_ARG = new Set(["search", "install", "upload"]);
 
+// 플랫폼 간 이름 통일(오너 결정 2026-07-27): 클로드코드/코덱스에서 부르는 hep-*
+// 스킬명과 터미널 명령이 서로 다르면 사용자가 어느 표면에 있는지에 따라 이름을
+// 바꿔 써야 한다. 같은 기능은 어디서든 같은 이름으로 부른다.
+const COMMAND_ALIASES = {
+  "hep-network": "workforce",
+  network: "workforce",
+  "hep-cloud": "cloud",
+  "hep-build": "build",
+  "hep-call": "call",
+  "hep-search": "search",
+  "hep-upload": "upload",
+  "hep-storm": "storm",
+  "hep-browser": "browser",
+  "hep-connect": "connect",
+  "hep-local": "workforce",
+  "hep-hub": "search",
+};
+
+function resolveCommandName(cmd) {
+  return COMMAND_ALIASES[cmd] || cmd;
+}
+
 function dispatch(ctx, argv) {
-  const [cmd, ...rest] = argv;
-  if (!cmd) return null; // 엔진이 REPL로 진입
+  const [rawCmd, ...rest] = argv;
+  if (!rawCmd) return null; // 엔진이 REPL로 진입
+  const cmd = resolveCommandName(rawCmd);
 
   if (COMMANDS[cmd]) {
     return COMMANDS[cmd]().run(ctx, rest);
@@ -133,4 +156,4 @@ function dispatch(ctx, argv) {
   return undefined; // 알 수 없는 토큰 — 엔진이 에이전트 이름/프롬프트로 해석 시도
 }
 
-module.exports = { dispatch, COMMANDS, NOT_YET_PORTED, GUARDED_NO_ARG, DESKTOP_ONLY_SURFACES };
+module.exports = { dispatch, COMMANDS, COMMAND_ALIASES, resolveCommandName, NOT_YET_PORTED, GUARDED_NO_ARG, DESKTOP_ONLY_SURFACES };

package/engine/workforce/capture.cjs

@@ -359,7 +359,13 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
       const stdout = Buffer.concat(stdoutChunks).toString("utf8");
       const stderr = Buffer.concat(stderrChunks).toString("utf8");
       if (code && code !== 0) {
-        finishReject(new Error(`${kind} exited ${code}: ${stderr.slice(-500)}`));
+        // stderr가 경고문뿐이면 진짜 원인이 stdout(JSON 오류 응답 등)에 있을 수 있다 —
+        // 2026-07-27 실측: 워커 exit 1이 설정 경고 2줄만 남기고 원인 불명이 됐다.
+        // 두 스트림의 꼬리를 모두 싣는다.
+        const stdoutTail = stdout.trim().slice(-400);
+        finishReject(new Error(
+          `${kind} exited ${code}: ${stderr.slice(-500)}${stdoutTail ? `\n--- stdout tail ---\n${stdoutTail}` : ""}`,
+        ));
         return;
       }
       const raw = stdout.trim() || stderr.trim();

package/engine/workforce/deps.cjs

@@ -425,7 +425,13 @@ function buildWorkforceDeps(ctx = {}) {
     // v1과 동일: callHubTool은 주입하지 않는다. 워크포스 모듈 내부의 jsonrpc 경로가
     // 거절 코드 원문 전파·retryClass 계약을 소유하며, fetchHub는 버퍼드
     // {ok,status,headers,text} 어댑터 형태를 만족한다(3중 타임아웃 + 16MB 상한).
-    fetchHub: (url, init) => hubClient.fetchHub(url, init),
+    // 워크포스 전용 타임아웃: prepare_execution은 서버가 로스터 번들을 조립하는 동안
+    // 첫 바이트 없이 계산한다(1슬롯 실측 7.2s, 다슬롯은 그 배수). 기본 connect 15s는
+    // 실제로는 "응답 헤더까지"를 재므로 다슬롯 준비를 처형한다(2026-07-27 전송오류
+    // 2연속의 진범). 준비 상한을 여유 있게 준다 — idle/total 계약은 유지.
+    fetchHub: (url, init) => hubClient.fetchHub(url, init, {
+      timeoutConfig: { connectMs: 120_000, idleMs: 60_000, totalMs: 300_000 },
+    }),
     resolveRuntime: resolveWorkforceRuntime,
     captureRuntime: capture.captureRuntime,
     runApi: capture.runApi,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentlas",
-  "version": "1.0.1",
-  "description": "Agentlas agent terminal \u2014 chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
+  "version": "1.0.3",
+  "description": "Agentlas agent terminal — chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
   },