@amaster.ai/employee-runtime-connector 0.1.0-beta.15 → 0.1.0-beta.17

package/dist/amaster-runtime-daemon.mjs

@@ -286,6 +286,7 @@ function parseCodexJsonl(stdout) {
   let sessionId = null;
   let summary = "";
   let errorMessage = null;
+  let terminalEvent = null;
   const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
 
   for (const rawLine of String(stdout ?? "").split(/\r?\n/)) {
@@ -303,6 +304,7 @@ function parseCodexJsonl(stdout) {
       continue;
     }
     if (event.type === "turn.completed") {
+      terminalEvent = "completed";
       const eventUsage = asRecord(event.usage);
       usage.inputTokens = readNumber(eventUsage.input_tokens, usage.inputTokens);
       usage.cachedInputTokens = readNumber(eventUsage.cached_input_tokens, usage.cachedInputTokens);
@@ -314,12 +316,13 @@ function parseCodexJsonl(stdout) {
       continue;
     }
     if (event.type === "turn.failed") {
+      terminalEvent = "failed";
       const error = asRecord(event.error);
       errorMessage = readString(error.message) ?? errorMessage;
     }
   }
 
-  return { sessionId, summary, usage, errorMessage };
+  return { sessionId, summary, usage, errorMessage: terminalEvent === "completed" ? null : errorMessage };
 }
 
 function buildCodexErrorHaystack(input) {
@@ -1653,6 +1656,26 @@ function shouldPreserveExecutorJsonlForTranscript(executorKind, event) {
   return false;
 }
 
+// ---- bundled module: src/amaster-runtime-daemon/utf8-stream-decoder.mjs ----
+function createUtf8StreamDecoder(onText) {
+  const decoder = new StringDecoder("utf8");
+  let ended = false;
+
+  return {
+    write(chunk) {
+      if (ended) throw new Error("UTF-8 stream decoder received data after end");
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      onText(decoder.write(buffer), buffer.length);
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      const trailingText = decoder.end();
+      if (trailingText) onText(trailingText, 0);
+    },
+  };
+}
+
 // ---- bundled module: src/amaster-runtime-daemon/version-drift.mjs ----
 function normalizeRuntimeVersionText(value) {
   if (typeof value !== "string") return null;
@@ -2335,7 +2358,8 @@ import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync
 import { homedir, hostname } from "node:os";
 import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
-const CONNECTOR_VERSION = "0.1.0-beta.15";
+import { StringDecoder } from "node:string_decoder";
+const CONNECTOR_VERSION = "0.1.0-beta.17";
 const MAX_INFERRED_ARTIFACT_UPLOADS = 20;
 const MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
 const CHECKPOINT_TTL_MS = 24 * 60 * 60 * 1000;
@@ -3459,6 +3483,52 @@ function commandLegacyTaskDecompositionRequirement(command) {
   return legacyTaskDecompositionRequirement(asRecord(payload.contextSnapshot));
 }
 
+const TASK_DECOMPOSITION_MODES = new Set(["none", "required", "suggest_only"]);
+const TASK_DECOMPOSITION_SOURCE_TYPES = new Set([
+  "system_default",
+  "system_migration",
+  "operator",
+  "api",
+  "accepted_plan",
+  "workflow",
+]);
+
+function commandTaskDecompositionRequirement(command) {
+  const payload = asRecord(command.payload);
+  const context = asRecord(payload.contextSnapshot);
+  const envelope = asRecord(context.authorizationEnvelope);
+  const authority = readString(envelope.decompositionRequirementAuthority) ?? "shadow";
+  if (authority === "shadow") return commandLegacyTaskDecompositionRequirement(command);
+  if (authority !== "enforce") {
+    throw new Error(`Invalid typed decomposition requirement authority ${authority}`);
+  }
+  const requirement = asRecord(envelope.decompositionRequirement);
+  const source = asRecord(requirement.source);
+  const mode = readString(requirement.mode);
+  const sourceType = readString(source.type);
+  const sourceId = readString(source.id);
+  const sourceRevision = readString(source.revision);
+  const requirementKeys = Object.keys(requirement).sort().join(",");
+  const sourceKeys = Object.keys(source).sort().join(",");
+  if (
+    !TASK_DECOMPOSITION_MODES.has(mode)
+    || !TASK_DECOMPOSITION_SOURCE_TYPES.has(sourceType)
+    || !sourceId
+    || !sourceRevision
+    || requirementKeys !== "mode,source"
+    || sourceKeys !== "id,revision,type"
+  ) {
+    throw new Error("Candidate command requires one strict typed decomposition requirement");
+  }
+  return {
+    required: mode === "required",
+    suggested: mode === "suggest_only",
+    authorityMode: "enforce",
+    source: "typed_task_requirement",
+    sourceRef: { type: sourceType, id: sourceId, revision: sourceRevision, mode },
+  };
+}
+
 function normalizeAgentInstructionsFiles(bundle) {
   const files = asRecord(bundle.files);
   const selected = [];
@@ -3565,7 +3635,7 @@ function runtimeActionsInstruction(options = {}) {
     "Every request_confirmation and request_checkbox_confirmation should bind the concrete decision to payload.target using {type:\"custom\", key, label, revisionId} or the applicable issue_document target. Keep target.key stable for the same decision purpose and change target.revisionId only when the target content changes. Replace example target values with task-specific values. For a custom target with no business revision, use the current run id as revisionId. For an existing issue_document target, use only the exact current revision from task context and never invent a revision id. When the same runtime action batch first upserts the target issue document, omit target.revisionId; the connector binds the created revision before posting the confirmation.",
     "If the wake reason is issue_children_completed, treat the completed child tasks as already resolved blockers. Do not recreate blocker child tasks, do not repeat the first-run blocker plan, and do not create another review path unless new human input is truly required. Summarize the completed child work and use update_parent status done when no human review is needed.",
     "Use update_parent status done when no human review is needed. Prefer creating a pending review path such as request_confirmation, request_checkbox_confirmation, ask_user_questions, or suggest_tasks before status in_review; if a bare in_review update is emitted, AMaster will create a fallback request_confirmation before PATCH.",
-    "For create_child_task, do not create ownerless executable todo tasks. Set assigneeAgentId only when the target agent id came from the current AMaster task context or an agent_hire action in this same batch. Do not invent agent ids, role ids, or ids from another company. If you are unsure, omit assigneeAgentId and assigneeUserId; AMaster will assign the current executing agent for todo/in_progress children. Use backlog only when a task is intentionally unassigned.",
+    "For create_child_task, set a stable workKey for the business work, plus parentDependency required or informational. Do not create ownerless executable todo tasks. Set assigneeAgentId only when the target agent id came from the current AMaster task context or an agent_hire action in this same batch. Do not invent agent ids, role ids, or ids from another company. If you are unsure, omit assigneeAgentId and assigneeUserId; AMaster will assign the current executing agent for todo/in_progress children. An ownerless backlog child must set ownerDisposition intentionally_unassigned and ownerReason; null owner alone is not an auditable disposition.",
     "Create a child only for an independently executable residual work item. Do not create a nested child merely to prove that child creation works, and do not treat the current issue title as an instruction to recreate the issue itself. If the current child already embodies the requested test or work item, complete it directly.",
     "Every root create_child_task with status todo or in_progress must establish the parent disposition in the same batch. Set blockParentUntilDone true when the parent depends on that child. Only omit the wait when the same batch also closes the parent's independent scope with update_parent status done or cancelled. parentId alone is structural and never proves that the parent is waiting; missing both paths fails with delegated_parent_wait_required.",
     "Creating child tasks and delegating them to existing agents is task execution, not organization orchestration. Use assignee ids only from the current task context; server permissions still decide whether an assignment is allowed.",
@@ -3575,6 +3645,9 @@ function runtimeActionsInstruction(options = {}) {
     options.explicitDecompositionRequired
       ? "This standard task explicitly requires child task decomposition. The runtime action batch must include create_child_task or one suggest_tasks interaction unless child tasks already exist. A checklist in a comment or artifact is not decomposition. Create independently executable internal preparation tasks now. Use backlog for recorded work that should not start now, and use suggest_tasks for work that must wait for human approval. When a pending interaction is created, keep the parent in_review rather than in_progress or done."
       : "",
+    options.decompositionSuggested
+      ? "The typed task requirement suggests child task decomposition without making it a hard gate. Prefer create_child_task or suggest_tasks when decomposition materially helps; other valid mutations remain allowed."
+      : "",
     options.canOrchestrateOrganization
       ? "Pending-interaction batch gate: before emitting JSON, scan every agent_hire and create_child_task. Every co-batched hire must independently set executeBeforeConfirmation true; every create_child_task must independently be backlog, set executeBeforeConfirmation true, or move into suggest_tasks. blockParentUntilDone=false and a flagged assignee hire do not exempt a child. Otherwise move the hires to a later continuation and use suggest_tasks for work that must wait for acceptance. This applies to every pending interaction, including budget or business approval."
       : "Pending-interaction batch gate: before emitting JSON, scan every create_child_task. Every create_child_task must independently be backlog, set executeBeforeConfirmation true, or move into suggest_tasks. blockParentUntilDone=false does not exempt a child. Use suggest_tasks for work that must wait for acceptance.",
@@ -3607,7 +3680,7 @@ function runtimeActionsInstruction(options = {}) {
     "For create_interaction ask_user_questions, use continuationPolicy wake_assignee, never wake_assignee_on_accept, because answering questions does not produce accepted status. Every question requires 1-10 options; do not emit an open-text question without options. The UI provides an Other text answer alongside the declared options. Use payload {\"version\":1,\"title\":\"...\",\"questions\":[{\"id\":\"question_key\",\"prompt\":\"Question text\",\"selectionMode\":\"single\",\"required\":true,\"options\":[{\"id\":\"option_key\",\"label\":\"Option label\"}]}]}. Do not use question/options.value at the top level.",
     "For create_interaction request_confirmation, follow the complete example above and do not use options arrays.",
     "For create_interaction request_checkbox_confirmation, use payload {\"version\":1,\"prompt\":\"Select approved items\",\"options\":[{\"id\":\"option_key\",\"label\":\"Option label\"}],\"minSelected\":1,\"maxSelected\":2,\"acceptLabel\":\"确认\",\"rejectLabel\":\"调整\",\"target\":{\"type\":\"custom\",\"key\":\"approved-items\",\"label\":\"待批准项目\",\"revisionId\":\"v1\"}}.",
-    "For create_interaction suggest_tasks, use payload {\"version\":1,\"tasks\":[{\"clientKey\":\"task_key\",\"title\":\"Task title\",\"description\":\"Task description\",\"priority\":\"medium\"}]}.",
+    "For create_interaction suggest_tasks, use payload {\"version\":1,\"tasks\":[{\"clientKey\":\"task_key\",\"workKey\":\"stable_business_work_key\",\"title\":\"Task title\",\"description\":\"Task description\",\"priority\":\"medium\",\"ownerDisposition\":\"intentionally_unassigned\",\"ownerReason\":\"Why no owner is selected yet\",\"parentDependency\":\"informational\"}]}. Use ownerDisposition assigned_agent/assigned_user with the matching assignee id for required parent dependencies, or intentionally_unassigned with ownerReason only for informational work. parentDependency required creates a first-class parent blocker when accepted; informational does not.",
     "When a suggested task should start automatically after acceptance, set assigneeAgentId to an agent id from the current task context. Set assigneeUserId only when a known user must own the task. Omit both assignee fields only when the accepted task should remain intentionally unassigned in backlog. Never substitute a role name for an assignee id.",
     "An external input or human approval cannot exist only as free-text owner/next-step prose. Create a human-owned create_child_task with assigneeUserId and blockParentUntilDone=true (or another explicit interaction/dependency path), then keep the parent blocked or in_review until it resolves.",
     "Do not copy placeholder names, placeholder summaries, placeholder action arrays, or placeholder paths. Every title, body, role, idempotencyKey, artifact path, and task description must be specific to the current issue and company.",
@@ -3909,9 +3982,11 @@ function buildCommandPrompt(command, workspace, materializedAttachments = [], op
   const authorizationEnvelope = runtimeActionAuthorizationEnvelope(command);
   const canOrchestrateOrganization = canRuntimeAgentOrchestrateOrganization(context)
     && authorizationEnvelope.allowedActionClasses.has("organization_mutation");
-  const decompositionRequirement = commandLegacyTaskDecompositionRequirement(command);
+  const decompositionRequirement = commandTaskDecompositionRequirement(command);
   const explicitDecompositionRequired = decompositionRequirement.required
     && runtimeActionChildIssueSummaryEntries(command).length === 0;
+  const decompositionSuggested = decompositionRequirement.suggested === true
+    && runtimeActionChildIssueSummaryEntries(command).length === 0;
   const executingAgent = asRecord(context.paperclipExecutingAgent);
   const currentAgentAdapterType = readString(executingAgent.adapterType);
   const validatorContentTypes = runtimeAttachmentContentTypes(command);
@@ -3944,6 +4019,7 @@ function buildCommandPrompt(command, workspace, materializedAttachments = [], op
       canOrchestrateOrganization,
       currentAgentAdapterType,
       explicitDecompositionRequired,
+      decompositionSuggested,
       artifactVerifierCommands: options.artifactVerifierCommands,
       actionValidatorCommand,
       authorizationEnvelope,
@@ -4865,6 +4941,8 @@ function runExecutor(command, args, options) {
     let stoppedExitDrainTimer = null;
     let completionOutputDrainTimer = null;
     let piCompletionOutputLineBuffer = "";
+    let stdoutDecoder = null;
+    let stderrDecoder = null;
     const outputBytes = { stdout: 0, stderr: 0 };
     const maxOutputBytes = parsePositiveInteger(options.maxOutputBytes, 50 * 1024 * 1024);
     const maxRssMb = parsePositiveInteger(options.maxRssMb, 0);
@@ -4879,6 +4957,8 @@ function runExecutor(command, args, options) {
     const finish = (result) => {
       if (settled) return;
       settled = true;
+      stdoutDecoder?.end();
+      stderrDecoder?.end();
       if (timer) clearTimeout(timer);
       if (rssTimer) clearInterval(rssTimer);
       if (stopKillTimer) clearTimeout(stopKillTimer);
@@ -5001,21 +5081,25 @@ function runExecutor(command, args, options) {
       }, 1000);
       rssTimer.unref?.();
     }
-    child.stdout.on("data", (chunk) => {
-      const text = chunk.toString("utf8");
-      outputBytes.stdout += chunk.length;
+    stdoutDecoder = createUtf8StreamDecoder((text, byteLength) => {
+      outputBytes.stdout += byteLength;
       stdout = appendBounded(stdout, text);
-      options.onOutput?.("stdout", text, chunk.length);
+      options.onOutput?.("stdout", text, byteLength);
       maybeSchedulePiCompletionDrain(text);
       if (outputBytes.stdout > maxOutputBytes) killForOutputFlood("stdout");
     });
-    child.stderr.on("data", (chunk) => {
-      const text = chunk.toString("utf8");
-      outputBytes.stderr += chunk.length;
+    stderrDecoder = createUtf8StreamDecoder((text, byteLength) => {
+      outputBytes.stderr += byteLength;
       stderr = appendBounded(stderr, text);
-      options.onOutput?.("stderr", text, chunk.length);
+      options.onOutput?.("stderr", text, byteLength);
       if (outputBytes.stderr > maxOutputBytes) killForOutputFlood("stderr");
     });
+    child.stdout.on("data", (chunk) => {
+      if (!settled) stdoutDecoder.write(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (!settled) stderrDecoder.write(chunk);
+    });
     child.on("error", (err) => {
       finish({ exitCode: null, signal: null, timedOut: false, spawnError: err.message });
     });
@@ -6326,6 +6410,8 @@ function hashFileSha256(filePath) {
 }
 
 function runtimeChildActionFingerprint(action, issueId, parentIssueId) {
+  const workKey = readString(action.workKey);
+  if (workKey) return `amaster-work:${workKey}`;
   const explicit = readString(action.idempotencyKey);
   if (explicit) return explicit.slice(0, 220);
   const clientKey = readString(action.clientKey) ?? readString(action.key);
@@ -6916,10 +7002,14 @@ function normalizeRuntimeSuggestedTask(task, index) {
   const priority = normalizeRuntimeActionPriority(record.priority);
   return {
     clientKey: runtimeInteractionOptionId(record.clientKey ?? record.key ?? title, fallbackClientKey),
+    ...(readString(record.workKey) ? { workKey: readString(record.workKey) } : {}),
     title: title.slice(0, 240),
     ...(readString(record.description) ? { description: readString(record.description) } : {}),
     ...(readString(record.assigneeAgentId) ? { assigneeAgentId: readString(record.assigneeAgentId) } : {}),
     ...(readString(record.assigneeUserId) ? { assigneeUserId: readString(record.assigneeUserId) } : {}),
+    ...(readString(record.ownerDisposition) ? { ownerDisposition: readString(record.ownerDisposition) } : {}),
+    ...(readString(record.ownerReason) ? { ownerReason: readString(record.ownerReason) } : {}),
+    ...(readString(record.parentDependency) ? { parentDependency: readString(record.parentDependency) } : {}),
     ...(readString(record.projectId) ? { projectId: readString(record.projectId) } : {}),
     ...(readString(record.parentId) ? { parentId: readString(record.parentId) } : {}),
     ...(priority ? { priority } : {}),
@@ -7230,7 +7320,7 @@ const RUNTIME_ACTION_ALLOWED_FIELDS = new Map([
     "title", "description", "status", "priority", "assigneeAgentId", "assigneeUserId",
     "assigneeAgentClientKey", "agentClientKey", "blockParentUntilDone", "executeBeforeConfirmation",
     "clientKey", "idempotencyKey", "parentClientKey", "blockedByIssueIds", "blockedByClientKeys", "create_child_task",
-    "inputWorkProductIds",
+    "inputWorkProductIds", "workKey", "ownerDisposition", "ownerReason", "parentDependency",
   ])],
   ["agent_hire", new Set([
     "clientKey", "idempotencyKey", "key", "companyId", "role", "title", "icon", "reportsTo",
@@ -7514,11 +7604,42 @@ function assertRuntimeCreateInteractionPayload(kind, payload) {
     for (const [index, rawTask] of tasks.entries()) {
       const task = asRecord(rawTask);
       const clientKey = readString(task.clientKey);
+      const workKey = readString(task.workKey);
       const title = readString(task.title);
       assertRuntimeActionValid(clientKey && clientKey.length <= 120, `suggest_tasks payload tasks[${index}].clientKey is required`);
       assertRuntimeActionValid(!clientKeys.has(clientKey), `suggest_tasks payload tasks[${index}].clientKey must be unique`);
       clientKeys.add(clientKey);
+      assertRuntimeActionValid(workKey && workKey.length <= 120, `suggest_tasks payload tasks[${index}].workKey is required`);
       assertRuntimeActionValid(title && title.length <= 240, `suggest_tasks payload tasks[${index}].title is required`);
+      const ownerDisposition = readString(task.ownerDisposition);
+      const assigneeAgentId = readString(task.assigneeAgentId);
+      const assigneeUserId = readString(task.assigneeUserId);
+      assertRuntimeActionValid(
+        ["assigned_agent", "assigned_user", "intentionally_unassigned"].includes(ownerDisposition ?? ""),
+        `suggest_tasks payload tasks[${index}].ownerDisposition is required`,
+      );
+      assertRuntimeActionValid(
+        ownerDisposition !== "assigned_agent" || Boolean(assigneeAgentId),
+        `suggest_tasks payload tasks[${index}] assigned_agent requires assigneeAgentId`,
+      );
+      assertRuntimeActionValid(
+        ownerDisposition !== "assigned_user" || Boolean(assigneeUserId),
+        `suggest_tasks payload tasks[${index}] assigned_user requires assigneeUserId`,
+      );
+      assertRuntimeActionValid(
+        ownerDisposition !== "intentionally_unassigned"
+          || (!assigneeAgentId && !assigneeUserId && Boolean(readString(task.ownerReason))),
+        `suggest_tasks payload tasks[${index}] intentionally_unassigned requires ownerReason and forbids assignee ids`,
+      );
+      const parentDependency = readString(task.parentDependency);
+      assertRuntimeActionValid(
+        ["required", "informational"].includes(parentDependency ?? ""),
+        `suggest_tasks payload tasks[${index}].parentDependency is required`,
+      );
+      assertRuntimeActionValid(
+        ownerDisposition !== "intentionally_unassigned" || parentDependency !== "required",
+        "intentionally_unassigned work cannot be a required parent dependency",
+      );
     }
   }
 }
@@ -7655,7 +7776,7 @@ function assertDelegatedParentWaitDisposition(actions) {
 }
 
 function assertExplicitTaskDecomposition(command, actions) {
-  const requirement = commandLegacyTaskDecompositionRequirement(command);
+  const requirement = commandTaskDecompositionRequirement(command);
   if (!requirement.required) return;
   if (runtimeActionChildIssueSummaryEntries(command).length > 0) return;
   const hasDecompositionAction = actions.some((action) => {
@@ -7666,12 +7787,15 @@ function assertExplicitTaskDecomposition(command, actions) {
   });
   if (hasDecompositionAction) return;
   const error = new Error(
-    "task explicitly requires child task decomposition under the legacy text hard gate; emit create_child_task or suggest_tasks instead of only describing a checklist",
+    requirement.authorityMode === "enforce"
+      ? "task explicitly requires child task decomposition under the typed task requirement; emit create_child_task or suggest_tasks instead of only describing a checklist"
+      : "task explicitly requires child task decomposition under the legacy text hard gate; emit create_child_task or suggest_tasks instead of only describing a checklist",
   );
   error.runtimeActionType = "decomposition";
   error.runtimeActionReason = error.message;
   error.runtimeActionDecompositionRequirementSource = requirement.source;
   error.runtimeActionDecompositionMatch = requirement.match;
+  error.runtimeActionDecompositionSourceRef = requirement.sourceRef;
   throw error;
 }
 
@@ -7705,12 +7829,59 @@ function preflightRuntimeAction(action, preflightContext, actionIndex) {
   if (type === "create_child_task") {
     assertNoPlaceholderRuntimeActionText(fields, ["title", "description"]);
     assertRuntimeActionValid(readBoundedActionString(fields, "title", 240), "create_child_task action requires title");
+    if (fields.workKey !== undefined) {
+      assertRuntimeActionValid(Boolean(readString(fields.workKey)), "create_child_task workKey must be a non-empty string");
+    }
     if (fields.status !== undefined) {
       assertRuntimeActionValid(readActionStatus(fields.status), `create_child_task status is unsupported: ${String(fields.status)}`);
     }
     if (fields.priority !== undefined) {
       assertRuntimeActionValid(readActionPriority(fields.priority), `create_child_task priority is unsupported: ${String(fields.priority)}`);
     }
+    const childStatus = readActionStatus(fields.status) ?? "todo";
+    if (fields.parentDependency !== undefined) {
+      assertRuntimeActionValid(
+        ["required", "informational"].includes(readString(fields.parentDependency) ?? ""),
+        "create_child_task parentDependency must be required or informational",
+      );
+      assertRuntimeActionValid(
+        (readString(fields.parentDependency) === "required") === (fields.blockParentUntilDone === true || childStatus === "blocked"),
+        "create_child_task parentDependency must match blockParentUntilDone",
+      );
+    }
+    const ownerDisposition = readString(fields.ownerDisposition);
+    if (ownerDisposition) {
+      assertRuntimeActionValid(
+        ["assigned_agent", "assigned_user", "intentionally_unassigned"].includes(ownerDisposition),
+        "create_child_task ownerDisposition is unsupported",
+      );
+    }
+    if (
+      childStatus === "backlog"
+      && !readString(fields.assigneeAgentId)
+      && !readString(fields.assigneeUserId)
+      && !readString(fields.assigneeAgentClientKey)
+      && !readString(fields.agentClientKey)
+    ) {
+      assertRuntimeActionValid(
+        ownerDisposition === "intentionally_unassigned" && Boolean(readString(fields.ownerReason)),
+        "ownerless backlog create_child_task requires ownerDisposition intentionally_unassigned and ownerReason",
+      );
+    }
+    if (ownerDisposition === "intentionally_unassigned") {
+      assertRuntimeActionValid(
+        !readString(fields.assigneeAgentId)
+          && !readString(fields.assigneeUserId)
+          && !readString(fields.assigneeAgentClientKey)
+          && !readString(fields.agentClientKey)
+          && Boolean(readString(fields.ownerReason)),
+        "create_child_task intentionally_unassigned requires ownerReason and forbids assignee fields",
+      );
+      assertRuntimeActionValid(
+        readString(fields.parentDependency) !== "required",
+        "intentionally_unassigned work cannot be a required parent dependency",
+      );
+    }
     assertRuntimeActionValid(
       !readString(fields.assigneeAgentId) || (!readString(fields.assigneeAgentClientKey) && !readString(fields.agentClientKey)),
       "create_child_task action cannot combine assigneeAgentId with assigneeAgentClientKey/agentClientKey",
@@ -7915,6 +8086,41 @@ function preflightRuntimeActionBatch(actions, options = {}) {
   assertDelegatedParentWaitDisposition(actions);
   const orderedActions = orderRuntimeActionsByClientKeyDependencies(actions);
   const documentActionIndexByKey = new Map();
+  const workKeyOwner = new Map();
+  const hasSuggestedTaskProposal = orderedActions.some((action) => {
+    const fields = runtimeActionBusinessFields(action);
+    return readRuntimeActionType(fields) === "create_interaction" && inferCreateInteractionKind(fields) === "suggest_tasks";
+  });
+  for (const action of orderedActions) {
+    const fields = runtimeActionBusinessFields(action);
+    const actionIndex = actionIndexByObject.get(action);
+    if (hasSuggestedTaskProposal && readRuntimeActionType(fields) === "create_child_task") {
+      assertRuntimeActionValid(
+        Boolean(readString(fields.workKey)),
+        "create_child_task action requires workKey when the same batch also proposes suggest_tasks",
+      );
+    }
+    const entries = readRuntimeActionType(fields) === "create_child_task"
+      ? [{ workKey: readString(fields.workKey), fieldPath: `actions[${actionIndex}].workKey` }]
+      : readRuntimeActionType(fields) === "create_interaction" && inferCreateInteractionKind(fields) === "suggest_tasks"
+        ? (Array.isArray(asRecord(fields.payload).tasks) ? asRecord(fields.payload).tasks : []).map((task, taskIndex) => ({
+            workKey: readString(asRecord(task).workKey),
+            fieldPath: `actions[${actionIndex}].payload.tasks[${taskIndex}].workKey`,
+          }))
+        : [];
+    for (const entry of entries) {
+      if (!entry.workKey) continue;
+      const priorPath = workKeyOwner.get(entry.workKey);
+      if (priorPath) {
+        const err = runtimeActionValidationError(
+          `workKey ${entry.workKey} appears more than once in the runtime action batch (${priorPath}, ${entry.fieldPath})`,
+        );
+        err.runtimeActionFieldPath = entry.fieldPath;
+        throw err;
+      }
+      workKeyOwner.set(entry.workKey, entry.fieldPath);
+    }
+  }
   for (const action of orderedActions) {
     if (readRuntimeActionType(action) !== "upsert_document") continue;
     const key = readBoundedActionString(runtimeActionBusinessFields(action), "key", 64);
@@ -8227,7 +8433,7 @@ async function applyRuntimeAction(config, command, runtimeAuth, issueId, action,
         ? { inputWorkProductIds: fields.inputWorkProductIds.map(readString).filter(Boolean) }
         : {}),
       blockParentUntilDone,
-      originKind: "amaster_runtime_child_task",
+      originKind: readString(fields.workKey) ? "amaster_runtime_work" : "amaster_runtime_child_task",
       originId: issueId,
       originRunId: runId,
       originFingerprint,
@@ -9090,6 +9296,9 @@ function runtimeActionDiagnostics(err, options = {}) {
     ...(err?.runtimeActionDecompositionMatch
       ? { decompositionMatch: err.runtimeActionDecompositionMatch }
       : {}),
+    ...(err?.runtimeActionDecompositionSourceRef
+      ? { decompositionSourceRef: err.runtimeActionDecompositionSourceRef }
+      : {}),
     ...(err?.runtimeActionInferenceTrace ? { inferenceTrace: err.runtimeActionInferenceTrace } : {}),
     ...(readString(err?.runtimeActionFieldPath) ? { fieldPath: readString(err.runtimeActionFieldPath) } : {}),
     ...(readString(err?.runtimeActionReceivedType) ? { receivedType: readString(err.runtimeActionReceivedType) } : {}),
@@ -9474,6 +9683,11 @@ function assertRuntimeMarkdownSourceTruth(sourceTruthValue, fieldPath, filePath)
   const allowedFields = new Set(["status", "reason", "sources", "unverifiedClaims"]);
   for (const field of Object.keys(sourceTruth)) {
     if (!allowedFields.has(field)) {
+      if (field === "assumptions") {
+        throw runtimeDeliverableError(
+          `${fieldPath}.assumptions is unsupported; use ${fieldPath}.unverifiedClaims instead`,
+        );
+      }
       throw runtimeDeliverableError(`${fieldPath}.${field} is unsupported`);
     }
   }

package/dist/amaster-runtime.mjs

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.0-beta.15";
+const CONNECTOR_VERSION = "0.1.0-beta.17";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.0-beta.15",
+  "version": "0.1.0-beta.17",
   "description": "AMaster Employee runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",
@@ -15,6 +15,8 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "clean": "node scripts/clean.mjs",
+    "phase0b:live": "node probes/runtime-v2-phase0b/live-probe.mjs",
+    "phase0b:test": "node --test probes/runtime-v2-phase0b/*.test.mjs",
     "typecheck": "node --check scripts/build.mjs && node --check scripts/bundle.mjs && node --check src/amaster-runtime.mjs && node --check src/amaster-runtime-daemon.mjs",
     "test": "pnpm run build && node --test test/*.test.mjs src/amaster-runtime-daemon/*.test.mjs",
     "prepack": "pnpm run test"