@amaster.ai/employee-runtime-connector 0.1.1-beta.33 → 0.1.1-beta.35

package/dist/amaster-runtime-daemon.mjs

@@ -4641,6 +4641,95 @@ function continuationText(context) {
   if (!body) return "";
   return [readString(summary.title), body].filter(Boolean).join("\n");
 }
+function taskAcceptanceContractError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+function formalTaskAcceptanceContractRequired(context) {
+  const requirements = asRecord(asRecord(context.paperclipIssue).taskRequirements);
+  return requirements.requirementsVersion === "v2" && asRecord(requirements.taskIntent).intent === "business" && asRecord(requirements.admission).state === "active";
+}
+function sameCanonicalJson(left, right) {
+  return JSON.stringify(canonicalJsonValue(left)) === JSON.stringify(canonicalJsonValue(right));
+}
+function taskAcceptanceContractSection(context, input) {
+  const required = formalTaskAcceptanceContractRequired(context);
+  const contract = asRecord(context.taskAcceptanceContract);
+  if (Object.keys(contract).length === 0) {
+    if (required) {
+      throw taskAcceptanceContractError(
+        "task_acceptance_contract_unavailable",
+        "Formal Business Task dispatch requires a Server-owned Task Acceptance Contract"
+      );
+    }
+    return null;
+  }
+  const companyId = readString(asRecord(context.paperclipCompany).id);
+  const issueId = readString(input.issueId);
+  if (companyId && readString(contract.company_id) !== companyId || issueId && readString(contract.issue_id) !== issueId) {
+    throw taskAcceptanceContractError(
+      "task_acceptance_contract_scope_mismatch",
+      "Task Acceptance Contract does not match the current Company and Issue scope"
+    );
+  }
+  const enrollment = asRecord(contract.enrollment);
+  const delivery = asRecord(contract.delivery);
+  const acceptance = asRecord(contract.acceptance);
+  const criteria = Array.isArray(contract.acceptance_criteria) ? contract.acceptance_criteria.map(asRecord) : [];
+  const allowedKinds = Array.isArray(delivery.allowed_kinds) ? delivery.allowed_kinds.map(readString).filter(Boolean) : [];
+  const acceptanceContracts = Array.isArray(delivery.acceptance_contracts) ? delivery.acceptance_contracts : [];
+  const requirementRevision = readString(enrollment.requirement_revision);
+  const sourceRef = readString(contract.source_ref);
+  const validCriteria = criteria.length > 0 && criteria.every((criterion) => readString(criterion.ref) && readString(criterion.text));
+  const validIdentity = readString(contract.schema_version) === "mirrorx.task-acceptance-contract.v1" && readString(contract.company_id) && readString(contract.issue_id) && Number.isInteger(contract.execution_epoch) && readString(contract.observed_at) && readString(enrollment.id) && Number.isInteger(enrollment.revision) && requirementRevision && readString(enrollment.request_hash) && sourceRef === `business_task_enrollment:${readString(enrollment.id)}@${requirementRevision}`;
+  const validDelivery = allowedKinds.length > 0 && new Set(allowedKinds).size === allowedKinds.length && (delivery.contract_state === "explicit_typed" || delivery.contract_state === "acceptance_refs_only") && (delivery.contract_state !== "explicit_typed" || acceptanceContracts.length > 0);
+  const validAcceptance = readString(acceptance.owner_agent_id) && Object.keys(asRecord(acceptance.policy)).length > 0 && readString(acceptance.expected_outcome_at);
+  if (!validIdentity || !validCriteria || !validDelivery || !validAcceptance) {
+    throw taskAcceptanceContractError(
+      "task_acceptance_contract_invalid",
+      "Task Acceptance Contract is incomplete or internally inconsistent"
+    );
+  }
+  const requirements = asRecord(asRecord(context.paperclipIssue).taskRequirements);
+  if (required) {
+    const requirementDelivery = asRecord(requirements.delivery);
+    const requirementOutcome = asRecord(requirements.businessOutcome);
+    const criterionRefs = criteria.map((criterion) => readString(criterion.ref));
+    const requirementAcceptanceRefs = Array.isArray(requirementDelivery.acceptanceRefs) ? requirementDelivery.acceptanceRefs.map(readString).filter(Boolean) : [];
+    const requirementAllowedKinds = Array.isArray(requirementDelivery.allowedKinds) ? requirementDelivery.allowedKinds.map(readString).filter(Boolean) : [];
+    const requirementContracts = Array.isArray(requirementDelivery.acceptanceContracts) ? requirementDelivery.acceptanceContracts : [];
+    const revisionsMatch = [
+      asRecord(requirementDelivery.source),
+      asRecord(requirementOutcome.source)
+    ].every((source) => readString(source.revision) === requirementRevision);
+    if (!revisionsMatch || !sameCanonicalJson(criterionRefs, requirementAcceptanceRefs) || !sameCanonicalJson(allowedKinds, requirementAllowedKinds) || !sameCanonicalJson(acceptanceContracts, requirementContracts) || readString(requirementOutcome.acceptanceOwnerAgentId) !== readString(acceptance.owner_agent_id) || readString(requirementOutcome.expectedOutcomeAt) !== readString(acceptance.expected_outcome_at) || !sameCanonicalJson(requirementOutcome.acceptancePolicy, acceptance.policy)) {
+      throw taskAcceptanceContractError(
+        "task_acceptance_contract_invalid",
+        "Task Acceptance Contract does not match the active Task requirement projection"
+      );
+    }
+  }
+  return {
+    content: [
+      "This is the immutable Server-owned acceptance authority for the current execution epoch. Treat every criterion ref and text as exact; do not replace it with the Issue description, a summary, a historical task, or your own interpretation.",
+      "Plan and verify delivery against every criterion. Delivery evidence does not itself grant acceptance; follow the declared Acceptance policy and current Server-owned Outcome path.",
+      "If this contract conflicts with another prompt section or becomes stale after a CAS conflict, re-read the same exact contract through the Governed Business State detail_read rendered for this Issue. Do not guess from an opaque ref.",
+      jsonText(contract)
+    ].join("\n"),
+    sourceRef,
+    observedAt: readString(contract.observed_at),
+    freshness: {
+      kind: "immutable_enrollment",
+      requirementRevision,
+      executionEpoch: contract.execution_epoch
+    },
+    scope: {
+      companyId: readString(contract.company_id),
+      issueId: readString(contract.issue_id)
+    }
+  };
+}
 function governedReadSection(context) {
   const reads = Array.isArray(context.governedReadResults) ? context.governedReadResults : [];
   if (reads.length === 0) return { content: "", provenance: [] };
@@ -4697,40 +4786,48 @@ function governedBusinessDetailRead(input, issueId) {
     return { mode: "unavailable", canonical_tool: canonicalTool, reason: "not_in_run_catalog" };
   }
   if (input.executorKind === "pi" && managedPiMcpProxyAvailable(input)) {
-    return {
-      mode: "mcp_proxy",
-      server: "amaster",
-      tool: canonicalTool,
-      args: JSON.stringify(argumentsValue)
-    };
+    return { mode: "mcp_proxy", ...managedPiMcpProxyCall(canonicalTool, argumentsValue) };
   }
   return { mode: "canonical", tool: canonicalTool, arguments: argumentsValue };
 }
 function governedBusinessDecisionProjection(state, detailRead) {
   const record6 = asRecord(state);
   const snapshot = asRecord(record6.governed_state_snapshot);
-  const enrollment = asRecord(snapshot.business_task_enrollment);
   const authoritativeObjectRefs = Array.isArray(record6.authoritative_object_refs) ? record6.authoritative_object_refs : [];
-  const enrollmentRef = authoritativeObjectRefs.find((entry) => readString(asRecord(entry).object_kind) === "business_task_enrollment");
-  const snapshotId = readString(snapshot.snapshot_id);
-  const generatedAt = readString(snapshot.generated_at);
+  const capabilities = Array.isArray(record6.capabilities) ? record6.capabilities : [];
+  const availability = asRecord(record6.availability);
   const projection = {
-    availability: record6.availability,
-    capabilities: Array.isArray(record6.capabilities) ? record6.capabilities : [],
-    missing_objects: Array.isArray(record6.missing_objects) ? record6.missing_objects : [],
-    authoritative_object_refs: authoritativeObjectRefs,
-    snapshot: {
-      ref: snapshotId ? `governed_state:${snapshotId}` : null,
-      observed_at: generatedAt ?? null
-    },
+    status: readString(availability.status) ?? null,
+    objects: authoritativeObjectRefs.map((entry) => {
+      const object = asRecord(entry);
+      const compact = {
+        kind: readString(object.object_kind) ?? null,
+        ref: readString(object.ref) ?? null,
+        status: readString(object.status) ?? null
+      };
+      if (typeof object.revision === "string" || typeof object.revision === "number") {
+        compact.revision = object.revision;
+      }
+      return compact;
+    }),
+    missing: (Array.isArray(record6.missing_objects) ? record6.missing_objects : []).map((entry) => {
+      const missing = asRecord(entry);
+      return {
+        kind: readString(missing.object_kind) ?? null,
+        state: readString(missing.instance_state) ?? null,
+        reason_code: readString(missing.reason_code) ?? null,
+        next_owner: readString(missing.next_owner) ?? null
+      };
+    }),
+    unsupported: capabilities.filter((entry) => readString(asRecord(entry).object_kind_support) === "unsupported").map((entry) => readString(asRecord(entry).object_kind)).filter(Boolean),
+    observed_at: readString(snapshot.generated_at) ?? null,
     detail_read: detailRead
   };
-  if (Object.keys(enrollment).length > 0) {
-    projection.business_task_enrollment = {
-      state: readString(enrollment.state) ?? null,
-      authoritative_ref: readString(asRecord(enrollmentRef).ref) ?? null,
-      finding: enrollment.finding ?? null
-    };
+  const reasonCode = readString(availability.reason_code);
+  if (reasonCode) projection.reason_code = reasonCode;
+  const unavailableReads = capabilities.filter((entry) => readString(asRecord(entry).read_capability) === "unavailable").map((entry) => readString(asRecord(entry).object_kind)).filter(Boolean);
+  if (unavailableReads.length > 0) {
+    projection.unavailable_reads = unavailableReads;
   }
   const continuationId = readString(record6.continuation_id);
   if (continuationId) projection.continuation_id = continuationId;
@@ -4747,9 +4844,10 @@ function governedBusinessModelView(state, input) {
     readString(snapshot.issue_id) ?? readString(input.issueId)
   );
   if (detailRead.mode === "unavailable") {
+    const { task_acceptance_contract: _TaskAcceptanceContract, ...stateWithoutAcceptanceContract } = record6;
     return {
       mode: "full_snapshot",
-      content: record6,
+      content: stateWithoutAcceptanceContract,
       unavailableReason: detailRead.reason
     };
   }
@@ -4776,17 +4874,22 @@ function governedBusinessStateSection(context, input) {
   const currentView = Object.keys(current).length > 0 ? governedBusinessModelView(current, input) : null;
   const resumeView = Object.keys(resume).length > 0 ? governedBusinessModelView(resume, input) : null;
   const retainsFullSnapshot = [currentView, resumeView].some((view) => view?.mode === "full_snapshot");
+  const governedStates = [current, resume].filter((state) => Object.keys(state).length > 0);
+  const hasUnsupportedObjects = governedStates.some((state) => Array.isArray(state.capabilities) && state.capabilities.some((entry) => readString(asRecord(entry).object_kind_support) === "unsupported"));
+  const hasUnavailableRead = governedStates.some((state) => readString(asRecord(state.availability).status) === "unavailable" || Array.isArray(state.capabilities) && state.capabilities.some((entry) => readString(asRecord(entry).read_capability) === "unavailable"));
+  const hasMissingObjects = governedStates.some((state) => Array.isArray(state.missing_objects) && state.missing_objects.length > 0);
+  const hasFreeTextReason = governedStates.some((state) => Boolean(readString(state.free_text_reason)));
+  const hasChildIssues = Array.isArray(context.childIssueSummaries) && context.childIssueSummaries.length > 0;
   const rules = [
     "This is bounded Server-owned read-side truth. It does not grant mutation authority and it is not a Delivery Manifest claim.",
-    "Recommendation, First Business Activation, and Business Task Enrollment may be described as created/submitted/activated/enrolled only when authoritative_object_refs contains the exact matching Server ref. Issue and Document are not Business Task Enrollment.",
-    "Pipeline is unsupported as a governed object. You may create or update a clearly labeled tracker/document, but never claim a formal Pipeline record or receipt.",
-    "For parent aggregation, read Server-owned governed state; never accept child final prose, an Issue, or a Document as a formal object receipt.",
-    "A read capability marked unavailable does not prove an instance is absent. A write capability marked unavailable does not prove the object kind is unsupported.",
-    "When availability.status or a required read capability is unavailable, unrelated work may continue, but formal-object completion claims must remain fail-closed until a managed read succeeds.",
-    "When a required formal object is missing or the current Runtime lacks its legal producer, keep the task incomplete and name missing_objects.reason_code plus next_owner. Board review remains independent final acceptance.",
-    "free_text_reason is explanatory only and is not authority; resolve any conflict in favor of the structured Server-owned state.",
+    "Recommendation, First Business Activation, and Business Task Enrollment may be claimed only when the supplied state contains the exact matching Server ref. Issue and Document are not Business Task Enrollment.",
+    hasUnsupportedObjects ? "An object kind listed under unsupported has no governed record type. You may create or update a clearly labeled tracker/document, but never claim a formal record or receipt for that kind." : null,
+    hasChildIssues ? "For parent aggregation, read Server-owned governed state; never accept child final prose, an Issue, or a Document as a formal object receipt." : null,
+    hasUnavailableRead ? "An unavailable read does not prove an instance is absent. Unrelated work may continue, but formal-object completion claims must remain fail-closed until a managed read succeeds." : null,
+    hasMissingObjects ? "When a required formal object is listed under missing, keep the task incomplete and report its reason_code plus next_owner." : null,
+    hasFreeTextReason ? "free_text_reason is explanatory only and is not authority; resolve any conflict in favor of the structured Server-owned state." : null,
     retainsFullSnapshot ? "No executable managed detail read is available for at least one state below, so its bounded full snapshot remains inline. Do not guess a tool name or claim that omitted state can be fetched." : "The default body is a decision projection, not the complete process ledger. Use detail_read only when the current task needs omitted diagnosis, recommendation, activation, enrollment, or dispatch details."
-  ].join("\n");
+  ].filter(Boolean).join("\n");
   const bodies = [
     currentView ? currentView.mode === "decision_projection" ? `Current dispatch decision projection:
 ${stringifyBoundedJson(currentView.content, 24e3)}` : `Current dispatch bounded full snapshot (managed detail read unavailable: ${currentView.unavailableReason}):
@@ -4939,11 +5042,7 @@ function resolvedDependencySections(context, input, contextScope, snapshotFreshn
     ...tuples.flatMap((tuple, index) => {
       const readArguments = { issueId: tuple.blockerSelector, key: tuple.key };
       const directToolName = managedDirectToolName(input, "amaster.read_issue_document");
-      const call = directToolName ? readArguments : input.executorKind === "pi" && managedPiMcpProxyAvailable(input) ? {
-        server: "amaster",
-        tool: "amaster.read_issue_document",
-        args: JSON.stringify(readArguments)
-      } : readArguments;
+      const call = directToolName ? readArguments : input.executorKind === "pi" && managedPiMcpProxyAvailable(input) ? managedPiMcpProxyCall("amaster.read_issue_document", readArguments) : readArguments;
       return [
         `- Required read ${index + 1}: issue ${JSON.stringify(tuple.blockerSelector)}${tuple.blockerId ? ` (id ${JSON.stringify(tuple.blockerId)})` : ""}; document ${JSON.stringify(tuple.documentId)}; key ${JSON.stringify(tuple.key)}; expected latestRevisionId ${JSON.stringify(tuple.expectedLatestRevisionId)}${tuple.expectedLatestRevisionNumber != null ? `; revisionNumber ${tuple.expectedLatestRevisionNumber}` : ""}.`,
         directToolName ? `  Call \`${directToolName}\` with these exact object arguments: ${JSON.stringify(call)}` : input.executorKind === "pi" && managedPiMcpProxyAvailable(input) ? `  Exact Pi \`mcp\` arguments: ${JSON.stringify(call)}` : `  Call amaster.read_issue_document with these exact arguments: ${JSON.stringify(call)}`
@@ -5270,6 +5369,18 @@ function managedDirectToolName(input, canonicalName) {
 function managedPiMcpProxyAvailable(input) {
   return input.managedMcpToolMode === "proxy_only" || input.managedMcpToolMode === "hybrid";
 }
+function managedPiMcpProxyToolName(canonicalName) {
+  const name = readString(canonicalName);
+  if (!name) throw new TypeError("canonical MCP tool name is required");
+  return name.replaceAll(".", "_");
+}
+function managedPiMcpProxyCall(canonicalName, args) {
+  return {
+    server: "amaster",
+    tool: managedPiMcpProxyToolName(canonicalName),
+    args: JSON.stringify(args)
+  };
+}
 function runtimeActionContinuationOptionText(input) {
   if (!isRecoveryWakeReason(input.wakeReason)) return "";
   const heading = "### Runtime Action Continuation Option";
@@ -5310,11 +5421,7 @@ Runtime Action continuation is unavailable: the run catalog does not advertise t
       return `${heading}
 Runtime Action continuation is unavailable: managed Pi MCP tool mode is not proxy_only. Do not guess a proxy or direct-tool call.`;
     }
-    const proxyCall = {
-      server: "amaster",
-      tool: "runtime_action.submit",
-      args: JSON.stringify(envelope)
-    };
+    const proxyCall = managedPiMcpProxyCall("runtime_action.submit", envelope);
     return [
       heading,
       "Only after selecting continuation/todo from the disposition menu, emit an actual `mcp` tool call with the exact proxy arguments below. Do not print this JSON as prose and do not add an outer `action` field.",
@@ -5416,11 +5523,7 @@ function runtimeDecompositionRequirementText(context) {
 function deliveryReadCallText(input) {
   const args = { issueId: input.issueId };
   if (input.executorKind === "pi" && managedPiMcpProxyAvailable(input)) {
-    return `emit an mcp proxy call: ${JSON.stringify({
-      server: "amaster",
-      tool: "amaster.read_issue_delivery",
-      args: JSON.stringify(args)
-    })}`;
+    return `emit an mcp proxy call: ${JSON.stringify(managedPiMcpProxyCall("amaster.read_issue_delivery", args))}`;
   }
   return `call amaster.read_issue_delivery with these exact arguments: ${JSON.stringify(args)}`;
 }
@@ -5509,7 +5612,7 @@ function readIssueEvidenceCommentsCallText(issueId, commentIds, options) {
       return `call \`${directToolName}\`${batchLabel} with these exact object arguments: ${JSON.stringify(readArguments)}`;
     }
     if (options?.executorKind === "pi" && managedPiMcpProxyAvailable(options)) {
-      return `emit an mcp proxy call${batchLabel}: ${JSON.stringify({ server: "amaster", tool: "amaster.read_issue_evidence", args: JSON.stringify(readArguments) })}`;
+      return `emit an mcp proxy call${batchLabel}: ${JSON.stringify(managedPiMcpProxyCall("amaster.read_issue_evidence", readArguments))}`;
     }
     return `call amaster.read_issue_evidence${batchLabel} with these exact arguments: ${JSON.stringify(readArguments)}`;
   }).join("; then ");
@@ -5521,11 +5624,7 @@ function overflowDependencyRefsText(overflowRefs, input) {
     ...overflowRefs.flatMap((ref, index) => {
       const readArguments = { issueId: ref.blockerSelector, key: ref.key };
       const directToolName = managedDirectToolName(input, "amaster.read_issue_document");
-      const call = directToolName ? readArguments : input.executorKind === "pi" && managedPiMcpProxyAvailable(input) ? {
-        server: "amaster",
-        tool: "amaster.read_issue_document",
-        args: JSON.stringify(readArguments)
-      } : readArguments;
+      const call = directToolName ? readArguments : input.executorKind === "pi" && managedPiMcpProxyAvailable(input) ? managedPiMcpProxyCall("amaster.read_issue_document", readArguments) : readArguments;
       return [
         `- On-demand read ${index + 1}: issue ${JSON.stringify(ref.blockerSelector)}${ref.blockerId ? ` (id ${JSON.stringify(ref.blockerId)})` : ""}; document ${JSON.stringify(ref.documentId)}; key ${JSON.stringify(ref.key)}; expected latestRevisionId ${JSON.stringify(ref.expectedLatestRevisionId)}${ref.expectedLatestRevisionNumber != null ? `; revisionNumber ${ref.expectedLatestRevisionNumber}` : ""}.`,
         directToolName ? `  Call \`${directToolName}\` with these exact object arguments: ${JSON.stringify(call)}` : input.executorKind === "pi" && managedPiMcpProxyAvailable(input) ? `  Exact Pi \`mcp\` arguments: ${JSON.stringify(call)}` : input.managedMcpToolMode === "direct_typed" ? "  Exact read unavailable: amaster.read_issue_document is absent from the attested direct tool catalog. Do not guess a tool name or bypass the managed transport." : `  Call amaster.read_issue_document with these exact arguments: ${JSON.stringify(call)}`
@@ -5561,11 +5660,7 @@ function taskCommentRefGuidance(input, taskText) {
 }
 function piMcpUsageText(input) {
   if (!input.hasGovernedMcp || input.executorKind !== "pi" || !managedPiMcpProxyAvailable(input) || isRecoveryWakeReason(input.wakeReason)) return "";
-  const proxy = (tool, args) => JSON.stringify({
-    server: "amaster",
-    tool,
-    args: JSON.stringify(args)
-  });
+  const proxy = (tool, args) => JSON.stringify(managedPiMcpProxyCall(tool, args));
   return [
     "This run uses the outer `mcp` proxy for Governed MCP calls. Emit actual tool calls; `args` is the stringified inner canonical object. Pi validates this string schema before extension hooks, so never send object-valued `args`.",
     "Before the first write, describe that exact canonical action and use the returned schema; do not infer write arguments from this example.",
@@ -5631,6 +5726,7 @@ var CONTEXT_AVAILABILITY_SECTION_TITLES = Object.freeze({
   wake_comments: "Wake Delta",
   task: "Task Context",
   governed_business_state: "Governed Business State",
+  task_acceptance_contract: "Task Acceptance Contract",
   continuation_summary: "Continuation Summary",
   resolved_dependencies: "Resolved Dependency Outputs",
   runtime_delivery_readiness: "Current Delivery Readiness",
@@ -5725,6 +5821,7 @@ function compileCommandPromptWithManifest(input, options = {}) {
   const suppressOrdinaryCompletionContract = completeRecoveryInstruction.length > 0;
   const governedReads = governedReadSection(context);
   const governedBusinessState = governedBusinessStateSection(context, input);
+  const taskAcceptanceContract = taskAcceptanceContractSection(context, input);
   const verifiedCompanyContext = verifiedCompanyContextSection(context);
   const hasTask = Boolean(readString(input.taskMarkdown));
   const taskText = readString(input.taskMarkdown) ?? "";
@@ -5777,6 +5874,7 @@ ${resolvedDependencies.details.content}` : ""
     { name: "approval_continuation", title: "Approved Runtime Action Continuation", priority: 99, sourceRef: `run:${input.runId ?? "unknown"}`, content: approvalContinuationText(input), truncationReason: mode === "continuation" ? null : "mode_selection" },
     { name: "wake_comments", title: wakeDeltaTitle, priority: interactionResolution ? 99 : 95, sourceRef: wakeDeltaSourceRefs, originalContent: wakeDeltaOriginal, content: wakeDeltaContent, truncationReason: commentsSelected ? null : "duplicate_task_context" },
     { name: "task", title: "Task Context", priority: 90, sourceRef: taskSourceRefs, originalContent: [taskText, taskCommentRefGuidance(input, taskText)].filter(Boolean).join("\n"), content: includeTask ? [taskText, taskCommentRefGuidance(input, taskText)].filter(Boolean).join("\n") : "", truncationReason: includeTask ? null : "mode_selection" },
+    ...taskAcceptanceContract ? [{ name: "task_acceptance_contract", title: "Task Acceptance Contract", priority: 100, ...taskAcceptanceContract }] : [],
     ...governedBusinessState ? [{ name: "governed_business_state", title: "Governed Business State", priority: 99, ...governedBusinessState }] : [],
     { name: "continuation_summary", title: "Continuation Summary", priority: 97, sourceRef: readString(asRecord(context.paperclipContinuationSummary).key) ?? `issue:${input.issueId ?? "unknown"}`, observedAt: readString(asRecord(context.paperclipContinuationSummary).updatedAt), originalContent: continuationSummary, content: mode === "cold" ? "" : continuationSummary, truncationReason: mode === "cold" ? "mode_selection" : null },
     ...resolvedDependencyContent ? [{
@@ -9528,7 +9626,7 @@ function assertSourceAcquisitionRuntimeAuthority({
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.33";
+var CONNECTOR_VERSION = "0.1.1-beta.35";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY = "source_acquisition_v1";
 var SOURCE_ACQUISITION_PROFILE_VERSION = "source_acquisition_v1";

package/dist/amaster-runtime.mjs

@@ -6,7 +6,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.1-beta.33";
+const CONNECTOR_VERSION = "0.1.1-beta.35";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.1-beta.33",
+  "version": "0.1.1-beta.35",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",