omnius 1.0.667 → 1.0.668

package/dist/library.js

@@ -288,6 +288,722 @@ async function getServiceVersion(baseUrl, options = {}) {
   };
 }
 
+// packages/cli/src/tui/telegram-context-packet-v2.ts
+import { createHash } from "node:crypto";
+var TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION = 2;
+var TelegramContextPacketValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TelegramContextPacketValidationError";
+  }
+};
+var TelegramContextPacketRevisionConflictError = class extends Error {
+  constructor(semanticId, revision) {
+    super(
+      `Conflicting Telegram context blocks use semanticId=${JSON.stringify(semanticId)} revision=${revision}`
+    );
+    this.name = "TelegramContextPacketRevisionConflictError";
+  }
+};
+var TelegramContextPacketBudgetError = class extends Error {
+  segment;
+  budgetChars;
+  requiredChars;
+  constructor(segment, budgetChars, requiredChars) {
+    super(
+      `Telegram ${segment} context budget ${budgetChars} cannot fit the mandatory packet envelope and omission receipt (${requiredChars} chars required)`
+    );
+    this.name = "TelegramContextPacketBudgetError";
+    this.segment = segment;
+    this.budgetChars = budgetChars;
+    this.requiredChars = requiredChars;
+  }
+};
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/;
+function assertId(value, field) {
+  if (!ID_PATTERN.test(value)) {
+    throw new TelegramContextPacketValidationError(
+      `${field} must match ${ID_PATTERN.source}`
+    );
+  }
+}
+function normalizedInteger(value, fallback, field) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved)) {
+    throw new TelegramContextPacketValidationError(
+      `${field} must be a safe integer`
+    );
+  }
+  return resolved;
+}
+function normalizedBudget(value, field) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TelegramContextPacketValidationError(
+      `${field} must be a non-negative safe integer`
+    );
+  }
+  return value;
+}
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareBlocksForRender(left, right) {
+  return left.order - right.order || right.priority - left.priority || compareText(left.semanticId, right.semanticId);
+}
+function compareRecordsForRender(left, right) {
+  return left.blockOrder - right.blockOrder || right.blockPriority - left.blockPriority || compareText(left.semanticId, right.semanticId) || left.recordOrder - right.recordOrder || right.recordPriority - left.recordPriority || compareText(left.recordId, right.recordId);
+}
+function compareRecordsForAdmission(left, right) {
+  return right.blockPriority - left.blockPriority || right.recordPriority - left.recordPriority || left.blockOrder - right.blockOrder || left.recordOrder - right.recordOrder || compareText(left.semanticId, right.semanticId) || compareText(left.recordId, right.recordId);
+}
+function canonicalBlock(block) {
+  const records = [...block.records].map((record) => ({
+    recordId: record.recordId,
+    content: record.content,
+    order: record.order ?? 0,
+    priority: record.priority ?? 0
+  })).sort(
+    (left, right) => left.order - right.order || right.priority - left.priority || compareText(left.recordId, right.recordId)
+  );
+  return JSON.stringify({
+    semanticId: block.semanticId,
+    revision: block.revision,
+    stability: block.stability,
+    order: block.order ?? 0,
+    priority: block.priority ?? 0,
+    records
+  });
+}
+function normalizeBlock(block) {
+  assertId(block.semanticId, "semanticId");
+  const revision = normalizedInteger(block.revision, 0, "revision");
+  if (revision < 0) {
+    throw new TelegramContextPacketValidationError(
+      "revision must be non-negative"
+    );
+  }
+  if (block.stability !== "stable" && block.stability !== "dynamic") {
+    throw new TelegramContextPacketValidationError(
+      "stability must be stable or dynamic"
+    );
+  }
+  const order = normalizedInteger(block.order, 0, "block order");
+  const priority = normalizedInteger(block.priority, 0, "block priority");
+  const recordIds = /* @__PURE__ */ new Set();
+  const records = block.records.map((record) => {
+    assertId(record.recordId, "recordId");
+    if (recordIds.has(record.recordId)) {
+      throw new TelegramContextPacketValidationError(
+        `Duplicate recordId=${JSON.stringify(record.recordId)} in semanticId=${JSON.stringify(block.semanticId)}`
+      );
+    }
+    recordIds.add(record.recordId);
+    if (typeof record.content !== "string") {
+      throw new TelegramContextPacketValidationError(
+        `content for recordId=${JSON.stringify(record.recordId)} must be a string`
+      );
+    }
+    return {
+      semanticId: block.semanticId,
+      revision,
+      stability: block.stability,
+      blockOrder: order,
+      blockPriority: priority,
+      recordId: record.recordId,
+      content: record.content,
+      recordOrder: normalizedInteger(record.order, 0, "record order"),
+      recordPriority: normalizedInteger(record.priority, 0, "record priority")
+    };
+  });
+  records.sort(compareRecordsForRender);
+  return {
+    semanticId: block.semanticId,
+    revision,
+    stability: block.stability,
+    order,
+    priority,
+    records
+  };
+}
+function selectBlockRevisions(blocks) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const normalized2 = normalizeBlock(block);
+    const source = {
+      semanticId: normalized2.semanticId,
+      revision: normalized2.revision,
+      stability: normalized2.stability,
+      order: normalized2.order,
+      priority: normalized2.priority,
+      records: normalized2.records.map((record) => ({
+        recordId: record.recordId,
+        content: record.content,
+        order: record.recordOrder,
+        priority: record.recordPriority
+      }))
+    };
+    const canonical = canonicalBlock(source);
+    const current = selected.get(source.semanticId);
+    if (!current || source.revision > current.source.revision) {
+      selected.set(source.semanticId, { source, canonical });
+      continue;
+    }
+    if (source.revision < current.source.revision) continue;
+    if (canonical !== current.canonical) {
+      throw new TelegramContextPacketRevisionConflictError(
+        source.semanticId,
+        source.revision
+      );
+    }
+  }
+  return [...selected.values()].map(({ source }) => normalizeBlock(source)).sort(compareBlocksForRender);
+}
+function segmentHeader(segment) {
+  return JSON.stringify({
+    type: "telegram_context_packet_v2",
+    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
+    segment
+  });
+}
+function segmentFooter(segment) {
+  return JSON.stringify({
+    type: "telegram_context_packet_end_v2",
+    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
+    segment
+  });
+}
+function serializeRecord(record) {
+  return JSON.stringify({
+    type: "telegram_context_record_v2",
+    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
+    semanticId: record.semanticId,
+    revision: record.revision,
+    recordId: record.recordId,
+    content: record.content
+  });
+}
+function omittedRecordRef(record) {
+  return {
+    semanticId: record.semanticId,
+    revision: record.revision,
+    recordId: record.recordId
+  };
+}
+function buildOmissionReceipt(segment, omitted) {
+  if (omitted.length === 0) return void 0;
+  const omittedRecords = [...omitted].sort(compareRecordsForRender).map(omittedRecordRef);
+  const omittedSemanticIds = [
+    ...new Set(omittedRecords.map((record) => record.semanticId))
+  ].sort(compareText);
+  return {
+    type: "telegram_context_omission_receipt_v2",
+    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
+    segment,
+    reason: "char_budget",
+    omittedBlockCount: omittedSemanticIds.length,
+    omittedRecordCount: omittedRecords.length,
+    omittedDigest: createHash("sha256").update(JSON.stringify(omittedRecords)).digest("hex"),
+    omittedSemanticIds,
+    omittedRecords
+  };
+}
+function serializeOmissionReceipt(receipt) {
+  return JSON.stringify({
+    type: receipt.type,
+    schemaVersion: receipt.schemaVersion,
+    segment: receipt.segment,
+    reason: receipt.reason,
+    omittedBlockCount: receipt.omittedBlockCount,
+    omittedRecordCount: receipt.omittedRecordCount,
+    omittedDigest: receipt.omittedDigest
+  });
+}
+function renderSegmentText(segment, included, omitted) {
+  const receipt = buildOmissionReceipt(segment, omitted);
+  const lines = [
+    segmentHeader(segment),
+    ...[...included].sort(compareRecordsForRender).map(serializeRecord),
+    ...receipt ? [serializeOmissionReceipt(receipt)] : [],
+    segmentFooter(segment)
+  ];
+  return {
+    text: lines.join("\n"),
+    ...receipt ? { receipt } : {}
+  };
+}
+function compileSegment(segment, blocks, budgetChars) {
+  const records = blocks.flatMap((block) => block.records);
+  const admissionOrder = [...records].sort(compareRecordsForAdmission);
+  const included = /* @__PURE__ */ new Set();
+  const empty = renderSegmentText(segment, [], admissionOrder);
+  if (empty.text.length > budgetChars) {
+    throw new TelegramContextPacketBudgetError(
+      segment,
+      budgetChars,
+      empty.text.length
+    );
+  }
+  for (const candidate of admissionOrder) {
+    const tentativeIncluded = [...included, candidate];
+    const tentativeOmitted = admissionOrder.filter(
+      (record) => !included.has(record) && record !== candidate
+    );
+    const tentative = renderSegmentText(
+      segment,
+      tentativeIncluded,
+      tentativeOmitted
+    );
+    if (tentative.text.length <= budgetChars) included.add(candidate);
+  }
+  const includedRecords = records.filter((record) => included.has(record));
+  const omittedRecords = records.filter((record) => !included.has(record));
+  const rendered = renderSegmentText(segment, includedRecords, omittedRecords);
+  const compiledBlocks = blocks.flatMap((block) => {
+    const admitted = block.records.filter((record) => included.has(record));
+    if (admitted.length === 0) return [];
+    return [
+      {
+        semanticId: block.semanticId,
+        revision: block.revision,
+        stability: block.stability,
+        order: block.order,
+        priority: block.priority,
+        records: admitted.sort(compareRecordsForRender).map((record) => ({
+          semanticId: record.semanticId,
+          revision: record.revision,
+          recordId: record.recordId,
+          content: record.content,
+          order: record.recordOrder,
+          priority: record.recordPriority,
+          serializedChars: serializeRecord(record).length
+        }))
+      }
+    ];
+  });
+  return {
+    segment,
+    text: rendered.text,
+    charLength: rendered.text.length,
+    budgetChars,
+    blocks: compiledBlocks,
+    ...rendered.receipt ? { omissionReceipt: rendered.receipt } : {}
+  };
+}
+function compileTelegramContextPacketV2(input) {
+  const stableChars = normalizedBudget(
+    input.budgets.stableChars,
+    "stableChars"
+  );
+  const dynamicChars = normalizedBudget(
+    input.budgets.dynamicChars,
+    "dynamicChars"
+  );
+  const selected = selectBlockRevisions(input.blocks);
+  const stable = compileSegment(
+    "stable",
+    selected.filter((block) => block.stability === "stable"),
+    stableChars
+  );
+  const dynamic = compileSegment(
+    "dynamic",
+    selected.filter((block) => block.stability === "dynamic"),
+    dynamicChars
+  );
+  const selectedRevisions = Object.fromEntries(
+    [...selected].sort((left, right) => compareText(left.semanticId, right.semanticId)).map((block) => [block.semanticId, block.revision])
+  );
+  const combinedContext = `${stable.text}
+${dynamic.text}`;
+  return {
+    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
+    stablePrefix: stable.text,
+    stablePrefixHash: createHash("sha256").update(stable.text).digest("hex"),
+    dynamicContext: dynamic.text,
+    combinedContext,
+    selectedRevisions,
+    stable,
+    dynamic
+  };
+}
+
+// packages/cli/src/tui/telegram-cognition-queue.ts
+var TELEGRAM_COGNITION_AUTHORITY = "internal_cognition_only";
+var TelegramCognitionQueueValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TelegramCognitionQueueValidationError";
+  }
+};
+var JOB_KINDS = /* @__PURE__ */ new Set([
+  "social_state",
+  "memory",
+  "reflection",
+  "cognition_batch"
+]);
+function positiveSafeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TelegramCognitionQueueValidationError(
+      `${field} must be a positive safe integer`
+    );
+  }
+  return value;
+}
+function boundedIdentity(value, field) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 300) {
+    throw new TelegramCognitionQueueValidationError(
+      `${field} must contain 1 to 300 characters`
+    );
+  }
+  return value;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function deferredOutcome() {
+  let resolve2;
+  const promise = new Promise((done) => {
+    resolve2 = done;
+  });
+  return { promise, resolve: resolve2 };
+}
+var TelegramCognitionQueue = class {
+  maxConcurrentScopes;
+  maxQueuedJobs;
+  defaultTimeBudgetMs;
+  pending = [];
+  running = /* @__PURE__ */ new Map();
+  activeScopes = /* @__PURE__ */ new Set();
+  dedupe = /* @__PURE__ */ new Map();
+  jobsById = /* @__PURE__ */ new Map();
+  idleWaiters = /* @__PURE__ */ new Set();
+  totals = {
+    accepted: 0,
+    deduplicated: 0,
+    rejectedCapacity: 0,
+    rejectedClosed: 0,
+    started: 0,
+    succeeded: 0,
+    failed: 0,
+    timedOut: 0,
+    cancelled: 0
+  };
+  state = "open";
+  pumpScheduled = false;
+  nextJobSequence = 1;
+  constructor(options) {
+    this.maxConcurrentScopes = positiveSafeInteger(
+      options.maxConcurrentScopes,
+      "maxConcurrentScopes"
+    );
+    this.maxQueuedJobs = positiveSafeInteger(
+      options.maxQueuedJobs,
+      "maxQueuedJobs"
+    );
+    this.defaultTimeBudgetMs = positiveSafeInteger(
+      options.defaultTimeBudgetMs,
+      "defaultTimeBudgetMs"
+    );
+  }
+  enqueue(job) {
+    const scopeKey = boundedIdentity(job.scopeKey, "scopeKey");
+    const dedupeKey = boundedIdentity(job.dedupeKey, "dedupeKey");
+    if (!JOB_KINDS.has(job.kind)) {
+      throw new TelegramCognitionQueueValidationError(
+        `Unsupported cognition job kind: ${String(job.kind)}`
+      );
+    }
+    if (typeof job.execute !== "function") {
+      throw new TelegramCognitionQueueValidationError(
+        "execute must be a function"
+      );
+    }
+    const timeBudgetMs = positiveSafeInteger(
+      job.timeBudgetMs ?? this.defaultTimeBudgetMs,
+      "timeBudgetMs"
+    );
+    const dedupeIdentity = `${scopeKey}\0${dedupeKey}`;
+    const existing = this.dedupe.get(dedupeIdentity);
+    if (existing) {
+      this.totals.deduplicated++;
+      return {
+        admission: "deduplicated",
+        jobId: existing.jobId,
+        scopeKey,
+        dedupeKey,
+        completion: existing.completion
+      };
+    }
+    const jobId = boundedIdentity(
+      job.jobId ?? `tg-cognition-${this.nextJobSequence++}`,
+      "jobId"
+    );
+    if (this.jobsById.has(jobId)) {
+      throw new TelegramCognitionQueueValidationError(
+        `jobId is already active: ${jobId}`
+      );
+    }
+    if (this.state !== "open") {
+      this.totals.rejectedClosed++;
+      return this.rejectedReceipt(
+        "rejected_closed",
+        jobId,
+        scopeKey,
+        dedupeKey,
+        job.kind,
+        "Telegram cognition queue is closing or closed"
+      );
+    }
+    this.pump();
+    const canStartNow = this.running.size < this.maxConcurrentScopes && !this.activeScopes.has(scopeKey);
+    if (!canStartNow && this.pending.length >= this.maxQueuedJobs) {
+      this.totals.rejectedCapacity++;
+      return this.rejectedReceipt(
+        "rejected_capacity",
+        jobId,
+        scopeKey,
+        dedupeKey,
+        job.kind,
+        "Telegram cognition queue capacity reached"
+      );
+    }
+    const completion = deferredOutcome();
+    const accepted = {
+      jobId,
+      scopeKey,
+      dedupeKey,
+      dedupeIdentity,
+      kind: job.kind,
+      timeBudgetMs,
+      execute: job.execute,
+      enqueuedAtMs: Date.now(),
+      completion: completion.promise,
+      resolve: completion.resolve
+    };
+    this.dedupe.set(dedupeIdentity, accepted);
+    this.jobsById.set(jobId, accepted);
+    this.totals.accepted++;
+    if (canStartNow) this.start(accepted);
+    else this.pending.push(accepted);
+    return {
+      admission: "accepted",
+      jobId,
+      scopeKey,
+      dedupeKey,
+      completion: completion.promise
+    };
+  }
+  cancel(jobId, reason = "cancelled") {
+    const job = this.jobsById.get(jobId);
+    if (!job) return false;
+    const pendingIndex = this.pending.indexOf(job);
+    if (pendingIndex >= 0) {
+      this.pending.splice(pendingIndex, 1);
+      this.finish(job, "cancelled", reason);
+      return true;
+    }
+    if (job.controller && !job.controller.signal.aborted) {
+      job.forcedStatus = "cancelled";
+      job.forcedReason = reason;
+      job.controller.abort(new Error(reason));
+      return true;
+    }
+    return false;
+  }
+  cancelScope(scopeKey, reason = "scope cancelled") {
+    let cancelled = 0;
+    for (const job of [...this.pending, ...this.running.values()]) {
+      if (job.scopeKey === scopeKey && this.cancel(job.jobId, reason)) {
+        cancelled++;
+      }
+    }
+    return cancelled;
+  }
+  snapshot() {
+    const now = Date.now();
+    const queuedByScope = {};
+    for (const job of this.pending) {
+      queuedByScope[job.scopeKey] = (queuedByScope[job.scopeKey] ?? 0) + 1;
+    }
+    const oldest = this.pending.reduce(
+      (value, job) => Math.min(value, job.enqueuedAtMs),
+      Number.POSITIVE_INFINITY
+    );
+    return {
+      state: this.state,
+      maxConcurrentScopes: this.maxConcurrentScopes,
+      maxQueuedJobs: this.maxQueuedJobs,
+      defaultTimeBudgetMs: this.defaultTimeBudgetMs,
+      queuedJobs: this.pending.length,
+      runningJobs: this.running.size,
+      activeScopes: [...this.activeScopes].sort(),
+      queuedByScope: Object.fromEntries(
+        Object.entries(queuedByScope).sort(
+          ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+        )
+      ),
+      oldestQueuedAgeMs: Number.isFinite(oldest) ? Math.max(0, now - oldest) : 0,
+      totals: { ...this.totals }
+    };
+  }
+  waitForIdle() {
+    if (this.pending.length === 0 && this.running.size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve2) => {
+      this.idleWaiters.add(resolve2);
+    });
+  }
+  async close(options = {}) {
+    if (this.state === "closed") return;
+    this.state = "closing";
+    const reason = options.reason ?? "queue closed";
+    if (options.cancelQueued) {
+      for (const job of [...this.pending]) this.cancel(job.jobId, reason);
+    }
+    if (options.cancelRunning) {
+      for (const job of [...this.running.values()]) {
+        this.cancel(job.jobId, reason);
+      }
+    }
+    this.schedulePump();
+    await this.waitForIdle();
+    this.state = "closed";
+  }
+  rejectedReceipt(status, jobId, scopeKey, dedupeKey, kind, error) {
+    const now = Date.now();
+    return {
+      admission: status,
+      jobId,
+      scopeKey,
+      dedupeKey,
+      completion: Promise.resolve({
+        jobId,
+        scopeKey,
+        dedupeKey,
+        kind,
+        status,
+        enqueuedAtMs: now,
+        finishedAtMs: now,
+        errorMessage: error
+      })
+    };
+  }
+  schedulePump() {
+    if (this.pumpScheduled) return;
+    this.pumpScheduled = true;
+    queueMicrotask(() => {
+      this.pumpScheduled = false;
+      this.pump();
+    });
+  }
+  pump() {
+    while (this.running.size < this.maxConcurrentScopes) {
+      const nextIndex = this.pending.findIndex(
+        (job2) => !this.activeScopes.has(job2.scopeKey)
+      );
+      if (nextIndex < 0) break;
+      const [job] = this.pending.splice(nextIndex, 1);
+      if (!job) break;
+      this.start(job);
+    }
+    this.maybeResolveIdle();
+  }
+  start(job) {
+    job.startedAtMs = Date.now();
+    job.controller = new AbortController();
+    this.running.set(job.jobId, job);
+    this.activeScopes.add(job.scopeKey);
+    this.totals.started++;
+    const deadlineAtMs = job.startedAtMs + job.timeBudgetMs;
+    const timer = setTimeout(() => {
+      if (!job.controller || job.controller.signal.aborted) return;
+      job.forcedStatus = "timed_out";
+      job.forcedReason = `time budget exceeded after ${job.timeBudgetMs}ms`;
+      job.controller.abort(new Error(job.forcedReason));
+    }, job.timeBudgetMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    const abortOutcome = new Promise((resolve2) => {
+      job.controller.signal.addEventListener(
+        "abort",
+        () => resolve2("aborted"),
+        {
+          once: true
+        }
+      );
+    });
+    const execution = Promise.resolve().then(
+      () => job.execute({
+        authority: TELEGRAM_COGNITION_AUTHORITY,
+        jobId: job.jobId,
+        scopeKey: job.scopeKey,
+        kind: job.kind,
+        signal: job.controller.signal,
+        deadlineAtMs
+      })
+    ).then(
+      () => ({ type: "succeeded" }),
+      (error) => ({ type: "failed", error })
+    );
+    void Promise.race([
+      execution,
+      abortOutcome.then(() => ({ type: "aborted" }))
+    ]).then((result) => {
+      clearTimeout(timer);
+      if (result.type === "aborted") {
+        this.finish(
+          job,
+          job.forcedStatus ?? "cancelled",
+          job.forcedReason ?? "cancelled"
+        );
+      } else if (result.type === "failed") {
+        this.finish(job, "failed", errorMessage(result.error));
+      } else {
+        this.finish(job, "succeeded");
+      }
+    }).catch((error) => {
+      clearTimeout(timer);
+      this.finish(job, "failed", errorMessage(error));
+    });
+    void execution.then(() => void 0);
+  }
+  finish(job, status, error) {
+    if (!this.jobsById.has(job.jobId)) return;
+    this.running.delete(job.jobId);
+    this.activeScopes.delete(job.scopeKey);
+    this.jobsById.delete(job.jobId);
+    if (this.dedupe.get(job.dedupeIdentity) === job) {
+      this.dedupe.delete(job.dedupeIdentity);
+    }
+    this.totals[status === "timed_out" ? "timedOut" : status]++;
+    const finishedAtMs = Date.now();
+    const startedAtMs = job.startedAtMs;
+    job.resolve({
+      jobId: job.jobId,
+      scopeKey: job.scopeKey,
+      dedupeKey: job.dedupeKey,
+      kind: job.kind,
+      status,
+      enqueuedAtMs: job.enqueuedAtMs,
+      ...startedAtMs !== void 0 ? {
+        startedAtMs,
+        queueWaitMs: Math.max(0, startedAtMs - job.enqueuedAtMs),
+        runDurationMs: Math.max(0, finishedAtMs - startedAtMs)
+      } : {},
+      finishedAtMs,
+      ...error ? { errorMessage: error } : {}
+    });
+    this.schedulePump();
+  }
+  maybeResolveIdle() {
+    if (this.pending.length > 0 || this.running.size > 0) return;
+    for (const resolve2 of this.idleWaiters) resolve2();
+    this.idleWaiters.clear();
+    if (this.state === "closing") this.state = "closed";
+  }
+};
+
 // packages/backend-vllm/dist/providerRegistry.js
 var CHAT_CAPABILITIES = [
   "chat",
@@ -989,13 +1705,1271 @@ var PROVIDER_PRESETS = [
     description: "Custom endpoint; an explicit ollama, openai-chat, or anthropic-messages protocol is required."
   }
 ];
+
+// packages/cli/src/tui/telegram-input-ownership.ts
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "consumed",
+  "superseded",
+  "failed"
+]);
+var ALLOWED_TRANSITIONS = {
+  received: /* @__PURE__ */ new Set([
+    "classified",
+    "queued",
+    "dispatched",
+    "decision_committed",
+    "superseded",
+    "failed"
+  ]),
+  classified: /* @__PURE__ */ new Set([
+    "queued",
+    "dispatched",
+    "decision_committed",
+    "superseded",
+    "failed"
+  ]),
+  queued: /* @__PURE__ */ new Set([
+    "dispatched",
+    "deferred",
+    "decision_committed",
+    "superseded",
+    "failed"
+  ]),
+  dispatched: /* @__PURE__ */ new Set([
+    "deferred",
+    "decision_committed",
+    "superseded",
+    "failed"
+  ]),
+  deferred: /* @__PURE__ */ new Set([
+    "queued",
+    "dispatched",
+    "decision_committed",
+    "superseded",
+    "failed"
+  ]),
+  decision_committed: /* @__PURE__ */ new Set([
+    "deferred",
+    "queued",
+    "dispatched",
+    "delivery_committed",
+    "consumed",
+    "superseded",
+    "failed"
+  ]),
+  delivery_committed: /* @__PURE__ */ new Set(["consumed"]),
+  consumed: /* @__PURE__ */ new Set(),
+  superseded: /* @__PURE__ */ new Set(),
+  failed: /* @__PURE__ */ new Set()
+};
+function nonEmpty(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}
+function finiteInteger(value, label) {
+  if (!Number.isSafeInteger(value)) {
+    throw new TypeError(`${label} must be a safe integer`);
+  }
+  return value;
+}
+function timestamp(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError("atMs must be a non-negative finite number");
+  }
+  return value;
+}
+function createTelegramInputTargetBinding(target) {
+  return Object.freeze({
+    inputId: nonEmpty(target.inputId, "inputId"),
+    sessionKey: nonEmpty(target.sessionKey, "sessionKey"),
+    chatId: nonEmpty(target.chatId, "chatId"),
+    messageId: finiteInteger(target.messageId, "messageId"),
+    messageThreadId: finiteInteger(target.messageThreadId, "messageThreadId"),
+    senderActorKey: nonEmpty(target.senderActorKey, "senderActorKey")
+  });
+}
+function telegramInputTargetsEqual(left, right) {
+  return left.inputId === right.inputId && left.sessionKey === right.sessionKey && left.chatId === right.chatId && left.messageId === right.messageId && left.messageThreadId === right.messageThreadId && left.senderActorKey === right.senderActorKey;
+}
+function isTelegramInputTerminalLifecycle(state) {
+  return TERMINAL_STATES.has(state);
+}
+function freezeOwner(owner) {
+  const generation = finiteInteger(owner.generation, "owner.generation");
+  if (generation < 0) {
+    throw new TypeError("owner.generation must be non-negative");
+  }
+  return Object.freeze({
+    ownerId: nonEmpty(owner.ownerId, "owner.ownerId"),
+    generation
+  });
+}
+function ownersEqual(left, right) {
+  return left.ownerId === right.ownerId && left.generation === right.generation;
+}
+function freezeEvent(state, atMs, owner) {
+  return Object.freeze({ state, atMs: timestamp(atMs), owner });
+}
+function freezeRecord(record) {
+  return Object.freeze({
+    ...record,
+    history: Object.freeze([...record.history])
+  });
+}
+function decisionsEqual(left, right) {
+  return left.decisionId === right.decisionId && left.contractFingerprint === right.contractFingerprint && left.contractVersion === right.contractVersion && left.disposition === right.disposition;
+}
+function deliveriesEqual(left, right) {
+  return left.deliveryId === right.deliveryId && left.decisionId === right.decisionId && left.kind === right.kind && left.transportReceiptId === right.transportReceiptId;
+}
+var TelegramInputOwnershipLedger = class {
+  records = /* @__PURE__ */ new Map();
+  get(inputId) {
+    return this.records.get(inputId);
+  }
+  register(targetInput, ownerInput, atMs = Date.now()) {
+    const target = createTelegramInputTargetBinding(targetInput);
+    const owner = freezeOwner(ownerInput);
+    const existing = this.records.get(target.inputId);
+    if (existing) {
+      if (telegramInputTargetsEqual(existing.target, target)) {
+        return { status: "duplicate", record: existing };
+      }
+      return {
+        status: "contradiction",
+        record: existing,
+        reason: "inputId is already bound to a different immutable target"
+      };
+    }
+    const record = freezeRecord({
+      target,
+      owner,
+      lifecycle: "received",
+      revision: 0,
+      history: Object.freeze([freezeEvent("received", atMs, owner)])
+    });
+    this.records.set(target.inputId, record);
+    return { status: "applied", record };
+  }
+  claim(targetInput, ownerInput) {
+    const bound = this.boundRecord(targetInput);
+    if (bound.status !== "applied") return bound;
+    const record = bound.record;
+    const owner = freezeOwner(ownerInput);
+    if (ownersEqual(record.owner, owner)) {
+      return { status: "duplicate", record };
+    }
+    if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
+      return {
+        status: "terminal",
+        record,
+        reason: "terminal input ownership cannot be transferred"
+      };
+    }
+    if (owner.generation < record.owner.generation) {
+      return {
+        status: "stale",
+        record,
+        reason: "owner generation is older than the authoritative claim"
+      };
+    }
+    if (owner.generation === record.owner.generation) {
+      return {
+        status: "contradiction",
+        record,
+        reason: "one owner generation cannot name two owners"
+      };
+    }
+    const next = freezeRecord({
+      ...record,
+      owner,
+      revision: record.revision + 1
+    });
+    this.records.set(targetInput.inputId, next);
+    return { status: "applied", record: next };
+  }
+  transition(targetInput, ownerInput, nextState, atMs = Date.now()) {
+    const authorized = this.authorizedRecord(targetInput, ownerInput);
+    if (authorized.status !== "applied") return authorized;
+    const record = authorized.record;
+    if (record.lifecycle === nextState) {
+      return { status: "duplicate", record };
+    }
+    if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
+      return {
+        status: "terminal",
+        record,
+        reason: "terminal input lifecycle cannot advance"
+      };
+    }
+    if (!ALLOWED_TRANSITIONS[record.lifecycle].has(nextState)) {
+      return {
+        status: "invalid_transition",
+        record,
+        reason: `${record.lifecycle} cannot transition to ${nextState}`
+      };
+    }
+    return this.storeLifecycle(record, nextState, atMs);
+  }
+  commitDecision(targetInput, ownerInput, decisionInput, atMs = Date.now()) {
+    const bound = this.boundRecord(targetInput);
+    if (bound.status !== "applied") return bound;
+    const record = bound.record;
+    const decision = {
+      decisionId: nonEmpty(decisionInput.decisionId, "decisionId"),
+      contractFingerprint: nonEmpty(
+        decisionInput.contractFingerprint,
+        "contractFingerprint"
+      ),
+      contractVersion: decisionInput.contractVersion,
+      disposition: decisionInput.disposition
+    };
+    if (decision.contractVersion !== 2) {
+      return {
+        status: "invalid_transition",
+        record,
+        reason: "only Telegram turn contract version 2 can be committed"
+      };
+    }
+    if (record.decision) {
+      return decisionsEqual(record.decision, decision) ? { status: "duplicate", record } : {
+        status: "contradiction",
+        record,
+        reason: "an input can have only one committed decision"
+      };
+    }
+    const authorized = this.authorizedRecord(targetInput, ownerInput);
+    if (authorized.status !== "applied") return authorized;
+    if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
+      return {
+        status: "terminal",
+        record,
+        reason: "a terminal input cannot accept a decision"
+      };
+    }
+    if (!ALLOWED_TRANSITIONS[record.lifecycle].has("decision_committed")) {
+      return {
+        status: "invalid_transition",
+        record,
+        reason: `${record.lifecycle} cannot commit a decision`
+      };
+    }
+    const committed = Object.freeze({
+      ...decision,
+      committedBy: record.owner,
+      committedAtMs: timestamp(atMs)
+    });
+    const next = freezeRecord({
+      ...record,
+      decision: committed,
+      lifecycle: "decision_committed",
+      revision: record.revision + 1,
+      history: [
+        ...record.history,
+        freezeEvent("decision_committed", atMs, record.owner)
+      ]
+    });
+    this.records.set(record.target.inputId, next);
+    return { status: "applied", record: next };
+  }
+  commitDelivery(targetInput, ownerInput, deliveryInput, atMs = Date.now()) {
+    const bound = this.boundRecord(targetInput);
+    if (bound.status !== "applied") return bound;
+    const record = bound.record;
+    const delivery = {
+      deliveryId: nonEmpty(deliveryInput.deliveryId, "deliveryId"),
+      decisionId: nonEmpty(deliveryInput.decisionId, "decisionId"),
+      kind: deliveryInput.kind,
+      transportReceiptId: nonEmpty(
+        deliveryInput.transportReceiptId,
+        "transportReceiptId"
+      )
+    };
+    if (record.delivery) {
+      return deliveriesEqual(record.delivery, delivery) ? { status: "duplicate", record } : {
+        status: "contradiction",
+        record,
+        reason: "an input can have only one committed delivery"
+      };
+    }
+    const authorized = this.authorizedRecord(targetInput, ownerInput);
+    if (authorized.status !== "applied") return authorized;
+    if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
+      return {
+        status: "terminal",
+        record,
+        reason: "a terminal input cannot accept a delivery"
+      };
+    }
+    if (!record.decision || record.decision.decisionId !== delivery.decisionId) {
+      return {
+        status: "invalid_transition",
+        record,
+        reason: "delivery must cite the committed decision"
+      };
+    }
+    if (record.decision.disposition === "no_reply") {
+      return {
+        status: "invalid_transition",
+        record,
+        reason: "a no_reply decision cannot have a delivery"
+      };
+    }
+    if (record.decision.disposition === "chat_reply" && delivery.kind !== "visible_reply" || record.decision.disposition === "action" && delivery.kind !== "action_effect") {
+      return {
+        status: "contradiction",
+        record,
+        reason: "delivery kind contradicts the committed disposition"
+      };
+    }
+    const committed = Object.freeze({
+      ...delivery,
+      committedBy: record.owner,
+      committedAtMs: timestamp(atMs)
+    });
+    const next = freezeRecord({
+      ...record,
+      delivery: committed,
+      lifecycle: "delivery_committed",
+      revision: record.revision + 1,
+      history: [
+        ...record.history,
+        freezeEvent("delivery_committed", atMs, record.owner)
+      ]
+    });
+    this.records.set(record.target.inputId, next);
+    return { status: "applied", record: next };
+  }
+  complete(targetInput, ownerInput, terminal, atMs = Date.now()) {
+    const bound = this.boundRecord(targetInput);
+    if (bound.status !== "applied") return bound;
+    const record = bound.record;
+    if (record.terminal) {
+      return record.terminal === terminal ? { status: "duplicate", record } : {
+        status: "contradiction",
+        record,
+        reason: "an input can have only one terminal lifecycle result"
+      };
+    }
+    const authorized = this.authorizedRecord(targetInput, ownerInput);
+    if (authorized.status !== "applied") return authorized;
+    if (terminal === "consumed") {
+      if (!record.decision) {
+        return {
+          status: "invalid_transition",
+          record,
+          reason: "consumed input requires a committed decision"
+        };
+      }
+      if (record.decision.disposition !== "no_reply" && !record.delivery) {
+        return {
+          status: "invalid_transition",
+          record,
+          reason: "reply and action decisions require a delivery receipt"
+        };
+      }
+    }
+    if (!ALLOWED_TRANSITIONS[record.lifecycle].has(terminal)) {
+      return {
+        status: "invalid_transition",
+        record,
+        reason: `${record.lifecycle} cannot transition to ${terminal}`
+      };
+    }
+    return this.storeLifecycle(record, terminal, atMs, terminal);
+  }
+  boundRecord(targetInput) {
+    const existing = this.records.get(targetInput.inputId);
+    if (!existing) {
+      return { status: "unknown_input", reason: "input is not registered" };
+    }
+    let target;
+    try {
+      target = createTelegramInputTargetBinding(targetInput);
+    } catch (error) {
+      return {
+        status: "contradiction",
+        record: existing,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (!telegramInputTargetsEqual(existing.target, target)) {
+      return {
+        status: "contradiction",
+        record: existing,
+        reason: "operation target contradicts the immutable input binding"
+      };
+    }
+    return { status: "applied", record: existing };
+  }
+  authorizedRecord(targetInput, ownerInput) {
+    const bound = this.boundRecord(targetInput);
+    if (bound.status !== "applied") return bound;
+    const record = bound.record;
+    let owner;
+    try {
+      owner = freezeOwner(ownerInput);
+    } catch (error) {
+      return {
+        status: "contradiction",
+        record,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (ownersEqual(record.owner, owner)) return bound;
+    if (owner.generation < record.owner.generation) {
+      return {
+        status: "stale",
+        record,
+        reason: "operation belongs to an older owner generation"
+      };
+    }
+    return {
+      status: "contradiction",
+      record,
+      reason: "operation owner does not match the authoritative claim"
+    };
+  }
+  storeLifecycle(record, state, atMs, terminal) {
+    const next = freezeRecord({
+      ...record,
+      lifecycle: state,
+      terminal,
+      revision: record.revision + 1,
+      history: [...record.history, freezeEvent(state, atMs, record.owner)]
+    });
+    this.records.set(record.target.inputId, next);
+    return { status: "applied", record: next };
+  }
+};
+
+// packages/cli/src/tui/telegram-turn-contract-v2.ts
+var TELEGRAM_TURN_CONTRACT_V2_VERSION = 2;
+var SELF_ROLES = /* @__PURE__ */ new Set([
+  "addressee",
+  "participant",
+  "observer",
+  "uncertain"
+]);
+var REPLY_BASES = /* @__PURE__ */ new Set([
+  "direct_turn",
+  "ongoing_self_task",
+  "social_intervention",
+  "none",
+  "uncertain"
+]);
+var KINDS = /* @__PURE__ */ new Set([
+  "no_reply",
+  "chat_reply",
+  "action"
+]);
+var COMMON_WIRE_KEYS = [
+  "version",
+  "kind",
+  "input_id",
+  "target",
+  "confidence",
+  "reason",
+  "addressed_actor_keys",
+  "self_role",
+  "reply_basis",
+  "evidence_ids"
+];
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function issue(code, path, message) {
+  return Object.freeze({ code, path, message });
+}
+function collectUnknownFields(value, allowed, path, issues) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      issues.push(
+        issue(
+          "unknown_field",
+          `${path}.${key}`,
+          "field is not part of the V2 contract"
+        )
+      );
+    }
+  }
+}
+function readString(value, path, issues) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push(issue("invalid_field", path, "must be a non-empty string"));
+    return null;
+  }
+  return value;
+}
+function readInteger(value, path, issues) {
+  if (!Number.isSafeInteger(value)) {
+    issues.push(issue("invalid_field", path, "must be a safe integer"));
+    return null;
+  }
+  return value;
+}
+function readStringArray(value, path, issues) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.length === 0)) {
+    issues.push(
+      issue("invalid_field", path, "must be an array of non-empty strings")
+    );
+    return null;
+  }
+  if (new Set(value).size !== value.length) {
+    issues.push(
+      issue("invalid_field", path, "must not contain duplicate values")
+    );
+    return null;
+  }
+  return Object.freeze([...value]);
+}
+function validateWireTarget(raw, expected, issues) {
+  if (!isRecord(raw)) {
+    issues.push(issue("invalid_field", "$.target", "must be an object"));
+    return null;
+  }
+  collectUnknownFields(
+    raw,
+    /* @__PURE__ */ new Set([
+      "input_id",
+      "session_key",
+      "chat_id",
+      "message_id",
+      "message_thread_id",
+      "sender_actor_key"
+    ]),
+    "$.target",
+    issues
+  );
+  const inputId = readString(raw["input_id"], "$.target.input_id", issues);
+  const sessionKey = readString(
+    raw["session_key"],
+    "$.target.session_key",
+    issues
+  );
+  const chatId = readString(raw["chat_id"], "$.target.chat_id", issues);
+  const messageId = readInteger(
+    raw["message_id"],
+    "$.target.message_id",
+    issues
+  );
+  const messageThreadId = readInteger(
+    raw["message_thread_id"],
+    "$.target.message_thread_id",
+    issues
+  );
+  const senderActorKey = readString(
+    raw["sender_actor_key"],
+    "$.target.sender_actor_key",
+    issues
+  );
+  if (inputId === null || sessionKey === null || chatId === null || messageId === null || messageThreadId === null || senderActorKey === null) {
+    return null;
+  }
+  const target = createTelegramInputTargetBinding({
+    inputId,
+    sessionKey,
+    chatId,
+    messageId,
+    messageThreadId,
+    senderActorKey
+  });
+  if (!telegramInputTargetsEqual(target, expected)) {
+    issues.push(
+      issue(
+        "target_mismatch",
+        "$.target",
+        "target does not match the host-owned input binding"
+      )
+    );
+    return null;
+  }
+  return target;
+}
+function validateTelegramTurnContractV2(raw, context) {
+  const issues = [];
+  if (!isRecord(raw)) {
+    return Object.freeze({
+      ok: false,
+      value: null,
+      issues: Object.freeze([
+        issue("not_object", "$", "turn must be an object")
+      ])
+    });
+  }
+  const rawKind = raw["kind"];
+  const kind = typeof rawKind === "string" && KINDS.has(rawKind) ? rawKind : null;
+  if (raw["version"] !== TELEGRAM_TURN_CONTRACT_V2_VERSION) {
+    issues.push(issue("invalid_version", "$.version", "version must equal 2"));
+  }
+  if (!kind) {
+    issues.push(
+      issue(
+        "invalid_kind",
+        "$.kind",
+        "kind must be no_reply, chat_reply, or action"
+      )
+    );
+  }
+  const allowed = new Set(COMMON_WIRE_KEYS);
+  if (kind === "chat_reply") allowed.add("reply");
+  if (kind === "action") allowed.add("objective");
+  collectUnknownFields(raw, allowed, "$", issues);
+  const expectedTarget = createTelegramInputTargetBinding(context.target);
+  const inputId = readString(raw["input_id"], "$.input_id", issues);
+  if (inputId !== null && inputId !== expectedTarget.inputId) {
+    issues.push(
+      issue(
+        "target_mismatch",
+        "$.input_id",
+        "input_id does not match the host target"
+      )
+    );
+  }
+  const target = validateWireTarget(raw["target"], expectedTarget, issues);
+  if (inputId !== null && target && inputId !== target.inputId) {
+    issues.push(
+      issue(
+        "target_mismatch",
+        "$.input_id",
+        "input_id contradicts target.input_id"
+      )
+    );
+  }
+  const confidence = raw["confidence"];
+  if (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+    issues.push(
+      issue(
+        "invalid_field",
+        "$.confidence",
+        "confidence must be between 0 and 1"
+      )
+    );
+  }
+  const reason = readString(raw["reason"], "$.reason", issues);
+  const addressedActorKeys = readStringArray(
+    raw["addressed_actor_keys"],
+    "$.addressed_actor_keys",
+    issues
+  );
+  const evidenceIds = readStringArray(
+    raw["evidence_ids"],
+    "$.evidence_ids",
+    issues
+  );
+  const rawSelfRole = raw["self_role"];
+  const selfRole = typeof rawSelfRole === "string" && SELF_ROLES.has(rawSelfRole) ? rawSelfRole : null;
+  if (!selfRole) {
+    issues.push(issue("invalid_field", "$.self_role", "self_role is invalid"));
+  }
+  const rawReplyBasis = raw["reply_basis"];
+  const replyBasis = typeof rawReplyBasis === "string" && REPLY_BASES.has(rawReplyBasis) ? rawReplyBasis : null;
+  if (!replyBasis) {
+    issues.push(
+      issue("invalid_field", "$.reply_basis", "reply_basis is invalid")
+    );
+  }
+  const knownActors = new Set(context.actorKeys);
+  for (const actorKey of addressedActorKeys ?? []) {
+    if (!knownActors.has(actorKey)) {
+      issues.push(
+        issue(
+          "unknown_actor_key",
+          "$.addressed_actor_keys",
+          `unknown actor key: ${actorKey}`
+        )
+      );
+    }
+  }
+  const knownEvidence = new Set(context.evidenceIds);
+  for (const evidenceId of evidenceIds ?? []) {
+    if (!knownEvidence.has(evidenceId)) {
+      issues.push(
+        issue(
+          "unknown_evidence_id",
+          "$.evidence_ids",
+          `unknown evidence id: ${evidenceId}`
+        )
+      );
+    }
+  }
+  if (kind === "chat_reply" || kind === "action") {
+    if (selfRole === "observer" || selfRole === "uncertain") {
+      issues.push(
+        issue(
+          "reply_not_authorized",
+          "$.self_role",
+          `${kind} requires an authorized self role`
+        )
+      );
+    }
+    if (replyBasis === "none" || replyBasis === "uncertain") {
+      issues.push(
+        issue(
+          "reply_not_authorized",
+          "$.reply_basis",
+          `${kind} requires an affirmative reply basis`
+        )
+      );
+    }
+    if ((evidenceIds?.length ?? 0) === 0) {
+      issues.push(
+        issue(
+          "reply_not_authorized",
+          "$.evidence_ids",
+          `${kind} requires host evidence`
+        )
+      );
+    }
+  }
+  if (context.selfActorKey && selfRole === "addressee" && addressedActorKeys && !addressedActorKeys.includes(context.selfActorKey)) {
+    issues.push(
+      issue(
+        "reply_not_authorized",
+        "$.addressed_actor_keys",
+        "addressee role must include the host self actor"
+      )
+    );
+  }
+  if (context.selfActorKey && selfRole === "observer" && addressedActorKeys?.includes(context.selfActorKey)) {
+    issues.push(
+      issue(
+        "reply_not_authorized",
+        "$.addressed_actor_keys",
+        "observer role contradicts a self addressee"
+      )
+    );
+  }
+  let reply = null;
+  let objective = null;
+  if (kind === "chat_reply") {
+    reply = readString(raw["reply"], "$.reply", issues);
+  }
+  if (kind === "action") {
+    objective = readString(raw["objective"], "$.objective", issues);
+  }
+  if (issues.length > 0 || !kind || !target || inputId === null || reason === null || !addressedActorKeys || !selfRole || !replyBasis || !evidenceIds || typeof confidence !== "number") {
+    return Object.freeze({
+      ok: false,
+      value: null,
+      issues: Object.freeze([...issues])
+    });
+  }
+  const common = {
+    version: TELEGRAM_TURN_CONTRACT_V2_VERSION,
+    inputId,
+    target,
+    confidence,
+    reason,
+    addressedActorKeys,
+    selfRole,
+    replyBasis,
+    evidenceIds
+  };
+  const value = kind === "chat_reply" ? Object.freeze({ ...common, kind, reply }) : kind === "action" ? Object.freeze({ ...common, kind, objective }) : Object.freeze({ ...common, kind });
+  return Object.freeze({ ok: true, value, issues: Object.freeze([]) });
+}
+function telegramTurnContractV2Fingerprint(contract) {
+  return JSON.stringify({
+    version: contract.version,
+    kind: contract.kind,
+    inputId: contract.inputId,
+    target: contract.target,
+    confidence: contract.confidence,
+    reason: contract.reason,
+    addressedActorKeys: [...contract.addressedActorKeys].sort(),
+    selfRole: contract.selfRole,
+    replyBasis: contract.replyBasis,
+    evidenceIds: [...contract.evidenceIds].sort(),
+    reply: contract.kind === "chat_reply" ? contract.reply : void 0,
+    objective: contract.kind === "action" ? contract.objective : void 0
+  });
+}
+function rawInputId(raw) {
+  return isRecord(raw) && typeof raw["input_id"] === "string" ? raw["input_id"] : null;
+}
+function validateTelegramTurnBatchV2(raw, contexts) {
+  const globalIssues = [];
+  const expected = /* @__PURE__ */ new Map();
+  for (const context of contexts) {
+    const target = createTelegramInputTargetBinding(context.target);
+    if (expected.has(target.inputId)) {
+      throw new TypeError(`duplicate expected inputId: ${target.inputId}`);
+    }
+    expected.set(target.inputId, { ...context, target });
+  }
+  let turns = [];
+  if (!isRecord(raw)) {
+    globalIssues.push(issue("not_object", "$", "batch must be an object"));
+  } else {
+    collectUnknownFields(raw, /* @__PURE__ */ new Set(["version", "turns"]), "$", globalIssues);
+    if (raw["version"] !== TELEGRAM_TURN_CONTRACT_V2_VERSION) {
+      globalIssues.push(
+        issue("invalid_version", "$.version", "version must equal 2")
+      );
+    }
+    if (!Array.isArray(raw["turns"])) {
+      globalIssues.push(
+        issue("invalid_field", "$.turns", "turns must be an array")
+      );
+    } else {
+      turns = raw["turns"];
+    }
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (let index = 0; index < turns.length; index++) {
+    const turn = turns[index];
+    const inputId = rawInputId(turn);
+    if (!inputId) {
+      globalIssues.push(
+        issue(
+          "invalid_field",
+          `$.turns[${index}].input_id`,
+          "turn is not bound to an input"
+        )
+      );
+      continue;
+    }
+    if (!expected.has(inputId)) {
+      globalIssues.push(
+        issue(
+          "unexpected_input",
+          `$.turns[${index}].input_id`,
+          `unexpected input: ${inputId}`
+        )
+      );
+      continue;
+    }
+    const entries = grouped.get(inputId) ?? [];
+    entries.push(turn);
+    grouped.set(inputId, entries);
+  }
+  const dispositions = [];
+  for (const [inputId, context] of expected) {
+    const entries = grouped.get(inputId) ?? [];
+    if (entries.length === 0) {
+      const issues = Object.freeze([
+        issue(
+          "missing_input",
+          "$.turns",
+          `missing disposition for input: ${inputId}`
+        )
+      ]);
+      dispositions.push(
+        Object.freeze({ inputId, status: "missing", contract: null, issues })
+      );
+      continue;
+    }
+    const validations = entries.map(
+      (entry) => validateTelegramTurnContractV2(entry, context)
+    );
+    const invalidIssues = validations.flatMap(
+      (validation) => validation.issues
+    );
+    if (validations.some((validation) => !validation.ok || !validation.value)) {
+      dispositions.push(
+        Object.freeze({
+          inputId,
+          status: "invalid",
+          contract: null,
+          issues: Object.freeze(invalidIssues)
+        })
+      );
+      continue;
+    }
+    const contracts = validations.map((validation) => validation.value);
+    const fingerprints = new Set(
+      contracts.map(telegramTurnContractV2Fingerprint)
+    );
+    if (fingerprints.size > 1) {
+      const issues = Object.freeze([
+        issue(
+          "contradictory_input",
+          "$.turns",
+          `input has contradictory dispositions: ${inputId}`
+        )
+      ]);
+      dispositions.push(
+        Object.freeze({
+          inputId,
+          status: "contradiction",
+          contract: null,
+          issues
+        })
+      );
+      continue;
+    }
+    if (contracts.length > 1) {
+      const issues = Object.freeze([
+        issue(
+          "duplicate_input",
+          "$.turns",
+          `identical disposition repeated for input: ${inputId}`
+        )
+      ]);
+      dispositions.push(
+        Object.freeze({
+          inputId,
+          status: "duplicate",
+          contract: contracts[0],
+          issues
+        })
+      );
+      continue;
+    }
+    dispositions.push(
+      Object.freeze({
+        inputId,
+        status: "accepted",
+        contract: contracts[0],
+        issues: Object.freeze([])
+      })
+    );
+  }
+  const ok = globalIssues.length === 0 && dispositions.every(
+    (disposition) => disposition.status === "accepted" || disposition.status === "duplicate"
+  );
+  return Object.freeze({
+    ok,
+    dispositions: Object.freeze(dispositions),
+    issues: Object.freeze(globalIssues)
+  });
+}
+
+// packages/cli/src/tui/telegram-action-session-registry.ts
+var TelegramActionSessionLeaseError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TelegramActionSessionLeaseError";
+  }
+  code;
+};
+var DEFAULT_TTL_MS = 15 * 6e4;
+var DEFAULT_MAX_ENTRIES = 32;
+function nonEmpty2(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function nonNegativeTime(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(
+      "registry clock must return a non-negative finite number"
+    );
+  }
+  return value;
+}
+function createTelegramActionSessionTarget(target) {
+  return Object.freeze({
+    chatSessionKey: nonEmpty2(target.chatSessionKey, "target.chatSessionKey"),
+    principalKey: nonEmpty2(target.principalKey, "target.principalKey")
+  });
+}
+function telegramActionSessionKey(targetInput) {
+  const target = createTelegramActionSessionTarget(targetInput);
+  return JSON.stringify([target.chatSessionKey, target.principalKey]);
+}
+var TelegramActionSessionRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  create;
+  ttlMs;
+  maxEntries;
+  now;
+  onEvict;
+  generationSequence = 0;
+  leaseSequence = 0;
+  closed = false;
+  constructor(options) {
+    this.create = options.create;
+    this.ttlMs = positiveInteger(options.ttlMs ?? DEFAULT_TTL_MS, "ttlMs");
+    this.maxEntries = positiveInteger(
+      options.maxEntries ?? DEFAULT_MAX_ENTRIES,
+      "maxEntries"
+    );
+    this.now = options.now ?? Date.now;
+    this.onEvict = options.onEvict;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  acquire(options) {
+    if (this.closed) {
+      return {
+        status: "closed",
+        reason: "Telegram action session registry is closed"
+      };
+    }
+    const now = this.readNow();
+    this.pruneExpiredAt(now);
+    const target = createTelegramActionSessionTarget(options.target);
+    const key = telegramActionSessionKey(target);
+    const ownerId = nonEmpty2(options.ownerId, "ownerId");
+    const compatibilityKey = nonEmpty2(
+      options.compatibilityKey,
+      "compatibilityKey"
+    );
+    let entry = this.entries.get(key);
+    if (entry && entry.compatibilityKey !== compatibilityKey) {
+      if (entry.lease) {
+        return {
+          status: "busy",
+          reason: "active session has incompatible runner configuration",
+          current: this.snapshotEntry(entry)
+        };
+      }
+      this.evictEntry(entry, "incompatible");
+      entry = void 0;
+    }
+    if (!entry) {
+      while (this.entries.size >= this.maxEntries) {
+        const evicted = this.evictLeastRecentlyUsedIdle();
+        if (!evicted) {
+          return {
+            status: "capacity",
+            reason: "all bounded Telegram action sessions are active"
+          };
+        }
+      }
+      entry = this.createEntry(target, key, compatibilityKey, now);
+      this.entries.set(key, entry);
+    }
+    if (entry.lease) {
+      return {
+        status: "busy",
+        reason: "Telegram action session already has an active lease",
+        current: this.snapshotEntry(entry)
+      };
+    }
+    const token = Object.freeze({
+      key,
+      generation: entry.generation,
+      leaseId: ++this.leaseSequence,
+      ownerId
+    });
+    entry.lease = {
+      token,
+      onEvent: options.onEvent,
+      onTypedEvent: options.onTypedEvent,
+      runStarted: false
+    };
+    entry.lastUsedAtMs = now;
+    const lease = Object.freeze({
+      token,
+      target: entry.target,
+      run: (input) => this.runLease(token, input),
+      abort: () => this.abortLease(token),
+      release: () => this.releaseLease(token)
+    });
+    return { status: "acquired", lease };
+  }
+  pruneExpired() {
+    return this.pruneExpiredAt(this.readNow());
+  }
+  snapshot() {
+    return Object.freeze(
+      [...this.entries.values()].sort(
+        (left, right) => left.lastUsedAtMs - right.lastUsedAtMs || left.generation - right.generation
+      ).map((entry) => this.snapshotEntry(entry))
+    );
+  }
+  /** Abort active work, dispose every cached resource, and reject new leases. */
+  shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const entry of [...this.entries.values()]) {
+      this.evictEntry(entry, "shutdown");
+    }
+  }
+  createEntry(target, key, compatibilityKey, now) {
+    const generation = ++this.generationSequence;
+    let entry;
+    const resource = this.create(
+      Object.freeze({
+        key,
+        target,
+        generation,
+        onTypedEvent: (event) => {
+          if (entry) this.dispatchTypedEvent(entry, event);
+        }
+      })
+    );
+    if (!resource || !resource.runner) {
+      throw new TypeError("Telegram action session factory returned no runner");
+    }
+    entry = {
+      key,
+      target,
+      generation,
+      compatibilityKey,
+      runner: resource.runner,
+      dispose: resource.dispose,
+      createdAtMs: now,
+      lastUsedAtMs: now,
+      lease: null,
+      disposed: false
+    };
+    resource.runner.onEvent((event) => {
+      if (entry) this.dispatchEvent(entry, event);
+    });
+    return entry;
+  }
+  async runLease(token, input) {
+    const owned = this.ownedEntry(token);
+    if (!owned) {
+      throw new TelegramActionSessionLeaseError(
+        "stale_lease",
+        "Telegram action session lease is no longer authoritative"
+      );
+    }
+    if (owned.lease.runStarted) {
+      throw new TelegramActionSessionLeaseError(
+        "already_started",
+        "Telegram action session lease can run only once"
+      );
+    }
+    owned.lease.runStarted = true;
+    try {
+      await input.prepare?.(owned.entry.runner);
+      return await owned.entry.runner.run(
+        input.task,
+        input.context,
+        input.actualUserGoal
+      );
+    } finally {
+      this.finishLease(token);
+    }
+  }
+  abortLease(token) {
+    const owned = this.ownedEntry(token);
+    if (!owned) return false;
+    try {
+      owned.entry.runner.abort();
+    } catch {
+    }
+    return true;
+  }
+  releaseLease(token) {
+    const owned = this.ownedEntry(token);
+    if (!owned) return "stale";
+    if (owned.lease.runStarted) return "running";
+    owned.entry.lease = null;
+    owned.entry.lastUsedAtMs = this.readNow();
+    return "released";
+  }
+  finishLease(token) {
+    const owned = this.ownedEntry(token);
+    if (!owned) return;
+    owned.entry.lease = null;
+    owned.entry.lastUsedAtMs = this.readNow();
+  }
+  ownedEntry(token) {
+    const entry = this.entries.get(token.key);
+    if (!entry || entry.generation !== token.generation || !entry.lease || entry.lease.token !== token) {
+      return null;
+    }
+    return { entry, lease: entry.lease };
+  }
+  dispatchEvent(entry, event) {
+    const lease = entry.lease;
+    if (!lease?.runStarted || !lease.onEvent) return;
+    try {
+      lease.onEvent(event, lease.token);
+    } catch {
+    }
+  }
+  dispatchTypedEvent(entry, event) {
+    const lease = entry.lease;
+    if (!lease?.runStarted || !lease.onTypedEvent) return;
+    try {
+      lease.onTypedEvent(event, lease.token);
+    } catch {
+    }
+  }
+  pruneExpiredAt(now) {
+    let evicted = 0;
+    for (const entry of [...this.entries.values()]) {
+      if (entry.lease || now - entry.lastUsedAtMs < this.ttlMs) continue;
+      this.evictEntry(entry, "ttl");
+      evicted++;
+    }
+    return evicted;
+  }
+  evictLeastRecentlyUsedIdle() {
+    const candidate = [...this.entries.values()].filter((entry) => !entry.lease).sort(
+      (left, right) => left.lastUsedAtMs - right.lastUsedAtMs || left.generation - right.generation
+    )[0];
+    if (!candidate) return false;
+    this.evictEntry(candidate, "lru");
+    return true;
+  }
+  evictEntry(entry, reason) {
+    if (entry.disposed) return;
+    entry.disposed = true;
+    const snapshot = this.snapshotEntry(entry);
+    entry.lease = null;
+    this.entries.delete(entry.key);
+    try {
+      entry.runner.abort();
+    } catch {
+    }
+    try {
+      entry.dispose?.();
+    } catch {
+    }
+    try {
+      this.onEvict?.(snapshot, reason);
+    } catch {
+    }
+  }
+  snapshotEntry(entry) {
+    return Object.freeze({
+      key: entry.key,
+      target: entry.target,
+      generation: entry.generation,
+      compatibilityKey: entry.compatibilityKey,
+      createdAtMs: entry.createdAtMs,
+      lastUsedAtMs: entry.lastUsedAtMs,
+      busy: Boolean(entry.lease),
+      ownerId: entry.lease?.token.ownerId,
+      leaseId: entry.lease?.token.leaseId,
+      runStarted: entry.lease?.runStarted ?? false
+    });
+  }
+  readNow() {
+    return nonNegativeTime(this.now());
+  }
+};
 export {
   DISCOVERY_KINDS,
   OmniusVersionError,
+  TELEGRAM_COGNITION_AUTHORITY,
+  TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
+  TELEGRAM_TURN_CONTRACT_V2_VERSION,
+  TelegramActionSessionLeaseError,
+  TelegramActionSessionRegistry,
+  TelegramCognitionQueue,
+  TelegramCognitionQueueValidationError,
+  TelegramContextPacketBudgetError,
+  TelegramContextPacketRevisionConflictError,
+  TelegramContextPacketValidationError,
+  TelegramInputOwnershipLedger,
   UnknownProviderProtocolError,
   assertServiceVersion,
   buildProviderHeaders,
   compareOmniusVersions,
+  compileTelegramContextPacketV2,
+  createTelegramActionSessionTarget,
+  createTelegramInputTargetBinding,
   detectProviderDescriptor,
   discoverCapabilities,
   discoveryBootstrap,
@@ -1003,6 +2977,7 @@ export {
   discoverySchemaVersion,
   findDiscoveryCatalogPath,
   getServiceVersion,
+  isTelegramInputTerminalLifecycle,
   isVersionGatedExecutionRequest,
   listProviderDescriptors,
   loadDiscoveryCatalog,
@@ -1011,5 +2986,10 @@ export {
   rankCapabilities,
   resolveProviderDescriptor,
   resolveProviderTransport,
-  showCapability
+  showCapability,
+  telegramActionSessionKey,
+  telegramInputTargetsEqual,
+  telegramTurnContractV2Fingerprint,
+  validateTelegramTurnBatchV2,
+  validateTelegramTurnContractV2
 };