@oxygen-agent/cli 1.632.3 → 1.662.0

package/node_modules/@oxygen/shared/dist/axiom-field-budget.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The `oxygen-logs` field budget — one shared contract for both log shippers.
+ *
+ * WHY THIS EXISTS. Axiom caps a dataset at 1,024 distinct fields. `oxygen-logs`
+ * is shared by the Fly worker, the Vercel web runtime, and the Vercel log drain,
+ * and it reached that cap: measured 2026-08-08, **1,026 fields**. At the cap a
+ * single unrecognised key does not get dropped — Axiom rejects the ENTIRE ingest
+ * batch with HTTP 400, including every schema-stable record travelling with it.
+ *
+ * The worker already survived this, with a 400-triggered fallback that packed
+ * unknown keys into `message` and stayed there for the process lifetime. The web
+ * shipper had no such path: it logged `web.log_shipper.ingest_failed` and threw
+ * the batch away — 409 times in the 7 days to 2026-08-08, invisible to every
+ * Lane A query because the failure line could not ship itself either.
+ *
+ * So the strategy inverts. Instead of reacting to a 400, both shippers now pack
+ * PROACTIVELY: a fixed allowlist stays flat and queryable, and everything else —
+ * including every field any future code invents — is serialized into `message`
+ * under `worker_fields`. New instrumentation can then be added freely without
+ * anyone having to remember that a new key can take down log shipping globally.
+ *
+ * THE ALLOWLIST IS A LOAD-BEARING CONTRACT IN BOTH DIRECTIONS.
+ *
+ * - A field that a monitor, dashboard, or checked-in query reads **flat** must be
+ *   in this set. Removing one does not break ingestion; it silently moves the
+ *   value into `message` and the query starts returning zero, which reads as an
+ *   all-clear forever.
+ * - A field that a monitor reads **out of `worker_fields`** must NOT be here.
+ *   `[P3] OXYGEN Prod Egress order reconcile stuck` does
+ *   `extend wf = parse_json(tostring(message)).worker_fields | dcount(tostring(wf.order_ref))`
+ *   — promoting `order_ref` to a flat field would make `wf.order_ref` null and
+ *   that monitor would report zero stuck orders while orders were stuck.
+ *
+ * Both directions are asserted by `scripts/ci/log-field-budget.mjs` against the
+ * real seed and dashboard JSON, so a change to either side fails loudly instead
+ * of quietly blinding a monitor.
+ */
+/**
+ * Fields that stay top-level in `oxygen-logs`.
+ *
+ * Grouped by why each group is here. Do not add a field without a reader — the
+ * whole point of the budget is that flat columns are a scarce, spoken-for
+ * resource.
+ */
+export declare const AXIOM_STABLE_FIELDS: ReadonlySet<string>;
+/**
+ * The Axiom **map field** every non-allowlisted key is nested under.
+ *
+ * Map fields are Axiom's own answer to this problem and they are strictly better
+ * than the JSON-string packing this module shipped first: data inside a map field
+ * does not count toward the dataset field limit at all, AND it stays natively
+ * queryable with its types intact — `['worker_fields']['order_ref']`, no
+ * `parse_json(tostring(message))` wrapper, no everything-becomes-a-string.
+ *
+ * Proven on `oxygen-logs-dev` 2026-08-08: three records carrying three novel keys
+ * plus a nested object moved the dataset field count by exactly **+1** — the map
+ * field itself — where the same records as flat keys would have cost five columns.
+ *
+ * The name is deliberately unchanged from the old JSON blob's inner key, so every
+ * runbook, monitor, and memory that says "overflow lives in worker_fields" is
+ * still true; only the access path got shorter.
+ *
+ * The map field must EXIST on the dataset before ingest, or the keys land as
+ * ordinary flat fields and the budget is defeated silently. Create it with:
+ *   POST /v2/datasets/{dataset}/mapfields  {"name": "worker_fields"}
+ * `scripts/ops/axiom-mapfields.mjs` does this idempotently for every log dataset.
+ */
+export declare const AXIOM_OVERFLOW_MAP_FIELD = "worker_fields";
+/**
+ * Bound on the serialized overflow, so one pathological record cannot push a whole
+ * batch past Axiom's request limits. 64 KB is far above any real log line and far
+ * below anything that would matter.
+ */
+export declare const MAX_PACKED_MESSAGE_LENGTH: number;
+/**
+ * Splits a flat `log()` record into the allowlisted columns plus one map field
+ * holding everything else.
+ *
+ * The resulting shape is the query contract:
+ *
+ * ```kusto
+ * ['oxygen-logs']
+ * | where msg == 'worker.egress_order_reconcile_stuck'
+ * | summarize dcount(tostring(['worker_fields']['order_ref']))
+ * ```
+ *
+ * `worker_fields` keeps its name even for web records: it is already the word
+ * every existing monitor, dashboard, and runbook uses for "the overflow", and
+ * renaming it would silently zero those queries for no gain.
+ */
+export declare function packAxiomLogRecord(record: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@oxygen/shared/dist/axiom-field-budget.js

@@ -0,0 +1,262 @@
+/**
+ * The `oxygen-logs` field budget — one shared contract for both log shippers.
+ *
+ * WHY THIS EXISTS. Axiom caps a dataset at 1,024 distinct fields. `oxygen-logs`
+ * is shared by the Fly worker, the Vercel web runtime, and the Vercel log drain,
+ * and it reached that cap: measured 2026-08-08, **1,026 fields**. At the cap a
+ * single unrecognised key does not get dropped — Axiom rejects the ENTIRE ingest
+ * batch with HTTP 400, including every schema-stable record travelling with it.
+ *
+ * The worker already survived this, with a 400-triggered fallback that packed
+ * unknown keys into `message` and stayed there for the process lifetime. The web
+ * shipper had no such path: it logged `web.log_shipper.ingest_failed` and threw
+ * the batch away — 409 times in the 7 days to 2026-08-08, invisible to every
+ * Lane A query because the failure line could not ship itself either.
+ *
+ * So the strategy inverts. Instead of reacting to a 400, both shippers now pack
+ * PROACTIVELY: a fixed allowlist stays flat and queryable, and everything else —
+ * including every field any future code invents — is serialized into `message`
+ * under `worker_fields`. New instrumentation can then be added freely without
+ * anyone having to remember that a new key can take down log shipping globally.
+ *
+ * THE ALLOWLIST IS A LOAD-BEARING CONTRACT IN BOTH DIRECTIONS.
+ *
+ * - A field that a monitor, dashboard, or checked-in query reads **flat** must be
+ *   in this set. Removing one does not break ingestion; it silently moves the
+ *   value into `message` and the query starts returning zero, which reads as an
+ *   all-clear forever.
+ * - A field that a monitor reads **out of `worker_fields`** must NOT be here.
+ *   `[P3] OXYGEN Prod Egress order reconcile stuck` does
+ *   `extend wf = parse_json(tostring(message)).worker_fields | dcount(tostring(wf.order_ref))`
+ *   — promoting `order_ref` to a flat field would make `wf.order_ref` null and
+ *   that monitor would report zero stuck orders while orders were stuck.
+ *
+ * Both directions are asserted by `scripts/ci/log-field-budget.mjs` against the
+ * real seed and dashboard JSON, so a change to either side fails loudly instead
+ * of quietly blinding a monitor.
+ */
+/**
+ * Fields that stay top-level in `oxygen-logs`.
+ *
+ * Grouped by why each group is here. Do not add a field without a reader — the
+ * whole point of the budget is that flat columns are a scarce, spoken-for
+ * resource.
+ */
+export const AXIOM_STABLE_FIELDS = new Set([
+    // --- Envelope stamped by log() on every record ---------------------------
+    "ts",
+    "level",
+    "msg",
+    "service_name",
+    "oxygen_version",
+    "sha",
+    "region",
+    "env",
+    "surface",
+    // --- Ambient LogContext (packages/shared/src/log.ts) ----------------------
+    // These are the correlation dimensions every query joins on. A record that
+    // loses them is debuggable only by full-text search.
+    "request_id",
+    "trace_id",
+    "org_id",
+    "organization_id",
+    "user_id",
+    "tool_name",
+    "provider",
+    "operation",
+    "tenant_database_id",
+    "run_id",
+    "chunk_id",
+    "item_id",
+    "worker_id",
+    "conversation_id",
+    // --- Error shape (errorFields) -------------------------------------------
+    "error_id",
+    "error_name",
+    "error_message",
+    "error_code",
+    // Next.js stamps `digest` on a serialized server error; it is the only value
+    // that joins a browser error report back to its `next.request_error` row.
+    "digest",
+    // --- Primitive identity --------------------------------------------------
+    "workflow_id",
+    "workflow_run_id",
+    "table_id",
+    "row_id",
+    "column_id",
+    "action_run_id",
+    "trigger_id",
+    // --- Request/route shape (web, CLI, MCP) ---------------------------------
+    // Read by `cli.command_failed`, `next.request_error`, and the MCP/CLI health
+    // dashboard, which groups failures by route and command.
+    "path",
+    "route",
+    "route_path",
+    "route_type",
+    "router_kind",
+    "method",
+    "command",
+    "latency_ms",
+    "framework_code",
+    "component",
+    // --- Outcome vocabulary --------------------------------------------------
+    "mode",
+    "status",
+    "outcome",
+    "reason",
+    "role",
+    "phase",
+    "step",
+    "dataset",
+    // --- Monitor-critical gauges ---------------------------------------------
+    // Each of these is read FLAT by a monitor in docs/observability/monitors.json.
+    // `broken_tenant_oldest_age_ms` is the value `[P1] Tenant database broken`
+    // alerts on; `pending_count` is what `[P2] tenant migration drift` minimises.
+    "broken_tenant_oldest_age_ms",
+    "pending_count",
+    "divergence",
+    "window_start",
+    // Group keys for `notifyByGroup` alerts. These are what put the offender in
+    // the notification subject — packed away, the alert still fires and names
+    // nobody, which is the whole reason those alerts were grouped.
+    "sender_account_id",
+    "stripe_event_type",
+    // --- Worker queue counters (worker cycle telemetry) ----------------------
+    "queue",
+    "ready",
+    "claimable",
+    "leased",
+    "oldest_pending_age_seconds",
+    "stalled_tenant_count",
+    "active_runs",
+    "skipped_to",
+    "ticket_reason",
+    "queue_wait_ms",
+    "ticket_age_ms",
+    "quantum_duration_ms",
+    "tenants",
+    "claimed",
+    "completed",
+    "skipped",
+    "retrying",
+    "failed",
+    "expired",
+    "finalized",
+    "repaired",
+    "chainChildrenDispatched",
+    "ingestionClaimed",
+    "ingestionCompleted",
+    "ingestionRetrying",
+    "ingestionFailed",
+    "ingestionExpired",
+    "ingestionFinalized",
+    "ingestionRepaired",
+    "workflowClaimed",
+    "workflowCompleted",
+    "workflowRetrying",
+    "workflowFailed",
+    "workflowExpired",
+    "workflowAwaitingApproval",
+    "workflowApprovalsExpired",
+    "workflowWaiting",
+    "workflowCronInitialized",
+    "workflowCronEnqueued",
+    "workflowCronFailed",
+    "linkedinPlanned",
+    "linkedinDispatched",
+    "linkedinDeferred",
+    "linkedinSkipped",
+    "linkedinFailed",
+    "publishingClaimed",
+    "publishingPublished",
+    "publishingFailed",
+    "publishingDeferred",
+    "publishingLeasesRevived",
+    "publishingLeasesFailed",
+]);
+/**
+ * The Axiom **map field** every non-allowlisted key is nested under.
+ *
+ * Map fields are Axiom's own answer to this problem and they are strictly better
+ * than the JSON-string packing this module shipped first: data inside a map field
+ * does not count toward the dataset field limit at all, AND it stays natively
+ * queryable with its types intact — `['worker_fields']['order_ref']`, no
+ * `parse_json(tostring(message))` wrapper, no everything-becomes-a-string.
+ *
+ * Proven on `oxygen-logs-dev` 2026-08-08: three records carrying three novel keys
+ * plus a nested object moved the dataset field count by exactly **+1** — the map
+ * field itself — where the same records as flat keys would have cost five columns.
+ *
+ * The name is deliberately unchanged from the old JSON blob's inner key, so every
+ * runbook, monitor, and memory that says "overflow lives in worker_fields" is
+ * still true; only the access path got shorter.
+ *
+ * The map field must EXIST on the dataset before ingest, or the keys land as
+ * ordinary flat fields and the budget is defeated silently. Create it with:
+ *   POST /v2/datasets/{dataset}/mapfields  {"name": "worker_fields"}
+ * `scripts/ops/axiom-mapfields.mjs` does this idempotently for every log dataset.
+ */
+export const AXIOM_OVERFLOW_MAP_FIELD = "worker_fields";
+/**
+ * Bound on the serialized overflow, so one pathological record cannot push a whole
+ * batch past Axiom's request limits. 64 KB is far above any real log line and far
+ * below anything that would matter.
+ */
+export const MAX_PACKED_MESSAGE_LENGTH = 64 * 1024;
+/**
+ * Splits a flat `log()` record into the allowlisted columns plus one map field
+ * holding everything else.
+ *
+ * The resulting shape is the query contract:
+ *
+ * ```kusto
+ * ['oxygen-logs']
+ * | where msg == 'worker.egress_order_reconcile_stuck'
+ * | summarize dcount(tostring(['worker_fields']['order_ref']))
+ * ```
+ *
+ * `worker_fields` keeps its name even for web records: it is already the word
+ * every existing monitor, dashboard, and runbook uses for "the overflow", and
+ * renaming it would silently zero those queries for no gain.
+ */
+export function packAxiomLogRecord(record) {
+    const stable = {};
+    const overflow = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (AXIOM_STABLE_FIELDS.has(key))
+            stable[key] = value;
+        else
+            overflow[key] = value;
+    }
+    // The capped dataset predates the Copilot column names, so `turn_id` and
+    // `session_id` cannot become flat fields. Copy them into the semantically
+    // equivalent correlation columns that DO exist — a Langfuse trace id is the
+    // turn id, and a Copilot session is the conversation grouping its turns —
+    // while leaving the exact original names inside the packed blob.
+    const copilotTraceId = record.turn_id ?? record.langfuse_trace_id;
+    if (stable.trace_id === undefined &&
+        typeof copilotTraceId === "string" &&
+        copilotTraceId.length > 0) {
+        stable.trace_id = copilotTraceId;
+    }
+    if (stable.conversation_id === undefined &&
+        typeof record.session_id === "string" &&
+        record.session_id.length > 0) {
+        stable.conversation_id = record.session_id;
+    }
+    if (Object.keys(overflow).length === 0)
+        return stable;
+    // Nested under the map field as a real object — NOT stringified. Axiom stores
+    // map contents without allocating a column per key, and keeps them queryable
+    // and typed.
+    stable[AXIOM_OVERFLOW_MAP_FIELD] =
+        JSON.stringify(overflow).length <= MAX_PACKED_MESSAGE_LENGTH
+            ? overflow
+            : {
+                // Never silently truncate to nothing: the key NAMES alone are usually
+                // enough to identify which call site produced the oversized record.
+                _truncated: true,
+                _keys: Object.keys(overflow),
+            };
+    return stable;
+}

package/node_modules/@oxygen/shared/dist/capability-discovery.js

@@ -87,6 +87,42 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         endpointSections: ["admin", "db", "worker"],
         intentTerms: ["admin", "worker", "queue", "tenant repair", "database", "db status", "stuck jobs", "operations"],
     },
+    {
+        // Control-layer interaction state, deliberately NOT a sixteenth primitive
+        // (ADR 0020): a comment or an approval request is state ABOUT a GTM
+        // artifact, and the hard gate is honored by the owning primitive's own
+        // route. `primitive: null` is what keeps the fifteen-primitive assertion
+        // in OXYGEN_PRIMITIVE_ROUTES true.
+        id: "collaboration",
+        layer: "Control",
+        primitive: null,
+        owns: "Threaded internal comments on any workspace object, second-party approval requests, the opt-in gate that blocks a live action until approved, and the restricted client role.",
+        notFor: "Public comments on a published post (Posts/Publishing), the artifact itself, or a run's own approval card — those belong to their owning primitive.",
+        execution: "Comment or request a decision on a subject reference (`<kind>:<id>`); an admin arms the gate, and the owning primitive refuses its live path until an approval lands.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_approvals_inbox", "oxygen_approvals_request", "oxygen_approvals_decide", "oxygen_comments_add", "oxygen_comments_list", "oxygen_approvals_gate_set"],
+        gatewayCommands: ["approvals inbox", "approvals request", "approvals decide", "comments add", "comments list", "approvals gate set"],
+        skills: ["oxygen-collaboration"],
+        endpointSections: ["collab"],
+        intentTerms: [
+            "collaboration",
+            "comment thread",
+            "internal comment",
+            "leave a comment",
+            "sign off",
+            "signoff",
+            "approval request",
+            "request approval",
+            "approval gate",
+            "client approval",
+            "client review",
+            "client login",
+            "client role",
+            "go no go",
+            "waiting on me",
+        ],
+        negativeTerms: ["public comment", "linkedin comment", "post comment"],
+    },
     {
         id: "agency-directory",
         layer: "Control",
@@ -188,7 +224,7 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         gatewayCommands: ["publishing comments list", "publishing analytics summary", "posts get", "posts create"],
         skills: ["oxygen-linkedin-marketing"],
         endpointSections: [],
-        intentTerms: ["post artifact", "social post", "post comments", "public comments", "comments needing reply", "post reactions", "post performance", "posting analytics", "broadcast content"],
+        intentTerms: ["post artifact", "social post", "post comments", "public comments", "unanswered comments", "comments needing reply", "owned posts", "post reactions", "post performance", "posting analytics", "broadcast content"],
     },
     {
         id: "signals",
@@ -475,6 +511,16 @@ function explicitCapabilityIntent(query) {
         return ROUTE_BY_PRIMITIVE.get("workflows") ?? null;
     if (isOwnedPostCommentIntent(query))
         return ROUTE_BY_PRIMITIVE.get("posts") ?? null;
+    // Asking a second party to decide is Collaboration even when the thing being
+    // decided is a campaign, a table, or a post — the subject noun would
+    // otherwise win outright ("campaign" is an explicit Sequences intent below,
+    // and that is right for every ask that is not about the decision itself).
+    // Deliberately narrow: bare "approve"/"approval" stays with the owning
+    // primitive (a publishing approval, an Observability approval queue), and
+    // this sits after the owned-post-comment check so a PUBLIC comment on a
+    // published post still routes to Posts.
+    if (isSecondPartyDecisionIntent(query))
+        return ROUTE_BY_ID.get("collaboration") ?? null;
     // A deferred acquisition motion starts with the public-data owner. This keeps
     // "find/qualify now, contact later" from skipping straight to the final write
     // step; the recommendation still hands the eventual initiation to Sequences.
@@ -743,12 +789,21 @@ function isNetNewLinkedInInitiation(query) {
         return false;
     return !/\b(sequence|campaign|cadence|enroll|nurture|multi[ -]step|multi[ -]recipient|leads|contacts|recipients|audience|rotate senders?|stop on reply|day\s*\d+)\b/.test(query);
 }
+function isSecondPartyDecisionIntent(query) {
+    const decisionLanguage = /\b(sign ?off|signoff|approval request|request approval|approval gate|go no go)\b/.test(query);
+    const clientDecision = /\bclient\b.{0,20}\b(approv\w*|sign ?off|review|decide|decision|login|role)\b/.test(query)
+        || /\b(approv\w*|sign ?off|decision)\b.{0,20}\bfrom the client\b/.test(query);
+    const internalThread = /\b(comment|comments|thread)\b/.test(query)
+        && /\b(internal|client|teammate|workspace member|discuss)\b/.test(query)
+        && !/\b(linkedin|public|published|post|posts|publishing)\b/.test(query);
+    return decisionLanguage || clientDecision || internalThread;
+}
 function isOwnedPostCommentIntent(query) {
     if (!/\bcomments?\b/.test(query) || !/\b(linkedin|posts?|publishing)\b/.test(query))
         return false;
-    const owned = /\b(my|our|own)\b|\boxygen[ -]published\b|\bpublished through oxygen\b/.test(query);
+    const owned = /\b(my|our|own|owned)\b|\boxygen[ -]published\b|\bpublished through oxygen\b/.test(query);
     const operatorWork = /\b(needs?|needing|awaiting)\b.{0,20}\b(response|reply|answer)\b/.test(query)
-        || /\b(reply|respond|answer|triage|queue)\b/.test(query);
+        || /\b(reply|respond|answer|triage|queue|unanswered|unreplied)\b/.test(query);
     return owned || operatorWork;
 }
 function isHostedWorkflowIntent(query) {
@@ -770,7 +825,7 @@ function isPublicLinkedInRead(query) {
         return false;
     const disclaimsConnectedAccount = /\b(without|no|not using|does not require)\b.{0,24}\bconnected(?: linkedin)? account\b/.test(query);
     const connectedOwnership = !disclaimsConnectedAccount
-        && /\b(my|our|own|connected|connections|followers|inbox|messages|recruiter|sales\s*navigator|salesnav|unipile|viewers)\b/.test(query);
+        && /\b(my|our|own|owned|connected|connections|followers|inbox|messages|recruiter|sales\s*navigator|salesnav|unipile|viewers)\b/.test(query);
     if (connectedOwnership)
         return false;
     return /\b(comments?|companies|company|competitor|cookieless|engagers?|harvest|posts?|profiles?|public|reactions?|reactors?|scrape|scraper|search|third[ -]party)\b/.test(query);