@oxygen-agent/cli 1.894.0 → 1.917.5

package/node_modules/@oxygen/formula/dist/expression.d.ts

@@ -41,6 +41,27 @@ export type ParseOptions = {
 export declare function parseFormulaExpression(expression: string, options?: ParseOptions): FormulaAst;
 /** Validate supported functions and arity on an already-parsed tree. */
 export declare function validateFormulaAst(ast: FormulaAst): void;
+/**
+ * SAVE-TIME ONLY: reject a literal regex pattern that is too long to ever compile.
+ *
+ * Deliberately NOT part of validateFormulaAst. That runs on the READ path too
+ * (formula-column-runner prepares every batch through it) and
+ * prepareFormulaForRead swallows the throw and nulls the WHOLE column, so
+ * tightening it would silently blank already-stored columns rather than reject
+ * the edit. Keeping this save-only means a column that stores today keeps
+ * reading today, and only a NEW write is refused.
+ *
+ * Length is checked, not compilation. A pattern over the cap can never succeed in
+ * any branch, so flagging it costs the author nothing -- whereas rejecting an
+ * unparseable literal would break `if(cond, regex_match(x, "["), "n/a")`, which
+ * works today precisely because if/switch/and/or/coalesce are lazy and never
+ * evaluate the untaken side. That stricter semantic is a separate decision.
+ *
+ * Without this, an over-long pattern stored fine and then failed per row on every
+ * run forever -- the production shape was one column failing across dozens of rows
+ * for days with received_length 290 against the old 256 cap.
+ */
+export declare function validateFormulaRegexLiterals(ast: FormulaAst): void;
 /** Validate syntax, supported functions, and arity without evaluating any data. */
 export declare function validateFormulaExpression(expression: string, options?: ParseOptions): void;
 export declare function walkExpression(node: FormulaAst, visit: (node: FormulaAst) => void): void;

package/node_modules/@oxygen/formula/dist/expression.js

@@ -1,4 +1,4 @@
-import { FORMULA_FUNCTION_REGISTRY, checkFormulaFunctionArity, formulaExpressionError, } from "./formula-functions.js";
+import { FORMULA_FUNCTION_REGISTRY, MAX_FORMULA_REGEX_PATTERN_LENGTH, checkFormulaFunctionArity, formulaExpressionError, } from "./formula-functions.js";
 /**
  * Functions evaluated against the whole column rather than the current scope.
  * They are intercepted before registry dispatch (the registry entry carries
@@ -37,6 +37,47 @@ export function validateFormulaAst(ast) {
         checkFormulaFunctionArity(spec, node.args.length);
     });
 }
+/**
+ * SAVE-TIME ONLY: reject a literal regex pattern that is too long to ever compile.
+ *
+ * Deliberately NOT part of validateFormulaAst. That runs on the READ path too
+ * (formula-column-runner prepares every batch through it) and
+ * prepareFormulaForRead swallows the throw and nulls the WHOLE column, so
+ * tightening it would silently blank already-stored columns rather than reject
+ * the edit. Keeping this save-only means a column that stores today keeps
+ * reading today, and only a NEW write is refused.
+ *
+ * Length is checked, not compilation. A pattern over the cap can never succeed in
+ * any branch, so flagging it costs the author nothing -- whereas rejecting an
+ * unparseable literal would break `if(cond, regex_match(x, "["), "n/a")`, which
+ * works today precisely because if/switch/and/or/coalesce are lazy and never
+ * evaluate the untaken side. That stricter semantic is a separate decision.
+ *
+ * Without this, an over-long pattern stored fine and then failed per row on every
+ * run forever -- the production shape was one column failing across dozens of rows
+ * for days with received_length 290 against the old 256 cap.
+ */
+export function validateFormulaRegexLiterals(ast) {
+    walkExpression(ast, (node) => {
+        if (node.type !== "call")
+            return;
+        const normalized = node.name.toLowerCase();
+        if (normalized !== "regex_match" && normalized !== "regex_extract" && normalized !== "regex_replace") {
+            return;
+        }
+        // Every regex function takes its pattern as the second argument.
+        const pattern = node.args[1];
+        if (!pattern || pattern.type !== "literal" || typeof pattern.value !== "string")
+            return;
+        if (pattern.value.length <= MAX_FORMULA_REGEX_PATTERN_LENGTH)
+            return;
+        throw formulaExpressionError("Regular-expression pattern is too long.", {
+            function: node.name,
+            max_length: MAX_FORMULA_REGEX_PATTERN_LENGTH,
+            received_length: pattern.value.length,
+        });
+    });
+}
 /** Validate syntax, supported functions, and arity without evaluating any data. */
 export function validateFormulaExpression(expression, options = {}) {
     validateFormulaAst(parseFormulaExpression(expression, options));

package/node_modules/@oxygen/formula/dist/formula-functions.d.ts

@@ -37,7 +37,7 @@ export type FormulaFunctionSpec = FormulaFunctionMeta & {
     evaluate?: (args: unknown[]) => unknown;
     evaluateLazy?: (thunks: Array<() => unknown>) => unknown;
 };
-export declare const MAX_FORMULA_REGEX_PATTERN_LENGTH = 256;
+export declare const MAX_FORMULA_REGEX_PATTERN_LENGTH = 1000;
 export declare const MAX_FORMULA_REGEX_INPUT_LENGTH = 20000;
 export declare function formulaExpressionError(message: string, details: Record<string, unknown>): OxygenError;
 export declare function isBlankFormulaValue(value: unknown): boolean;

package/node_modules/@oxygen/formula/dist/formula-functions.js

@@ -1,7 +1,16 @@
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { walkJsonPath } from "@oxygen/shared/json-path";
 import { normalizeDomain, normalizeEmail, normalizeLinkedinUrl, } from "./value-normalizers.js";
-export const MAX_FORMULA_REGEX_PATTERN_LENGTH = 256;
+// Pattern LENGTH is not a safety bound and never was -- catastrophic backtracking
+// is a function of pattern SHAPE, and `(a+)+$` hangs at 6 characters, so 256 already
+// permitted an unbounded hang while rejecting harmless long literals. The real bound
+// on scan cost is MAX_FORMULA_REGEX_INPUT_LENGTH below, which caps what a pattern is
+// run against. 256 rejected a customer's 290-character alternation on every row of
+// their table, continuously, for days (production 2026-08-28/31). Raised to a value
+// that still stops a pathological paste while leaving ordinary generated alternations
+// room. If real ReDoS protection is ever needed it belongs in the engine (a
+// backtracking budget or re2), not in a character count.
+export const MAX_FORMULA_REGEX_PATTERN_LENGTH = 1_000;
 export const MAX_FORMULA_REGEX_INPUT_LENGTH = 20_000;
 // ---------------------------------------------------------------------------
 // Shared coercion helpers (used by the registry AND the runner's operators)

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

@@ -21,15 +21,20 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         id: "discovery-and-skills",
         layer: "Control",
         primitive: null,
-        owns: "Bounded capability, command, provider-operation, Recipe, and product-skill discovery with exact hydration on demand.",
+        owns: "Bounded capability, command, provider-operation, Recipe, and product-skill discovery, plus INSTANCE discovery — what this workspace actually holds — with exact hydration on demand.",
         notFor: "Executing GTM work or loading full manifests and schemas before a capability is selected.",
-        execution: "Search by outcome, choose the owner, then hydrate one exact command, MCP schema, provider descriptor, or skill.",
+        execution: "Search by outcome, choose the owner, then hydrate one exact command, MCP schema, provider descriptor, or skill. For instance discovery, read the map and then the primitive that owns the row.",
         posture: "read_only",
-        gatewayTools: ["oxygen_capabilities_search", "oxygen_tools_search", "oxygen_recipes_list"],
-        gatewayCommands: ["capabilities search", "commands search", "skills search", "tools search", "recipes list"],
+        gatewayTools: ["oxygen_capabilities_search", "oxygen_tools_search", "oxygen_recipes_list", "oxygen_workspace_map"],
+        gatewayCommands: ["capabilities search", "commands search", "skills search", "tools search", "recipes list", "workspace map"],
         skills: ["oxygen-quickstart", "oxygen-gtm"],
-        endpointSections: ["skills"],
-        intentTerms: ["discover", "discovery", "capability", "capabilities", "command", "commands", "skill", "skills", "which tool", "how do i"],
+        // `workspace` (the map) belongs here rather than beside `home`: capability
+        // discovery answers what OXYGEN can do and instance discovery answers what THIS
+        // workspace holds, and they are the same act — bounded, read-only, hydrate one
+        // thing on demand. `home` stayed on the onboarding card because the standup is a
+        // first-run surface; the map is not.
+        endpointSections: ["skills", "workspace"],
+        intentTerms: ["discover", "discovery", "capability", "capabilities", "command", "commands", "skill", "skills", "which tool", "how do i", "what do i have", "what is in my workspace", "workspace map"],
     },
     {
         id: "onboarding-and-copilot",
@@ -537,6 +542,13 @@ function normalizeIntent(query) {
     return query.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
 }
 function explicitCapabilityIntent(query) {
+    // A unified sender profile is an owned Sequence identity, even when the ask
+    // names every attached channel (LinkedIn + WhatsApp + email). Resolve this
+    // before public LinkedIn research, whose generic "profile" wording would
+    // otherwise route an account-readiness question to scraper tools.
+    if (isSenderProfileIntent(query)) {
+        return ROUTE_BY_PRIMITIVE.get("sequences") ?? null;
+    }
     if (isInboxAvatarIntent(query)) {
         return ROUTE_BY_ID.get("sending-infrastructure") ?? null;
     }
@@ -765,6 +777,12 @@ function recommendationsFor(card, query) {
         }
     }
     if (card.primitive === "sequences") {
+        if (isSenderProfileIntent(query)) {
+            return {
+                tools: ["oxygen_senders_profiles_list", "oxygen_senders_profiles_get"],
+                commands: ["senders profiles list", "senders profiles get"],
+            };
+        }
         if (isNetNewLinkedInInitiation(query)) {
             const publicResearch = isPublicLinkedInRead(query);
             const harvestEngagers = publicResearch && isPublicLinkedInEngagerHarvest(query);
@@ -861,7 +879,7 @@ function recommendationsFor(card, query) {
     if (card.id === "connected-whatsapp" && /\b(account|connect|limits?|sync)\b/.test(query)) {
         return {
             tools: ["oxygen_whatsapp_accounts_list", "oxygen_whatsapp_get", "oxygen_whatsapp_limits_get", "oxygen_whatsapp_connect"],
-            commands: ["whatsapp accounts list", "whatsapp get", "whatsapp limits get", "whatsapp connect"],
+            commands: ["whatsapp accounts", "whatsapp get", "whatsapp limits get", "whatsapp connect"],
         };
     }
     return { tools: [...card.gatewayTools], commands: [...card.gatewayCommands] };
@@ -869,6 +887,11 @@ function recommendationsFor(card, query) {
 function isInboxAvatarIntent(query) {
     return /\b(avatar|profile (?:picture|photo)|headshot|hosted (?:picture|image)|mailbox (?:picture|photo))\b/.test(query);
 }
+function isSenderProfileIntent(query) {
+    return /\b(?:sender|sending|unified)\s+(?:profiles?|identit(?:y|ies))\b/.test(query)
+        || (/\bprofiles?\b.{0,64}\b(?:linkedin|whatsapp|mailboxes?|inboxes?|email)\b/.test(query)
+            && /\b(?:sender|sending|unif(?:y|ied))\b/.test(query));
+}
 function isMutualLinkedInConnectionsIntent(query) {
     const linkedInContext = /\blinkedin\b|\bprofiles?\b/.test(query);
     const mutualContext = /\b(mutual|shared|in common)\b.{0,48}\b(connections?|relations?)\b/.test(query)

package/node_modules/@oxygen/shared/dist/copilot-errors.d.ts

@@ -1,5 +1,6 @@
 export declare const COPILOT_TURN_TIMEOUT_CODE = "copilot_turn_timeout";
 export declare const COPILOT_TURN_TIMEOUT_MESSAGE = "This Copilot request timed out and stopped. Any completed actions are still saved\u2014review this session before trying again.";
+export declare const COPILOT_TURN_DEADLINE_EXCEEDED_CODE = "copilot_turn_deadline_exceeded";
 export type CustomerFacingCopilotError = {
     code: string | null;
     message: string | null;

package/node_modules/@oxygen/shared/dist/copilot-errors.js

@@ -4,6 +4,14 @@
 // and already-persisted failures serialize identically across web, CLI, and MCP.
 export const COPILOT_TURN_TIMEOUT_CODE = "copilot_turn_timeout";
 export const COPILOT_TURN_TIMEOUT_MESSAGE = "This Copilot request timed out and stopped. Any completed actions are still saved—review this session before trying again.";
+// A turn the worker refused to start because it was ALREADY past its stamped
+// wall-clock deadline when it was reclaimed. Distinct in the durable row from
+// `copilot_turn_timeout` (a turn that ran and then ran out of clock) so an
+// operator can separate "we never started it" from "we could not finish it" in
+// SQL — but deliberately NOT distinct to the customer: the mapping below folds
+// it into the same timeout contract every Control surface already renders, per
+// this module's policy.
+export const COPILOT_TURN_DEADLINE_EXCEEDED_CODE = "copilot_turn_deadline_exceeded";
 const WORKER_STEP_TIMEOUT_MESSAGE = /\bWorker step '[^']+' exceeded \d+ms deadline\.?/i;
 /**
  * Replace an internal worker deadline with the stable Copilot timeout contract.
@@ -15,6 +23,7 @@ export function customerFacingCopilotError(input) {
     const message = input.message ?? null;
     const isTimeout = code === "worker_step_timeout" ||
         code === COPILOT_TURN_TIMEOUT_CODE ||
+        code === COPILOT_TURN_DEADLINE_EXCEEDED_CODE ||
         (message !== null && WORKER_STEP_TIMEOUT_MESSAGE.test(message));
     return isTimeout
         ? { code: COPILOT_TURN_TIMEOUT_CODE, message: COPILOT_TURN_TIMEOUT_MESSAGE }

package/node_modules/@oxygen/shared/dist/copilot-plan.d.ts

@@ -0,0 +1,169 @@
+/**
+ * The four states a plan step may be in.
+ *
+ * This is the vocabulary `plan_update`'s JSON Schema enforces going forward, and
+ * @oxygen/agent-runtime imports it so the schema and this reader can never drift.
+ */
+export declare const COPILOT_PLAN_STEP_STATUSES: readonly ["pending", "in_progress", "done", "blocked"];
+export type CopilotPlanStepStatus = (typeof COPILOT_PLAN_STEP_STATUSES)[number];
+/**
+ * An unrecognised status resolves to `pending`, never to `done`.
+ *
+ * This is the fail-closed direction and it is deliberate. Resolving the unknown
+ * to `done` would let a typo report a run as finished and silence the open-steps
+ * nudge; resolving it to `pending` at worst leaves a finished step looking open,
+ * which is visible and self-correcting on the next plan update.
+ */
+export declare function normalizeCopilotPlanStepStatus(raw: unknown): CopilotPlanStepStatus;
+/** A step is open until it is done. `blocked` is open too -- it still owes an outcome. */
+export declare function isCopilotPlanStepOpen(step: {
+    status: CopilotPlanStepStatus;
+}): boolean;
+/**
+ * The step shape after normalisation, before any timing is attached.
+ *
+ * `title` accepts three spellings because three have been produced: the tool
+ * schema and `packages/copilot`'s dormant `PlanStep` type both say `title`, while
+ * the model actually shipped `description` on every step of session 4097ef0d.
+ * `parsePlanSteps` in the web app required `title` and `continue`d past anything
+ * else, which is why it returned null for every real payload ever written.
+ */
+export type CopilotPlanRawStep = {
+    id: string | null;
+    title: string;
+    status: CopilotPlanStepStatus;
+    estimateSeconds: number | null;
+    substeps: Array<{
+        id: string | null;
+        title: string;
+        status: CopilotPlanStepStatus;
+    }>;
+};
+/**
+ * Pull the step list out of a `plan_updated` payload.
+ *
+ * Accepts both `{steps}` at the root (what the runtime emits) and the nested
+ * `{plan:{steps}}` shape, so a payload written by either producer renders.
+ */
+export declare function readCopilotPlanPayload(payload: Record<string, unknown> | null | undefined): {
+    summary: string;
+    steps: CopilotPlanRawStep[];
+} | null;
+/** Where a step's ETA came from. Rendered beside the number, never hidden. */
+export type CopilotPlanEtaBasis = 
+/** A model estimate scaled by how wrong its estimates have been so far. */
+"calibrated"
+/** No usable estimate; the mean of this turn's own completed steps. */
+ | "measured"
+/** The model's estimate, with nothing completed yet to calibrate it. */
+ | "model"
+/** Nothing to go on. The surface must say so rather than invent a number. */
+ | "none";
+export type CopilotPlanSubstep = {
+    id: string;
+    title: string;
+    status: CopilotPlanStepStatus;
+    /** `model` when the model declared it, `tool` when it is an observed call. */
+    source: "model" | "tool";
+    durationMs: number | null;
+    startedAt: string | null;
+    /**
+     * Set only for a `subagent_run`. A sub-agent's own capability calls never reach
+     * the ledger (it is handed capability tools directly, bypassing the runtime tool
+     * path), so the rollup counts are all there is -- and the rail must not imply a
+     * deeper trace exists.
+     */
+    subagent?: {
+        name: string;
+        inferences: number;
+        capabilityCalls: number;
+    };
+};
+export type CopilotPlanStep = {
+    id: string;
+    title: string;
+    status: CopilotPlanStepStatus;
+    estimateSeconds: number | null;
+    startedAt: string | null;
+    endedAt: string | null;
+    /** Wall time the step has taken, or took. Null until it starts. */
+    elapsedMs: number | null;
+    /** Seconds still expected. Null for a done step, or when nothing can be said. */
+    etaSeconds: number | null;
+    etaBasis: CopilotPlanEtaBasis;
+    substeps: CopilotPlanSubstep[];
+};
+export type CopilotPlanProjection = {
+    summary: string | null;
+    steps: CopilotPlanStep[];
+    progress: {
+        done: number;
+        total: number;
+        ratio: number;
+    };
+    eta: {
+        remainingSeconds: number | null;
+        basis: CopilotPlanEtaBasis;
+        /** How many completed, timed steps the measurement rests on. */
+        measuredSteps: number;
+        /** True when the turn's wall-clock deadline, not the plan, is the binding bound. */
+        deadlineBound: boolean;
+    };
+    /** False when no turn is executing: the plan is history, not work in flight. */
+    turnActive: boolean;
+    /** Ledger position of the newest plan_updated, so a caller can tell staleness. */
+    updatedAtSeq: number;
+    updatedAt: string;
+};
+export type CopilotPlanSourceEvent = {
+    seq: number;
+    kind: string;
+    payload: Record<string, unknown> | null;
+    created_at: string | Date;
+};
+export type ProjectCopilotPlanInput = {
+    /** Ordered by seq. Only plan_updated / tool_call_* / context_assembled are read. */
+    events: CopilotPlanSourceEvent[];
+    /** The active turn's wall-clock deadline, used only to clamp the total. */
+    turnDeadlineAt?: string | Date | null;
+    /**
+     * Whether a turn is executing right now. Defaults to true.
+     *
+     * A plan OUTLIVES the turn that wrote it. The model routinely stops without
+     * marking its last step done, so the session rests in the ledger forever with a
+     * step still `in_progress`. Read against a running clock that step accrues
+     * elapsed time indefinitely -- production session fd259942 reached 37 DAYS --
+     * and the surface goes on offering "time remaining" for work that stopped weeks
+     * ago. Both are the same error: treating a historical record as work in flight.
+     *
+     * So the clock stops with the turn, and a plan nobody is working reports no
+     * estimate at all rather than a false one.
+     */
+    turnActive?: boolean;
+    now?: Date;
+};
+/**
+ * Rebuild the plan, with timings, from the session's event ledger.
+ *
+ * Returns null when the session has never published a plan -- which is the correct
+ * answer for a trivial turn, since the prompt tells the model to skip `plan_update`
+ * entirely and call `finish`. A rail that renders an empty shell for every greeting
+ * would be worse than one that stays away.
+ */
+export declare function projectCopilotPlan(input: ProjectCopilotPlanInput): CopilotPlanProjection | null;
+/**
+ * How long, in words. One owner, because there were three and all three were wrong.
+ *
+ * The rail, `oxygen copilot plan` and the MCP widget each carried their own copy
+ * of this, and every copy did `Math.floor(s / 60)` minutes with `Math.round(s % 60)`
+ * seconds -- which rounds the remainder INDEPENDENTLY of the minutes it was taken
+ * from. A 179.6s sub-agent therefore rendered as "2m 60s" on all three surfaces
+ * (observed live in session 34826105), and 59.6s rendered as "60s" rather than
+ * "1m". Rounding the total FIRST and splitting afterwards cannot produce either.
+ *
+ * The projection promised one implementation behind three surfaces; the numbers
+ * were shared and the words describing them were not, so this is where they meet.
+ */
+export declare function formatCopilotPlanSeconds(seconds: number): string;
+/** A duration in ms, or null when there is nothing worth showing. */
+export declare function formatCopilotPlanDuration(ms: number | null | undefined): string | null;