@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-K5UJD6MM.js

@@ -0,0 +1,39 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESET_IDS
+} from "./chunk-QUIJZSDW.js";
+import {
+  StringEnum
+} from "./chunk-QLAGXTTV.js";
+import {
+  ToolNames
+} from "./chunk-WLHX3MM5.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/panes-surface.ts
+init_esm_shims();
+var panesToolSurface = {
+  name: ToolNames.Panes,
+  description: "Manage the terminal panes Clio owns beside this session: show focuses a dispatched run's viewer pane, open starts a fixed utility preset (files, logs, or shell; never an arbitrary command) or focuses it when it is already open, close removes a Clio-created pane, list reports the inventory and the pane layer's health.",
+  parameters: typebox_exports.Object({
+    action: StringEnum(["show", "open", "close", "list"], { description: "Pane action." }),
+    target: typebox_exports.Optional(
+      typebox_exports.String({
+        description: 'show: an agent id or run id prefix, most recent match wins. close: a pane id, label, agent id, or "all".'
+      })
+    ),
+    preset: typebox_exports.Optional(StringEnum([...PANES_PRESET_IDS], { description: "open: which utility pane to start." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "sequential"
+};
+
+export {
+  panesToolSurface
+};
+//# sourceMappingURL=chunk-K5UJD6MM.js.map

package/dist/chunk-KGP3UQGJ.js

@@ -0,0 +1,200 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  receiptGatewayRoutingLabel,
+  receiptResponseModelIdObservationLabel
+} from "./chunk-5W4FRA5Q.js";
+import {
+  adaptRunReceiptTrustStatus,
+  formatTrustAxes,
+  formatTrustSummary
+} from "./chunk-FB3KTE2J.js";
+import {
+  formatBudgetPolicy,
+  formatBudgetReasons,
+  formatBudgetRequest,
+  formatEffectiveBudget
+} from "./chunk-MWMW53WW.js";
+import {
+  RESULT_SUMMARY_MAX_BYTES_CEILING,
+  resultContractAuthorship
+} from "./chunk-ARRUMZ7X.js";
+import {
+  mentionsWorkerToolCallCap
+} from "./chunk-C27U2TYG.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/worker-evidence.ts
+init_esm_shims();
+var SOURCE_CITATION_PATTERN = /([\w./~-]+):(\d+)/g;
+function sourceCitations(text) {
+  const citations = [];
+  for (const match of text.matchAll(SOURCE_CITATION_PATTERN)) {
+    const path = match[1];
+    const line = Number(match[2]);
+    if (path && Number.isSafeInteger(line) && line > 0) citations.push({ path, line });
+  }
+  return citations;
+}
+function hasSourceCitation(text) {
+  return sourceCitations(text).length > 0;
+}
+var SPOT_CHECK_GUIDANCE = 'Spot-check delegated claims before repeating them: re-read any cited file:line location, and re-run or inspect the named validation before repeating a "tests pass" claim.';
+function isMutationClassRun(receipt, status) {
+  if (status.validationGrounding.state === "not_applicable") return false;
+  if (receipt.executionRole === "builder" || receipt.executionRole === "recovery") return true;
+  return receipt.quality?.resultContract?.sourceId?.startsWith("agent-result-contract:mutation-report") === true;
+}
+function receiptAdmissionLabels(receipt) {
+  const labels = [];
+  const mismatch = receipt.capabilityMismatch;
+  if (mismatch !== void 0) {
+    labels.push(
+      `capability_mismatch=${mismatch.capabilityClass}/${mismatch.taskType}${mismatch.suggestedAgentId === null ? "" : ` suggested:${mismatch.suggestedAgentId}`}`
+    );
+  }
+  const grounding = receipt.validationGrounding;
+  if (grounding !== void 0) {
+    labels.push(
+      `validations=claimed:${grounding.claimed} grounded:${grounding.grounded}${grounding.ungrounded.length > 0 ? ` ${grounding.basis === "no-command-executed" ? "unverifiable" : "unmatched"}:${grounding.ungrounded.map((name) => JSON.stringify(name)).join(",")}` : ""}`
+    );
+  }
+  return labels;
+}
+function receiptActivityLabels(receipt, status) {
+  const labels = [];
+  const activity = receipt.toolActivity;
+  if (activity !== void 0) {
+    labels.push(
+      `work=calls:${activity.calls} ok:${activity.succeeded} failed:${activity.failed} blocked:${activity.blocked} mutations:${activity.mutatingSucceeded ? "yes" : "no"}`
+    );
+    if (!activity.mutatingSucceeded && isMutationClassRun(receipt, status)) labels.push("mutation_effect=none");
+  }
+  const findings = receipt.findingsSummary;
+  if (findings !== void 0) {
+    if (!findings.firstPassSuccess) labels.push("first_pass=false");
+    if (findings.tags.length > 0) labels.push(`findings=${[...findings.tags].sort().join(",")}`);
+  }
+  return labels;
+}
+function receiptEvidenceLabels(receipt, verification, integrity) {
+  const status = adaptRunReceiptTrustStatus({ ...receipt, verification }, { integrity });
+  const canonical = canonicalTrustLabels(status);
+  if (!integrity.ok) {
+    return [...canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
+  }
+  const briefing = receipt.briefing === void 0 ? "briefing=none" : `briefing=bytes:${receipt.briefing.bytes} sha256:${receipt.briefing.contentHash}`;
+  let projectContext = "project_context=absent";
+  if (receipt.projectContext !== void 0) {
+    const sections = receipt.projectContext.sections ?? [];
+    projectContext = `project_context=${receipt.projectContext.tier} chars:${receipt.projectContext.chars ?? 0}${sections.length > 0 ? ` sections:${[...sections].sort().join(",")}` : ""}${receipt.projectContext.contentHash !== void 0 ? ` sha256:${receipt.projectContext.contentHash}` : ""}`;
+  }
+  const responseModelIdObservation = receiptResponseModelIdObservationLabel(receipt);
+  const gatewayRouting = receiptGatewayRoutingLabel(receipt);
+  const budget = receipt.budget === void 0 ? [] : [
+    `budget_recipe_policy=${JSON.stringify(formatBudgetPolicy(receipt.budget))}`,
+    `budget_requested=${JSON.stringify(formatBudgetRequest(receipt.budget))}`,
+    `budget_effective=${JSON.stringify(formatEffectiveBudget(receipt.budget))}`,
+    `budget_reason=${JSON.stringify(formatBudgetReasons(receipt.budget))}`
+  ];
+  return [
+    ...canonical,
+    `receipt_integrity=verified/v${receipt.integrity.version}/${receipt.integrity.algorithm}`,
+    ...documenterDeliveryLabels(receipt),
+    `evidence_verification=${verification.state}/${verification.basis}`,
+    `host_verification=${receipt.hostVerification?.status ?? "not_requested"}`,
+    ...responseModelIdObservation ? [responseModelIdObservation] : [],
+    ...gatewayRouting ? [gatewayRouting] : [],
+    ...budget,
+    ...receiptAdmissionLabels(receipt),
+    ...receiptActivityLabels(receipt, status),
+    briefing,
+    ...receipt.workerContext ? [
+      `context=${receipt.workerContext.mode} tokens:${receipt.workerContext.estimatedTokens} omitted:${receipt.workerContext.omittedMessages} sha256:${receipt.workerContext.contentHash}`
+    ] : [],
+    projectContext
+  ];
+}
+function documenterDeliveryLabels(receipt) {
+  if (receipt.agentId !== "documenter" || !receipt.quality.resultContract?.sourceId.startsWith("agent-result-contract:mutation-report:"))
+    return [];
+  const output = receipt.output;
+  const summary = output?.state === "final" ? resultContractAuthorship(
+    { kind: "mutation-report", maxSummaryBytes: RESULT_SUMMARY_MAX_BYTES_CEILING },
+    output.text
+  ).summary : null;
+  return [
+    `terminal Documenter result: ${summary === null ? "no inline summary is available" : "the inline deliverable or limitation is in output.text JSON field summary"}. Execution success and contract conformance alone do not prove the requested explanation was delivered.`,
+    "Read the summary or the task-authorized artifact once and check it against the requested deliverable. If it is absent, incomplete, or states a limitation, report the specific limitation and the run ID; do not repeatedly read this unchanged terminal receipt or poll it for new output. Keep any separately authorized recovery and its outcome distinct from the original run."
+  ];
+}
+function canonicalTrustLabels(status) {
+  return [`trust=${JSON.stringify(formatTrustSummary(status))}`, formatTrustAxes(status)];
+}
+function workerTextLabel(status) {
+  switch (status.validationGrounding.state) {
+    case "validated":
+      return "worker output (tool-verified):";
+    case "not_applicable":
+      return "reconnaissance output (advisory leads, not validation evidence):";
+    case "unknown":
+      return "worker claims (validation not observable at this layer):";
+    // The three remaining states were one label. The evidence bundle tells
+    // a failed check, an inferred claim, and no validation at all apart, so
+    // the terminal must too or it hands the operator a coarser verdict than
+    // the report for the same run.
+    case "failed":
+      return "worker claims (validation failed; a check ran and did not pass):";
+    case "ungrounded":
+      return "worker claims (inferred; validation claimed, none observed):";
+    default:
+      return "worker claims (unverified prose):";
+  }
+}
+function workerTextNonEvidenceNotices(receipt, status, answerText) {
+  const notices = [];
+  const failedRun = receipt.exitCode !== 0 || receipt.outcome !== void 0 && receipt.outcome !== "succeeded";
+  if (mentionsWorkerToolCallCap(receipt.failureMessage) || mentionsWorkerToolCallCap(receipt.outcomeDetail)) {
+    notices.push(
+      answerText.length > 0 ? "non-evidence: the worker exhausted its tool-call cap; the text above is a partial synthesis, not verified results." : "non-evidence: the worker exhausted its tool-call cap before a final synthesis was captured."
+    );
+  } else if (failedRun) {
+    notices.push(
+      "non-evidence: this run did not succeed; treat the text above as an unsubstantiated report, not results."
+    );
+  }
+  if (receipt.toolActivity !== void 0 && receipt.toolActivity.succeeded === 0) {
+    notices.push("non-evidence: no tool call succeeded in this run; the text above was written without observed work.");
+  } else if (receipt.toolActivity?.mutatingSucceeded === false && isMutationClassRun(receipt, status)) {
+    notices.push(
+      "non-evidence: this run was dispatched as work that changes the tree, but no mutating tool call succeeded. Nothing was written. Confirm with a diff before repeating any claim that something was fixed."
+    );
+  }
+  const grounding = receipt.validationGrounding;
+  if (grounding !== void 0 && grounding.ungrounded.length > 0) {
+    const named = grounding.ungrounded.map((name) => JSON.stringify(name)).join(", ");
+    notices.push(
+      grounding.basis === "no-command-executed" ? `non-evidence: this run reported ${named} as passing and executed no command at all. Re-run the check yourself before repeating the claim.` : `non-evidence: this run reported ${named} as passing through a command the harness cannot identify as that check. Re-run it before repeating the claim.`
+    );
+  }
+  if (receipt.capabilityMismatch !== void 0) {
+    notices.push(
+      `non-evidence: '${receipt.capabilityMismatch.agentId}' is a ${receipt.capabilityMismatch.capabilityClass} recipe and cannot write to the workspace, but this task classified as ${receipt.capabilityMismatch.taskType}. Nothing it reports as changed can have been changed by it.`
+    );
+  }
+  if (!failedRun && status.validationGrounding.state === "not_applicable" && answerText.length > 0 && !hasSourceCitation(answerText)) {
+    notices.push(
+      "non-evidence: this reconnaissance answer cites no file:line locations; treat its leads as unconfirmed."
+    );
+  }
+  return notices;
+}
+
+export {
+  SPOT_CHECK_GUIDANCE,
+  receiptEvidenceLabels,
+  workerTextLabel,
+  workerTextNonEvidenceNotices
+};
+//# sourceMappingURL=chunk-KGP3UQGJ.js.map

package/dist/chunk-KKRXONXG.js

@@ -0,0 +1,43 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// apps/clio-coder-web/contracts/common.ts
+init_esm_shims();
+var Id = typebox_exports.String({ pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" });
+var PageCursor = typebox_exports.String({ maxLength: 1024, pattern: "^[A-Za-z0-9_-]+$" });
+var Empty = typebox_exports.Object({}, { additionalProperties: false });
+var ProblemCode = typebox_exports.Union([
+  typebox_exports.Literal("validation"),
+  typebox_exports.Literal("unauthorized"),
+  typebox_exports.Literal("not_found"),
+  typebox_exports.Literal("conflict"),
+  typebox_exports.Literal("unsupported"),
+  typebox_exports.Literal("unavailable"),
+  typebox_exports.Literal("upstream_acp"),
+  typebox_exports.Literal("operation_failed"),
+  typebox_exports.Literal("internal")
+]);
+var Problem = typebox_exports.Object(
+  {
+    type: typebox_exports.String(),
+    title: typebox_exports.String(),
+    status: typebox_exports.Integer(),
+    detail: typebox_exports.String(),
+    code: ProblemCode,
+    instance: typebox_exports.String()
+  },
+  { additionalProperties: false }
+);
+
+export {
+  Id,
+  PageCursor,
+  Empty,
+  Problem
+};
+//# sourceMappingURL=chunk-KKRXONXG.js.map

package/dist/chunk-KWJXCL2X.js

@@ -0,0 +1,103 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  appendOutOfTurnUsageRow
+} from "./chunk-W7KNI3F5.js";
+import {
+  extractReasoningTokens
+} from "./chunk-OPC4DQD6.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/observability/compaction-usage.ts
+init_esm_shims();
+function observedUsage(call) {
+  const raw = isRecord(call.usage) ? call.usage : {};
+  const reading = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && (call.outcome === "success" || value > 0) ? value : null;
+  const cost = isRecord(raw.cost) ? reading(raw.cost.total) : null;
+  const costUsd = cost !== null && cost > 0 ? cost : null;
+  const reasoning = extractReasoningTokens({ ...raw, reasoningTokens: void 0 });
+  return {
+    input: reading(raw.input),
+    output: reading(raw.output),
+    cacheRead: reading(raw.cacheRead),
+    cacheWrite: reading(raw.cacheWrite),
+    ...raw.cacheWrite1h === void 0 ? {} : { cacheWrite1h: reading(raw.cacheWrite1h) },
+    reasoning: reasoning !== null && reasoning > 0 ? reasoning : null,
+    totalTokens: reading(raw.totalTokens),
+    costUsd,
+    costProvenance: costUsd === null ? "unknown" : "estimated"
+  };
+}
+function recordFailedCompactionCalls(origin, calls, observability) {
+  for (const call of calls) {
+    const usage = observedUsage(call);
+    const row = {
+      label: "failed-compaction",
+      callOutcome: call.outcome,
+      sessionId: origin.sessionId,
+      repoIdentity: origin.repoIdentity,
+      timestamp: call.timestamp,
+      target: origin.target,
+      attributedModelId: origin.model,
+      usage,
+      timing: { durationMs: call.durationMs }
+    };
+    appendOutOfTurnUsageRow(origin.stateDir, row, { required: true });
+    if (!Object.values(usage).some((value) => typeof value === "number" && value > 0)) continue;
+    observability?.recordTokens(
+      origin.target,
+      origin.model,
+      usage.totalTokens ?? 0,
+      usage.costUsd ?? 0,
+      {
+        input: usage.input ?? 0,
+        output: usage.output ?? 0,
+        cacheRead: usage.cacheRead ?? 0,
+        cacheWrite: usage.cacheWrite ?? 0,
+        ...typeof usage.cacheWrite1h === "number" ? { cacheWrite1h: usage.cacheWrite1h } : {},
+        reasoningTokens: usage.reasoning ?? 0,
+        totalTokens: usage.totalTokens ?? 0,
+        apiCalls: 1
+      },
+      usage.costProvenance,
+      void 0,
+      "failed-compaction"
+    );
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var USAGE_FIELDS = ["input", "output", "cacheRead", "cacheWrite", "reasoning", "totalTokens", "costUsd"];
+function summarizeFailedCompactionUsage(rows) {
+  const calls = rows.filter((row) => row.label === "failed-compaction");
+  const knownUsage = Object.fromEntries(USAGE_FIELDS.map((field) => [field, null]));
+  const erroredKnownUsage = { ...knownUsage };
+  const unobservedUsageCalls = Object.fromEntries(USAGE_FIELDS.map((field) => [field, 0]));
+  for (const row of calls) {
+    for (const field of USAGE_FIELDS) {
+      const value = row.usage[field];
+      if (value === null) unobservedUsageCalls[field] += 1;
+      else {
+        knownUsage[field] = (knownUsage[field] ?? 0) + value;
+        if (row.callOutcome === "error") erroredKnownUsage[field] = (erroredKnownUsage[field] ?? 0) + value;
+      }
+    }
+  }
+  return {
+    calls: calls.length,
+    successfulCalls: calls.filter((row) => row.callOutcome === "success").length,
+    erroredCalls: calls.filter((row) => row.callOutcome === "error").length,
+    abortedCalls: calls.filter((row) => row.callOutcome === "aborted").length,
+    knownUsage,
+    erroredKnownUsage,
+    unobservedUsageCalls
+  };
+}
+
+export {
+  recordFailedCompactionCalls,
+  summarizeFailedCompactionUsage
+};
+//# sourceMappingURL=chunk-KWJXCL2X.js.map