@oxygen-agent/cli 1.365.3 → 1.377.3

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.365.3
+Version: 1.377.3

package/dist/index.js

@@ -641,6 +641,7 @@ function buildCrmSetupBody(options) {
     return {
         objects: readCrmSetupObjects(options.objects),
         mode: resolveLiveDryRunMode(options),
+        ...(options.withEnrichment === true ? { with_enrichment: true } : {}),
         ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
     };
 }
@@ -2823,6 +2824,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("Create or repair standard CRM object-backed tables. Defaults to dry-run.")
         .option("--objects <objects>", "Comma-separated standard CRM objects to set up. Defaults to companies,people,deals.")
         .option("--project <project>", "Project id or slug for created CRM tables.")
+        .option("--with-enrichment", "Also arm the standing cheap-enrichment auto-run on objects that already existed (fresh-created tables arm it by default). New rows then auto-enrich within the per-batch credit cap.")
         .option("--dry-run", "Preview CRM setup without creating or repairing tables.")
         .option("--live", "Apply CRM setup changes. Default is dry-run.")
         .option("--json", "Print a JSON envelope.")
@@ -2894,7 +2896,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("assert")
-        .description("Create or update one CRM record by object identity. Defaults to dry-run.")
+        .description("Create or update one CRM record by object identity. Defaults to dry-run. Note: the table's standing auto-run (auto-enrichment) fires on `tables insert|upsert|import`, not on assert — after asserting new records, run the enrichment columns (`oxygen columns run <table> <column>`) or insert via `oxygen tables insert` when you want them enriched hands-free.")
         .argument("<object>", "CRM object slug, such as companies or people.")
         .requiredOption("--identity <key=value>", "Identity key/value, for example domain=acme.com or email=ceo@acme.com.")
         .option("--values-json <json>", "JSON object of CRM attribute values keyed by column key.")
@@ -2914,6 +2916,29 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action(async (object, rowId, options) => {
         await handleAsyncAction("crm get", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}`));
+    }))
+        .addCommand(new Command("tag")
+        .description("Add/remove workspace tags on one CRM record (Tags primitive — the same vocabulary as sequences, tables, conversations; see `oxygen tags list`). Delta semantics: --add unions, --remove subtracts, remove wins. Standard objects carry the tags attribute after `oxygen crm setup`.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<row_id>", "CRM record row id.")
+        .option("--add <tags>", "Comma-separated tags to add.")
+        .option("--remove <tags>", "Comma-separated tags to remove.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm tag", options, () => {
+            const add = splitCommaList(options.add);
+            const remove = splitCommaList(options.remove);
+            if (add.length === 0 && remove.length === 0) {
+                throw new OxygenError("invalid_request", "Pass --add and/or --remove.", { exitCode: 1 });
+            }
+            return requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tags`, {
+                method: "POST",
+                body: {
+                    ...(add.length > 0 ? { add } : {}),
+                    ...(remove.length > 0 ? { remove } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("relationships")
         .description("Define CRM relationships and manage record relationship edges.")
@@ -3433,11 +3458,20 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("list")
         .description("List workspace tables in the current tenant database.")
         .option("--project <project>", "Project id or slug to filter by.")
+        .option("--tag <tag>", "Only tables carrying this workspace tag (see `oxygen tags list`).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("tables list", options, () => requestOxygen(readOption(options.project)
-            ? `/api/cli/tables?project=${encodeURIComponent(readOption(options.project))}`
-            : "/api/cli/tables"));
+        await handleAsyncAction("tables list", options, () => {
+            const params = new URLSearchParams();
+            const project = readOption(options.project);
+            if (project)
+                params.set("project", project);
+            const tag = readOption(options.tag);
+            if (tag)
+                params.set("tag", tag);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/tables${qs}`);
+        });
     }))
         .addCommand(new Command("query")
         .description("Query a workspace table by id or slug.")
@@ -4503,7 +4537,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }));
     program
         .command("tags")
-        .description("Workspace tags: one vocabulary across publishing posts, knowledge pages, sequences, tables, workflows, and recipes. Tags normalize to lowercase (trimmed, deduped, max 50 per item; any characters). Write tags on the owning surface, then `tags get <tag>` returns every carrier with deep-links.")
+        .description("Workspace tags: one vocabulary across publishing posts, knowledge pages, sequences, tables, workflows, recipes, and inbox conversations. Tags normalize to lowercase (trimmed, deduped, max 50 per item; any characters). Write tags on the owning surface (e.g. `oxygen inbox tag`, `oxygen tables tag`), then `tags get <tag>` returns every carrier with deep-links.")
         .addCommand(new Command("list")
         .description("List every workspace tag with per-primitive counts, most-used first.")
         .option("--json", "Print a JSON envelope.")
@@ -4511,11 +4545,23 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("tags list", options, () => requestOxygen("/api/cli/tags"));
     }))
         .addCommand(new Command("get")
-        .description("Everything carrying one tag — publishing posts, knowledge pages, sequences, tables, workflows, and recipes — each with its deep-link.")
+        .description("Everything carrying one tag — publishing posts, knowledge pages, sequences, tables, workflows, recipes, and inbox conversations — each with its deep-link.")
         .argument("<tag>", "The tag (case-insensitive).")
         .option("--json", "Print a JSON envelope.")
         .action(async (tag, options) => {
         await handleAsyncAction("tags get", options, () => requestOxygen(`/api/cli/tags/${encodeURIComponent(tag)}`));
+    }))
+        .addCommand(new Command("rename")
+        .description("Rename one tag EVERYWHERE it appears (every primitive, archived rows included). Preview-first: without --apply, prints per-kind would-change counts and mutates nothing. Idempotent — safe to re-run after a partial failure.")
+        .argument("<from>", "The current tag (case-insensitive).")
+        .argument("<to>", "The new tag (normalized lowercase).")
+        .option("--apply", "Execute the rename. Without this flag, returns a preview of the counts only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (from, to, options) => {
+        await handleAsyncAction("tags rename", options, () => requestOxygen("/api/cli/tags/rename", {
+            method: "POST",
+            body: { from, to, ...(options.apply ? { apply: true } : {}) },
+        }));
     }));
     program
         .command("blueprints")
@@ -4539,6 +4585,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const qs = params.toString() ? `?${params.toString()}` : "";
             return requestOxygen(`/api/cli/blueprints${qs}`);
         });
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a saved blueprint's workspace tags (whole set; `--tags \"\"` clears). Works on already-saved blueprints — no re-export needed. See `oxygen tags list` for the vocabulary.")
+        .argument("<blueprint>", "Blueprint slug or id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (blueprint, options) => {
+        await handleAsyncAction("blueprints tag", options, () => requestOxygen("/api/cli/blueprints/tags", {
+            method: "POST",
+            body: { blueprint, tags: splitCommaList(options.tags) },
+        }));
     }))
         .addCommand(new Command("describe")
         .description("Describe one blueprint (seed or saved) by slug.")
@@ -4989,7 +5046,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
         .option("--row-id <row_id>", "Workspace row id to run.")
-        .option("--limit <n>", "Maximum rows to inspect when row-id is omitted. Defaults to 10; sync hard cap is 25.")
+        .option("--limit <n>", "Run the next N rows whose target cell is still empty (--force runs the first N regardless). Repeat until rowCount is 0 to page through a table. Defaults to 10; inline (non-background) hard cap is 25.")
         .option("--all", "Run all rows. Requires --background.")
         .option("--filter-json <json>", "Row selector filter object or array for background runs. Do not combine with --all, --limit, or --row-id.")
         .option("--force", "Run even when the target cell already has a value.")
@@ -6537,37 +6594,37 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     // `oxygen knowledge agent`, which configures the AI Knowledge Agent itself.)
     program
         .command("agent")
-        .description("Agents: your workspace agents (AI Sales Agent, AI Meeting Notetaker, AI Knowledge Agent) that work inside your workspace as approval-gated runs. List them, inspect run history, and enable or disable each one; each agent's `configCommand` (e.g. `oxygen inbox reply-agent set` for the AI Sales Agent) tunes its behavior. Web: /agents.")
+        .description("Agents: the programmable Workspace Agent plus built-in specialist agents. Publish versioned instructions and policies, start durable runs, trigger them by cron/event/webhook, inspect every event, and control approvals. Web: /agents.")
         .addCommand(new Command("list")
-        .description("List the built-in specialist agents with their enabled state and recent run history.")
+        .description("List the Workspace Agent and built-in specialists with state and recent run history.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("agent list", options, () => requestOxygen("/api/cli/agent"));
     }))
         .addCommand(new Command("get")
-        .description("Show one specialist agent: its state, approval boundary, config command, and recent runs.")
-        .argument("<slug>", "Specialist slug: inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
+        .description("Show one agent, including the Workspace Agent's active version and recent runs.")
+        .argument("<slug>", "Agent slug: workspace, inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
         await handleAsyncAction("agent get", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}`));
     }))
         .addCommand(new Command("enable")
-        .description("Enable a specialist agent so it resumes its approval-gated drafts/runs.")
+        .description("Enable a workspace or specialist agent so it resumes its governed runs.")
         .argument("<slug>", "Specialist slug: inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
         await handleAsyncAction("agent enable", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/enable`, { method: "POST" }));
     }))
         .addCommand(new Command("disable")
-        .description("Disable a specialist agent so it stops its drafts/runs on the next worker tick.")
+        .description("Disable a workspace or specialist agent so it stops new runs on the next worker tick.")
         .argument("<slug>", "Specialist slug: inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
         await handleAsyncAction("agent disable", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/disable`, { method: "POST" }));
     }))
         .addCommand(new Command("runs")
-        .description("List recent runs across the specialist agents (or one via <slug>), newest first.")
-        .argument("[slug]", "Optional specialist slug to filter to one agent.")
+        .description("List recent runs across all agents (or one via <slug>), newest first.")
+        .argument("[slug]", "Optional agent slug to filter to one agent.")
         .option("--limit <n>", "Maximum runs to return (1-100). Defaults to 25.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
@@ -6582,6 +6639,203 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const suffix = params.toString() ? `?${params.toString()}` : "";
             return requestOxygen(`/api/cli/agent/runs${suffix}`);
         });
+    }))
+        .addCommand(new Command("set")
+        .description("Publish an immutable version (reconfigure) for a runtime agent: the Workspace Agent or a custom agent.")
+        .argument("<slug>", "workspace, or a custom agent slug (from `oxygen agent create`).")
+        .requiredOption("--instructions <text>", "Workspace Agent instructions for this version.")
+        .option("--model-policy-json <json>", "Model policy JSON. Defaults to managed OpenRouter medium.")
+        .option("--tool-policy-json <json>", "Tool policy JSON. Omit restrictions for full eligible catalog access.")
+        .option("--context-policy-json <json>", "Context policy JSON: on_demand or prefetch, optional resolve_args and file_ids.")
+        .option("--skills <csv>", "Comma-separated product skill slugs snapshotted into this immutable version.")
+        .option("--sandbox-policy-json <json>", "Sandbox policy JSON.")
+        .option("--limits-json <json>", "Optional limits JSON; platform hard ceilings still apply.")
+        .option("--confirm-full-access", "Acknowledge standing full catalog access when the policy mode is full.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent set", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}`, {
+            method: "PATCH",
+            body: {
+                instructions: options.instructions,
+                ...(options.modelPolicyJson ? { model_policy: parseJsonObject(options.modelPolicyJson) } : {}),
+                ...(options.toolPolicyJson ? { tool_policy: parseJsonObject(options.toolPolicyJson) } : {}),
+                ...(options.contextPolicyJson ? { context_policy: parseJsonObject(options.contextPolicyJson) } : {}),
+                ...(options.skills ? { skill_slugs: options.skills.split(",").map((value) => value.trim()).filter(Boolean) } : {}),
+                ...(options.sandboxPolicyJson ? { sandbox_policy: parseJsonObject(options.sandboxPolicyJson) } : {}),
+                ...(options.limitsJson ? { limits: parseJsonObject(options.limitsJson) } : {}),
+                confirm_full_access: options.confirmFullAccess === true,
+            },
+        }));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a custom agent and publish its first immutable version. Schedule it with `oxygen agent trigger create`.")
+        .argument("<slug>", "User-minted agent slug: a lowercase letter then letters, digits, or hyphens (2-49 chars).")
+        .requiredOption("--name <name>", "Display name for the agent.")
+        .requiredOption("--instructions <text>", "Durable standing instructions for the first immutable version.")
+        .option("--description <text>", "Optional one-line description of the agent's job.")
+        .option("--model-policy-json <json>", "Model policy JSON. Defaults to managed OpenRouter medium.")
+        .option("--tool-policy-json <json>", "Tool policy JSON. Omit restrictions for full eligible catalog access.")
+        .option("--context-policy-json <json>", "Context policy JSON: on_demand or prefetch, optional resolve_args and file_ids.")
+        .option("--skills <csv>", "Comma-separated product skill slugs snapshotted into this immutable version.")
+        .option("--sandbox-policy-json <json>", "Sandbox policy JSON.")
+        .option("--limits-json <json>", "Optional limits JSON; platform hard ceilings still apply.")
+        .option("--confirm-full-access", "Acknowledge standing full catalog access when the policy mode is full.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent create", options, () => requestOxygen("/api/cli/agent/create", {
+            method: "POST",
+            body: {
+                slug,
+                name: options.name,
+                instructions: options.instructions,
+                ...(options.description ? { description: options.description } : {}),
+                ...(options.modelPolicyJson ? { model_policy: parseJsonObject(options.modelPolicyJson) } : {}),
+                ...(options.toolPolicyJson ? { tool_policy: parseJsonObject(options.toolPolicyJson) } : {}),
+                ...(options.contextPolicyJson ? { context_policy: parseJsonObject(options.contextPolicyJson) } : {}),
+                ...(options.skills ? { skill_slugs: options.skills.split(",").map((value) => value.trim()).filter(Boolean) } : {}),
+                ...(options.sandboxPolicyJson ? { sandbox_policy: parseJsonObject(options.sandboxPolicyJson) } : {}),
+                ...(options.limitsJson ? { limits: parseJsonObject(options.limitsJson) } : {}),
+                confirm_full_access: options.confirmFullAccess === true,
+            },
+        }));
+    }))
+        .addCommand(new Command("custom")
+        .description("List the org's user-defined custom agents (distinct from `agent list`, which shows the built-in roster).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("agent custom", options, () => requestOxygen("/api/cli/agent/custom"));
+    }))
+        .addCommand(new Command("run")
+        .description("Start a durable Workspace Agent run on the Fly worker.")
+        .argument("<slug>", "Currently: workspace.")
+        .option("--goal <text>", "Natural-language goal.")
+        .option("--input-json <json>", "Structured run input instead of --goal.")
+        .option("--idempotency-key <key>", "Deduplicate retries of the same source event.")
+        .option("--thread-id <id>", "Continue an existing persistent Agent thread.")
+        .option("--thread-mode <isolated|persistent>", "Create a persistent thread for this run. Defaults to isolated.")
+        .option("--file-ids <csv>", "Comma-separated workspace file UUIDs attached to context and eligible for sandbox input.")
+        .requiredOption("--max-credits <credits>", "Hard credit ceiling for this run.")
+        .requiredOption("--approved", "Explicitly approve managed inference up to --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent run", options, () => {
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (maxCredits === undefined)
+                throw new OxygenError("invalid_request", "--max-credits must be positive.", { exitCode: 2 });
+            return requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs`, {
+                method: "POST",
+                body: {
+                    ...(options.goal ? { goal: options.goal } : {}),
+                    ...(options.inputJson ? { input: parseJsonObject(options.inputJson) } : {}),
+                    ...(options.idempotencyKey ? { idempotency_key: options.idempotencyKey } : {}),
+                    ...(options.threadId ? { thread_id: options.threadId } : {}),
+                    thread_mode: options.threadMode ?? "isolated",
+                    ...(options.fileIds ? { file_ids: options.fileIds.split(",").map((value) => value.trim()).filter(Boolean) } : {}),
+                    max_credits: maxCredits,
+                    approved: options.approved === true,
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("run-get")
+        .description("Inspect one Workspace Agent run and its append-only event ledger.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<run-id>", "Agent run id.")
+        .option("--after-seq <n>", "Return events after this sequence number.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, runId, options) => {
+        await handleAsyncAction("agent run get", options, () => {
+            const params = new URLSearchParams();
+            if (options.afterSeq)
+                params.set("after_seq", options.afterSeq);
+            const suffix = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}${suffix}`);
+        });
+    }))
+        .addCommand(new Command("cancel")
+        .description("Request cancellation of an active Workspace Agent run.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<run-id>", "Agent run id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, runId, options) => {
+        await handleAsyncAction("agent run cancel", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" }));
+    }))
+        .addCommand(new Command("approval-decide")
+        .description("Approve or reject one pending Workspace Agent tool call, then resume its durable run.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<run-id>", "Agent run id.")
+        .argument("<approval-id>", "Approval id from the run event ledger.")
+        .requiredOption("--decision <approved|rejected>", "Decision.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, runId, approvalId, options) => {
+        await handleAsyncAction("agent approval decide", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}/approvals/${encodeURIComponent(approvalId)}`, { method: "POST", body: { decision: options.decision } }));
+    }))
+        .addCommand(new Command("trigger-create")
+        .description("Create a cron, internal event, or signed-webhook trigger for the Workspace Agent.")
+        .argument("<slug>", "Currently: workspace.")
+        .requiredOption("--type <cron|event|webhook>", "Trigger type.")
+        .requiredOption("--instruction <text>", "Goal template run for each delivery.")
+        .option("--cron <expression>", "Five-field cron expression for cron triggers.")
+        .option("--timezone <iana>", "IANA timezone. Defaults to UTC.")
+        .option("--event-source <source>", "Internal workflow-event source for event triggers.")
+        .option("--event-type <event>", "Internal workflow-event type for event triggers.")
+        .option("--thread-mode <isolated|persistent>", "Reuse a bounded thread across deliveries. Defaults to isolated.")
+        .requiredOption("--max-credits <credits>", "Standing per-delivery credit ceiling.")
+        .requiredOption("--approved", "Authorize each trigger delivery up to --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent trigger create", options, () => {
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (maxCredits === undefined)
+                throw new OxygenError("invalid_request", "--max-credits must be positive.", { exitCode: 2 });
+            return requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/triggers`, { method: "POST", body: {
+                    type: options.type, instruction_template: options.instruction,
+                    ...(options.cron ? { cron_expression: options.cron } : {}),
+                    ...(options.timezone ? { timezone: options.timezone } : {}),
+                    ...(options.eventSource ? { event_source: options.eventSource } : {}),
+                    ...(options.eventType ? { event_type: options.eventType } : {}),
+                    thread_mode: options.threadMode ?? "isolated",
+                    max_credits: maxCredits,
+                    approved: options.approved === true,
+                } });
+        });
+    }))
+        .addCommand(new Command("triggers")
+        .description("List Workspace Agent cron, internal event, and webhook triggers.")
+        .argument("<slug>", "Currently: workspace.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent triggers", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/triggers`));
+    }))
+        .addCommand(new Command("trigger-set")
+        .description("Activate, pause, or archive one Workspace Agent trigger.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<trigger-id>", "Agent trigger id.")
+        .requiredOption("--status <active|paused|archived>", "New trigger status.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, triggerId, options) => {
+        await handleAsyncAction("agent trigger set", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/triggers/${encodeURIComponent(triggerId)}`, { method: "PATCH", body: { status: options.status } }));
+    }))
+        .addCommand(new Command("file-create")
+        .description("Store a tenant-owned text file for Agent context and sandbox input.")
+        .requiredOption("--name <name>", "Workspace filename.")
+        .requiredOption("--text <text>", "Inline text content (max 1.5 MB).")
+        .option("--mime-type <type>", "MIME type. Defaults to text/plain.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("agent file create", options, () => requestOxygen("/api/cli/agent/files", {
+            method: "POST", body: { name: options.name, text: options.text, mime_type: options.mimeType ?? "text/plain" },
+        }));
+    }))
+        .addCommand(new Command("files")
+        .description("List tenant-owned Agent context files.")
+        .option("--limit <n>", "Maximum files (1-500).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("agent files", options, () => {
+            const limit = readPositiveInt(options.limit);
+            return requestOxygen(`/api/cli/agent/files${limit ? `?limit=${limit}` : ""}`);
+        });
     }));
     program
         .command("copilot")
@@ -6594,6 +6848,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--per-turn-ceiling <number>", "Optional per-turn credit ceiling that caps any single turn's inference spend.")
         .option("--journey <slug>", "Optional journey slug to seed the session's goal and context.")
         .option("--title <text>", "Optional human title for the session.")
+        .option("--auto-approve", "Start with auto-approve ON for paid, workspace-internal actions (cards are still created and decided automatically within each action's credit cap). External sends, enrollments, publishes, DNS, and external CRM pushes always stay human-gated.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("copilot start", options, () => {
@@ -6617,6 +6872,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body.journey = journey;
             if (title)
                 body.title = title;
+            if (options.autoApprove)
+                body.auto_approve = true;
             return requestOxygen("/api/cli/copilot/sessions", { method: "POST", body });
         });
     }))
@@ -7377,7 +7634,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("senders checkpoints", options, () => requestOxygen("/api/cli/senders/checkpoints"));
     }))
         .addCommand(new Command("connect")
-        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Use --count to mint several links at once for bulk onboarding. Open each URL in a browser to complete authentication.")
+        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Use --count to mint several links at once for bulk onboarding. Open each URL in a browser to complete authentication. Links are shareable: send one to the account owner (e.g. a client) — no Oxygen login is needed to complete it, and the account lands in this workspace's sender list. Each link is valid for 30 minutes and connects one account.")
         .option("--reconnect <connection_id>", "Reconnect an existing connection instead of creating a new one. Accepts a connection id.")
         .option("--sales-nav", "Request Classic + Sales Navigator access during Unipile hosted authentication.")
         .option("--count <n>", "Mint N hosted-auth links in one call for bulk onboarding (1-25, default 1). Each link connects a different account. Ignored when reconnecting.")
@@ -7402,6 +7659,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("senders get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}`));
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a sender account's workspace tags (whole set; `--tags \"\"` clears) — e.g. pool the senders behind one campaign tag. See `oxygen tags list` for the vocabulary.")
+        .argument("<id>", "Sender account id or Unipile account id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("senders tag", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/tags`, {
+            method: "POST",
+            body: { tags: splitCommaList(options.tags) },
+        }));
     }))
         .addCommand(new Command("health")
         .description("Show a one-call health snapshot for a LinkedIn sender: status, the latest error reason, any open security checkpoint, today's usage, the warm-up ramp, and when the daily quota resets. Read-only — no provider call, no credits. <id> accepts a sender account id, connection id, or Unipile account id.")
@@ -8147,6 +8415,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--bucket <bucket>", "Email only: primary or others (superseded by --segment).")
         .option("--segment <segment>", "Email only: top-tab folder — primary, others, sent, warmup, or dmarc.")
         .option("--status <keys>", "Comma-separated status keys (e.g. interested,meeting_booked). Cross-channel — filters email + LinkedIn + WhatsApp by the shared taxonomy.")
+        .option("--sentiment <values>", "Comma-separated AI sentiment: positive, neutral, negative. Cross-channel; not-yet-analyzed conversations never match.")
+        .option("--tag <tags>", "Comma-separated campaign tags — matches email conversations whose campaign (sequence) carries any of these tags. DMs have no campaign link, so a tag filter shows email only.")
         .option("--since <iso>", "Only conversations whose last message is on/after this ISO date/timestamp. Cross-channel.")
         .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Cross-channel.")
         .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) UUIDs (not slugs — get the id from `sequences get <slug>`).")
@@ -8157,6 +8427,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--search <text>", "Filter by attendee name or last-message text. Cross-channel.")
         .option("--include-archived", "Include archived conversations.")
         .option("--limit <n>", "Maximum conversations to return (1-200). Defaults to 50.")
+        .option("--cursor <cursor>", "channel=all only: the previous page's next_cursor — resumes the merged stream after that row.")
+        .option("--no-counts", "channel=all only: skip the sidebar facet counts for a faster paged read (total_conversations/unread_conversations/sidebar_counts omitted from the envelope). Other channels ignore it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("inbox list", options, () => {
@@ -8176,6 +8448,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 ["segment", "segment"],
                 ["channels", "channels"],
                 ["status", "status"],
+                ["sentiment", "sentiment"],
+                ["tag", "tag"],
                 ["since", "since"],
                 ["until", "until"],
                 ["sequenceId", "sequence_id"],
@@ -8183,6 +8457,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 ["domain", "domain"],
                 ["excludeDomain", "exclude_domain"],
                 ["mailboxId", "mailbox_id"],
+                ["cursor", "cursor"],
             ]) {
                 const value = readOption(options[flag]);
                 if (value)
@@ -8196,6 +8471,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const limit = readOption(options.limit);
             if (limit)
                 params.set("limit", limit);
+            // Commander's --no-counts sets counts:false; absent leaves the
+            // server default (counts included) untouched.
+            if (options.counts === false)
+                params.set("include_counts", "false");
             const suffix = params.toString();
             return requestOxygen(`/api/cli/inbox${suffix ? `?${suffix}` : ""}`);
         });
@@ -8342,6 +8621,31 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body: { status, channel },
             });
         });
+    }))
+        .addCommand(new Command("tag")
+        .description("Add/remove workspace tags on a conversation (Tags primitive — the same vocabulary as sequences, tables, posts; see `oxygen tags list`). Delta semantics: --add unions, --remove subtracts, remove wins on conflict. Internal metadata, never sent to the counterpart. --channel linkedin/whatsapp tags a DM conversation.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--add <tags>", "Comma-separated tags to add.")
+        .option("--remove <tags>", "Comma-separated tags to remove.")
+        .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox tag", options, () => {
+            const add = splitCommaList(options.add);
+            const remove = splitCommaList(options.remove);
+            if (add.length === 0 && remove.length === 0) {
+                throw new OxygenError("invalid_request", "Pass --add and/or --remove.", { exitCode: 1 });
+            }
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/tags`, {
+                method: "POST",
+                body: {
+                    ...(add.length > 0 ? { add } : {}),
+                    ...(remove.length > 0 ? { remove } : {}),
+                    channel,
+                },
+            });
+        });
     }))
         .addCommand(new Command("rescan")
         .description("Re-queue conversations for AI re-classification (status + sentiment + drafted reply). Without --yes, previews the counts that would be re-flipped. With --yes, the worker re-classifies the pending rows (free for opt-outs, low-tier model otherwise, credit-capped).")
@@ -8562,6 +8866,37 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body.max_drafts_per_day = Number(options.maxDraftsPerDay);
             return requestOxygen("/api/cli/inbox/reply-agent", { method: "POST", body });
         });
+    })))
+        .addCommand(new Command("auto-tagger")
+        .description("The auto-tagging agent (the 'AI Inbox Tagger'): classifies each new inbound conversation against your workspace tag allowlist and auto-applies matches — additive, never re-adds a tag you removed, zero extra model calls (rides the analysis pass). Roster + run history: `oxygen agent get inbox-auto-tagger`; web home: /agents/inbox-auto-tagger.")
+        .addCommand(new Command("get")
+        .description("Show the auto-tagger config (enabled, tag allowlist, channels).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox auto-tagger get", options, () => requestOxygen("/api/cli/inbox/auto-tagger"));
+    }))
+        .addCommand(new Command("set")
+        .description("Update the auto-tagger. --tags replaces the whole allowlist (max 50; `--tags \"\"` clears, which pauses tagging while keeping the agent enabled).")
+        .option("--enabled", "Enable the agent.")
+        .option("--disabled", "Disable the agent.")
+        .option("--tags <tags>", "Comma-separated tag allowlist the classifier may apply (replaces the whole set).")
+        .option("--channels <list>", "Comma-separated channels to tag: a non-empty subset of email, linkedin, whatsapp (default all three).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox auto-tagger set", options, () => {
+            const body = {};
+            if (options.enabled)
+                body.enabled = true;
+            if (options.disabled)
+                body.enabled = false;
+            if (options.tags !== undefined) {
+                body.tags = options.tags.split(",").map((tag) => tag.trim()).filter(Boolean);
+            }
+            if (options.channels !== undefined) {
+                body.channels = options.channels.split(",").map((c) => c.trim()).filter(Boolean);
+            }
+            return requestOxygen("/api/cli/inbox/auto-tagger", { method: "POST", body });
+        });
     }))));
     program.addCommand(new Command("messages")
         .description("Cross-channel message corpus: every individual email + LinkedIn + WhatsApp message as one searchable stream (Postgres full-text search over bodies, keyset paginated by recency), plus reply-rate/campaign analytics. Message-level, unlike inbox (conversation-level triage).")
@@ -8576,6 +8911,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--sequence-id <id>", "Email only: campaign (sequence) id (restricts the result to email).")
         .option("--status <keys>", "Comma-separated conversation status keys (e.g. interested,meeting_booked).")
         .option("--sentiment <sentiment>", "Filter by sentiment: positive, neutral, or negative.")
+        .option("--tag <tag>", "Only messages whose conversation carries this workspace tag (see `oxygen tags list`).")
         .option("--since <iso>", "Only messages sent at or after this ISO timestamp.")
         .option("--until <iso>", "Only messages sent before this ISO timestamp.")
         .option("--limit <n>", "Maximum messages to return (1-200). Defaults to 50.")
@@ -8596,6 +8932,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 ["sequenceId", "sequence_id"],
                 ["status", "status"],
                 ["sentiment", "sentiment"],
+                ["tag", "tag"],
                 ["since", "since"],
                 ["until", "until"],
                 ["limit", "limit"],
@@ -9496,6 +9833,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body: { mailboxes: parsed.mailboxes ?? [] },
             });
         });
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a sending mailbox's workspace tags (whole set; `--tags \"\"` clears) — e.g. pool the mailboxes behind one campaign tag. See `oxygen tags list` for the vocabulary.")
+        .argument("<mailbox>", "Mailbox id or email address.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (mailbox, options) => {
+        await handleAsyncAction("mailboxes tag", options, () => requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}/tags`, {
+            method: "POST",
+            body: { tags: splitCommaList(options.tags) },
+        }));
     }))
         .addCommand(new Command("status")
         .description("Set a sending mailbox's status. Pausing/disabling takes the inbox out of the rotation pool without losing its warmup state.")
@@ -10117,10 +10465,18 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("list")
         .description("List workflow automations. Archived workflows are hidden unless you pass --include-archived.")
         .option("--include-archived", "Also list archived workflows, which are hidden by default.")
+        .option("--tag <tag>", "Only workflows carrying this workspace tag (see `oxygen tags list`).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("workflows list", options, async () => {
-            const data = await requestOxygen(`/api/cli/workflows${options.includeArchived ? "?include_archived=true" : ""}`);
+            const params = new URLSearchParams();
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const tag = readOption(options.tag);
+            if (tag)
+                params.set("tag", tag);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            const data = await requestOxygen(`/api/cli/workflows${qs}`);
             writeDisabledWorkflowNotices(data);
             return data;
         });

package/node_modules/@oxygen/shared/dist/billing.d.ts

@@ -57,6 +57,8 @@ export type CreditTopupPackId = CreditTopupPack["id"];
 export declare function resolveCreditTopupPack(id: string | null | undefined): CreditTopupPack | null;
 export declare const TRIAL_PERIOD_DAYS = 7;
 export declare const TRIAL_CREDIT_GRANT = 20000;
+export declare const WALKTHROUGH_COMPLETION_BONUS_CREDITS = 1000;
+export declare const WALKTHROUGH_SCRAPE_MAX_CREDITS = 2000;
 export declare const BASE_PRICING_PLANS: {
     readonly free: {
         readonly tier: "free";

package/node_modules/@oxygen/shared/dist/billing.js

@@ -47,6 +47,13 @@ export function resolveCreditTopupPack(id) {
 // credit exhaustion or when the trial clock elapses, whichever comes first.
 export const TRIAL_PERIOD_DAYS = 7;
 export const TRIAL_CREDIT_GRANT = 20_000;
+// Onboarding walkthrough (2026-07-21): completing the in-product walkthrough
+// grants a one-off bonus (idempotent per billing owner), and the walkthrough's
+// "start scraping engagers" step may spend at most this many credits on the
+// managed cookieless scraper (founder-approved budget; the rest of the kickoff
+// is free connected-account reads).
+export const WALKTHROUGH_COMPLETION_BONUS_CREDITS = 1_000;
+export const WALKTHROUGH_SCRAPE_MAX_CREDITS = 2_000;
 export const BASE_PRICING_PLANS = {
     free: {
         tier: "free",

package/node_modules/@oxygen/shared/dist/hosted-ai.d.ts

@@ -21,7 +21,7 @@
  * can re-source the catalog without dragging in the shared barrel.
  */
 export type HostedAiLevel = "low" | "medium" | "high";
-export type HostedAiUseCase = "ai_column" | "copilot";
+export type HostedAiUseCase = "ai_column" | "copilot" | "agent";
 export type HostedAiModelSpec = {
     /** OpenRouter model id, e.g. "deepseek/deepseek-v4-flash". */
     model: string;
@@ -47,6 +47,7 @@ export type HostedAiModelSpec = {
 export declare const HOSTED_AI_MODEL_REGISTRY: Record<HostedAiUseCase, Record<HostedAiLevel, HostedAiModelSpec>>;
 /** The reasoning tier the hosted copilot runs at by default. */
 export declare const COPILOT_DEFAULT_LEVEL: HostedAiLevel;
+export declare const AGENT_DEFAULT_LEVEL: HostedAiLevel;
 /**
  * Resolve the model spec for a hosted-AI use case + reasoning level.
  *

package/node_modules/@oxygen/shared/dist/hosted-ai.js

@@ -77,9 +77,38 @@ export const HOSTED_AI_MODEL_REGISTRY = {
             maxOutputTokens: 8192,
         },
     },
+    agent: {
+        low: {
+            model: "deepseek/deepseek-v4-flash",
+            displayName: "DeepSeek V4 Flash",
+            fallbackModels: [],
+            reasoningEffort: "medium",
+            estPromptUsdPerM: 0.09,
+            estCompletionUsdPerM: 0.18,
+            maxOutputTokens: 8192,
+        },
+        medium: {
+            model: "deepseek/deepseek-v4-pro",
+            displayName: "DeepSeek V4 Pro",
+            fallbackModels: ["deepseek/deepseek-v4-flash"],
+            reasoningEffort: "high",
+            estPromptUsdPerM: 0.435,
+            estCompletionUsdPerM: 0.87,
+            maxOutputTokens: 8192,
+        },
+        high: {
+            model: "moonshotai/kimi-k2.6",
+            displayName: "Kimi K2.6",
+            fallbackModels: ["deepseek/deepseek-v4-pro"],
+            estPromptUsdPerM: 0.66,
+            estCompletionUsdPerM: 3.41,
+            maxOutputTokens: 8192,
+        },
+    },
 };
 /** The reasoning tier the hosted copilot runs at by default. */
 export const COPILOT_DEFAULT_LEVEL = "high";
+export const AGENT_DEFAULT_LEVEL = "medium";
 const LEVEL_ENV_SUFFIX = {
     low: "LOW",
     medium: "MEDIUM",
@@ -134,12 +163,13 @@ export function findHostedAiModelSpec(model, preferredUseCase) {
 }
 export function resolveHostedAiModel(input) {
     const base = HOSTED_AI_MODEL_REGISTRY[input.useCase][input.level];
-    if (input.useCase !== "copilot")
+    if (input.useCase === "ai_column")
         return base;
     const env = input.env ?? process.env;
     const suffix = LEVEL_ENV_SUFFIX[input.level];
-    const modelOverride = readTrimmedEnv(env, `OXYGEN_COPILOT_MODEL_${suffix}`);
-    const rawFallback = readTrimmedEnv(env, `OXYGEN_COPILOT_FALLBACK_${suffix}`);
+    const envPrefix = input.useCase === "agent" ? "OXYGEN_AGENT" : "OXYGEN_COPILOT";
+    const modelOverride = readTrimmedEnv(env, `${envPrefix}_MODEL_${suffix}`);
+    const rawFallback = readTrimmedEnv(env, `${envPrefix}_FALLBACK_${suffix}`);
     const fallbackOverride = rawFallback === undefined ? undefined : parseFallbackCsv(rawFallback);
     if (modelOverride === undefined && fallbackOverride === undefined)
         return base;

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -20,6 +20,7 @@ export * from "./knowledge-constants.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";
+export * from "./langfuse.js";
 export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-url.js";
@@ -30,6 +31,7 @@ export * from "./sequence-template.js";
 export * from "./sequences.js";
 export * from "./suppression-entries.js";
 export * from "./log.js";
+export { sanitizeLogFields } from "./redaction.js";
 export * from "./provider-request-outcomes.js";
 export * from "./schedule-label.js";
 export * from "./signup-lead-deliveries.js";

package/node_modules/@oxygen/shared/dist/index.js

@@ -20,6 +20,7 @@ export * from "./knowledge-constants.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";
+export * from "./langfuse.js";
 export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-url.js";
@@ -30,6 +31,11 @@ export * from "./sequence-template.js";
 export * from "./sequences.js";
 export * from "./suppression-entries.js";
 export * from "./log.js";
+// Narrow, deliberate export (ADR 0014): lets telemetry emitters regression-test
+// their field names against the REAL log sanitizer — the unanchored
+// SECRET_KEY_PATTERN redacts any name containing "token", which mocked loggers
+// cannot catch. Not a license to pre-sanitize outside log().
+export { sanitizeLogFields } from "./redaction.js";
 export * from "./provider-request-outcomes.js";
 export * from "./schedule-label.js";
 export * from "./signup-lead-deliveries.js";

package/node_modules/@oxygen/shared/dist/langfuse.d.ts

@@ -0,0 +1,77 @@
+import { Langfuse } from "langfuse";
+type EnvMap = Record<string, string | undefined>;
+export type LlmObservationLevel = "DEBUG" | "DEFAULT" | "WARNING" | "ERROR";
+export type LlmTraceBody = {
+    id: string;
+    name: string;
+    sessionId?: string | null;
+    userId?: string | null;
+    input?: unknown;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+};
+export type LlmSpanBody = {
+    id: string;
+    traceId: string;
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+    startTime?: Date;
+    endTime?: Date;
+    level?: LlmObservationLevel;
+    statusMessage?: string | null;
+};
+export type LlmGenerationBody = LlmSpanBody & {
+    model?: string | null;
+    completionStartTime?: Date | null;
+    usageDetails?: Record<string, number>;
+    costDetails?: Record<string, number>;
+};
+export type LlmEventBody = {
+    id: string;
+    traceId: string;
+    name: string;
+    input?: unknown;
+    metadata?: Record<string, unknown>;
+    startTime?: Date;
+};
+export type LlmTracingClient = {
+    trace(body: LlmTraceBody): void;
+    span(body: LlmSpanBody): void;
+    generation(body: LlmGenerationBody): void;
+    event(body: LlmEventBody): void;
+    /** Never rejects; bounded at ~5s. */
+    flush(): Promise<void>;
+    /** Flush + stop background timers. Never rejects; bounded at ~5s. */
+    shutdown(): Promise<void>;
+};
+/**
+ * FAIL CLOSED: LLM tracing is on only when OXYGEN_LLM_TRACING_ENABLED is exactly
+ * "1"/"true" (trimmed, case-insensitive) AND both Langfuse keys are present.
+ */
+export declare function isLlmTracingEnabled(env?: EnvMap): boolean;
+export declare function resolveLlmTracingEnvironment(env?: EnvMap): string;
+type LangfuseLike = Pick<Langfuse, "trace" | "span" | "generation" | "event" | "flushAsync" | "shutdownAsync"> & {
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+};
+/**
+ * Construct a fail-open Langfuse client, or `null` when tracing is disabled or
+ * misconfigured. Prefer the process-wide `getLlmTracingClient` in app code;
+ * this direct factory exists for tests (inject `langfuseImpl`).
+ */
+export declare function createLlmTracingClient(env?: EnvMap, options?: {
+    langfuseImpl?: LangfuseLike;
+}): LlmTracingClient | null;
+export declare function getLlmTracingClient(env?: EnvMap): LlmTracingClient | null;
+/** Flush the singleton if it exists. Never rejects. Hang off request/cycle ends. */
+export declare function flushLlmTracing(env?: EnvMap): Promise<void>;
+type FlushScheduler = (task: () => Promise<void>) => void;
+export declare function setLlmTracingFlushScheduler(scheduler: FlushScheduler | null): void;
+/** Request-safe flush trigger: post-response on web, fire-and-forget elsewhere. */
+export declare function scheduleLlmTracingFlush(env?: EnvMap): void;
+/** Shutdown the singleton (worker exit). Never rejects. */
+export declare function shutdownLlmTracing(env?: EnvMap): Promise<void>;
+export declare function __resetLlmTracingForTests(): void;
+export {};

package/node_modules/@oxygen/shared/dist/langfuse.js

@@ -0,0 +1,231 @@
+// LLM-observability transport (ADR 0014): Langfuse is the ONE sanctioned store
+// for full prompt/completion/tool-IO payloads. Axiom stays metadata-only (log.ts
+// redaction drops prompt/input/output-named fields BY DESIGN — that boundary is
+// unchanged), and PostHog stays sanitized product analytics. This module
+// deliberately rides the official `langfuse` SDK's own batched ingestion instead
+// of the OTel pipeline so prompt-bearing telemetry can never reach the Axiom
+// OTLP exporters by construction.
+//
+// Fail-open doctrine: tracing must never fail or stall product work. Every
+// method swallows internally (worst case: one throttled metadata-only warn via
+// log()), `flush()`/`shutdown()` never reject and are time-bounded, and a
+// missing flag/key yields `null` (callers no-op). Deterministic observation ids
+// are the caller's job — Langfuse upserts by id, which is what makes worker
+// lease-reclaim replays converge instead of duplicating.
+import { Langfuse } from "langfuse";
+import { log } from "./log.js";
+const FLUSH_TIMEOUT_MS = 5_000;
+const WARN_THROTTLE_MS = 30_000;
+// Defensive per-field bound, well under Langfuse's ~1 MB event cap. Copilot
+// transcripts max out around 150 KB; anything larger is truncated with an
+// explicit marker rather than risking a rejected ingestion batch.
+const MAX_JSON_FIELD_CHARS = 400_000;
+/**
+ * FAIL CLOSED: LLM tracing is on only when OXYGEN_LLM_TRACING_ENABLED is exactly
+ * "1"/"true" (trimmed, case-insensitive) AND both Langfuse keys are present.
+ */
+export function isLlmTracingEnabled(env = process.env) {
+    const raw = env.OXYGEN_LLM_TRACING_ENABLED;
+    if (typeof raw !== "string")
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized !== "1" && normalized !== "true")
+        return false;
+    return ((env.LANGFUSE_PUBLIC_KEY?.trim() ?? "") !== "" &&
+        (env.LANGFUSE_SECRET_KEY?.trim() ?? "") !== "");
+}
+// The Langfuse "environment" dimension separates dev/prod traces inside one
+// project. Explicit LANGFUSE_TRACING_ENVIRONMENT (Doppler, per config) wins.
+// Defaults per runtime: web has VERCEL_ENV; the Fly worker has NO VERCEL_ENV
+// (and NODE_ENV=production on BOTH worker apps), so mirror the worker telemetry
+// convention (apps/worker/src/telemetry.ts): the Fly-injected app name is the
+// ground truth for prod vs dev — the "-dev" suffix marks the dev app; a
+// cross-env Doppler drift cannot fake it (the OXY-1183 lesson) — then
+// FLY_ENVIRONMENT as the softer signal. Everything else → development.
+export function resolveLlmTracingEnvironment(env = process.env) {
+    const explicit = env.LANGFUSE_TRACING_ENVIRONMENT?.trim().toLowerCase();
+    if (explicit)
+        return explicit.replace(/[^a-z0-9_-]/g, "-");
+    if (env.VERCEL_ENV)
+        return env.VERCEL_ENV === "production" ? "production" : "development";
+    const flyApp = env.FLY_APP_NAME ?? env.FLY_APP;
+    if (flyApp)
+        return flyApp.includes("-dev") ? "development" : "production";
+    const flyEnv = env.FLY_ENVIRONMENT?.trim().toLowerCase();
+    if (flyEnv)
+        return flyEnv === "production" ? "production" : "development";
+    return "development";
+}
+// Bound one JSON-bearing field. Over the cap → an explicit truncation marker
+// (never a silently clipped payload that parses as complete).
+function boundJsonField(value) {
+    if (value === undefined || value === null)
+        return value;
+    let serialized;
+    try {
+        serialized = JSON.stringify(value) ?? "";
+    }
+    catch {
+        return { truncated: true, reason: "unserializable" };
+    }
+    if (serialized.length <= MAX_JSON_FIELD_CHARS)
+        return value;
+    return {
+        truncated: true,
+        chars: serialized.length,
+        preview: serialized.slice(0, MAX_JSON_FIELD_CHARS),
+    };
+}
+function compact(body) {
+    const out = {};
+    for (const [key, value] of Object.entries(body)) {
+        if (value === undefined)
+            continue;
+        out[key] = key === "input" || key === "output" ? boundJsonField(value) : value;
+    }
+    return out;
+}
+function boundedNever(rejectable, warn) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, FLUSH_TIMEOUT_MS);
+        timer.unref?.();
+        rejectable
+            .catch((error) => warn(error))
+            .finally(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+/**
+ * Construct a fail-open Langfuse client, or `null` when tracing is disabled or
+ * misconfigured. Prefer the process-wide `getLlmTracingClient` in app code;
+ * this direct factory exists for tests (inject `langfuseImpl`).
+ */
+export function createLlmTracingClient(env = process.env, options) {
+    if (!options?.langfuseImpl && !isLlmTracingEnabled(env))
+        return null;
+    let lastWarnAtMs = 0;
+    const warn = (error, context) => {
+        const nowMs = Date.now();
+        if (nowMs - lastWarnAtMs < WARN_THROTTLE_MS)
+            return;
+        lastWarnAtMs = nowMs;
+        log("warn", "llm_tracing.ingest_failed", {
+            provider: "langfuse",
+            error_message: error instanceof Error ? error.message : String(error),
+            ...context,
+        });
+    };
+    let sdk;
+    try {
+        sdk =
+            options?.langfuseImpl ??
+                new Langfuse({
+                    publicKey: env.LANGFUSE_PUBLIC_KEY,
+                    secretKey: env.LANGFUSE_SECRET_KEY,
+                    ...(env.LANGFUSE_BASE_URL?.trim() ? { baseUrl: env.LANGFUSE_BASE_URL.trim() } : {}),
+                    environment: resolveLlmTracingEnvironment(env),
+                    sdkIntegration: "oxygen",
+                });
+    }
+    catch (error) {
+        warn(error, { stage: "construct" });
+        return null;
+    }
+    // The SDK surfaces async ingest failures on its emitter; unheard, they are
+    // unhandled rejections. Route them into the throttled warn.
+    try {
+        sdk.on?.("error", (error) => warn(error, { stage: "ingest" }));
+    }
+    catch {
+        // an emitter-less test double is fine
+    }
+    const guarded = (fn, stage) => {
+        try {
+            fn();
+        }
+        catch (error) {
+            warn(error, { stage });
+        }
+    };
+    return {
+        trace: (body) => guarded(() => void sdk.trace(compact(body)), "trace"),
+        span: (body) => guarded(() => void sdk.span(compact(body)), "span"),
+        generation: (body) => guarded(() => void sdk.generation(compact(body)), "generation"),
+        event: (body) => guarded(() => void sdk.event(compact(body)), "event"),
+        flush: () => boundedNever(sdk.flushAsync(), (error) => warn(error, { stage: "flush" })),
+        shutdown: () => boundedNever(sdk.shutdownAsync(), (error) => warn(error, { stage: "shutdown" })),
+    };
+}
+// --- Process-wide singleton (both runtimes construct at most one client) ------
+let cached = null;
+function cacheKey(env) {
+    return [
+        env.OXYGEN_LLM_TRACING_ENABLED ?? "",
+        env.LANGFUSE_PUBLIC_KEY ?? "",
+        env.LANGFUSE_SECRET_KEY ?? "",
+        env.LANGFUSE_BASE_URL ?? "",
+        resolveLlmTracingEnvironment(env),
+    ].join("|");
+}
+export function getLlmTracingClient(env = process.env) {
+    const key = cacheKey(env);
+    if (cached && cached.key === key)
+        return cached.client;
+    cached = { key, client: createLlmTracingClient(env) };
+    return cached.client;
+}
+/** Flush the singleton if it exists. Never rejects. Hang off request/cycle ends. */
+export function flushLlmTracing(env = process.env) {
+    if (!isLlmTracingEnabled(env))
+        return Promise.resolve();
+    const client = getLlmTracingClient(env);
+    return client ? client.flush() : Promise.resolve();
+}
+// Serverless flush scheduling (the axiom-log-shipper pattern): the web runtime
+// registers next/server's after() here at instrumentation time; emission sites
+// then call scheduleLlmTracingFlush() and the flush runs post-response instead
+// of adding latency inside the request. Off-web (worker, tests) there is no
+// scheduler and the flush degrades to fire-and-forget — the worker's cycle-end
+// awaited flush + SDK interval flush are the durability guarantee there.
+//
+// The registration lives on globalThis, not in a module-local: Next.js gives
+// instrumentation.ts and each route handler their own copy of this module, so a
+// module-local set at instrumentation time is invisible to the routes that emit
+// traces — their flushes silently degraded to fire-and-forget, which a Vercel
+// post-response freeze can kill. Same slot pattern as setLogSink and the
+// LinkedIn/WhatsApp quota enforcers. (The `cached` client stays module-local on
+// purpose: each bundle flushing its own client is correct — the run closure
+// below flushes the CALLING bundle's client through the shared scheduler.)
+const FLUSH_SCHEDULER_SLOT = Symbol.for("oxygen.llm_tracing.flush_scheduler");
+export function setLlmTracingFlushScheduler(scheduler) {
+    globalThis[FLUSH_SCHEDULER_SLOT] = scheduler;
+}
+/** Request-safe flush trigger: post-response on web, fire-and-forget elsewhere. */
+export function scheduleLlmTracingFlush(env = process.env) {
+    if (!isLlmTracingEnabled(env))
+        return;
+    const run = () => flushLlmTracing(env);
+    const flushScheduler = globalThis[FLUSH_SCHEDULER_SLOT] ?? null;
+    if (flushScheduler) {
+        try {
+            flushScheduler(run);
+            return;
+        }
+        catch {
+            // Outside a request scope after() throws — degrade to fire-and-forget.
+        }
+    }
+    void run();
+}
+/** Shutdown the singleton (worker exit). Never rejects. */
+export function shutdownLlmTracing(env = process.env) {
+    const client = cached?.client;
+    cached = null;
+    return client ? client.shutdown() : Promise.resolve();
+}
+export function __resetLlmTracingForTests() {
+    cached = null;
+    globalThis[FLUSH_SCHEDULER_SLOT] = null;
+}

package/node_modules/@oxygen/shared/dist/log.js

@@ -57,9 +57,21 @@ function reserveSurfaceDimension(merged, ctx) {
         surface: ctx.surface,
     };
 }
-let logSink = null;
+// The sink registration must live on globalThis, not in a module-local variable:
+// Next.js compiles instrumentation.ts and each route handler into separate
+// bundles, each with its OWN instance of this module. A module-local set by the
+// web log shipper (which starts in instrumentation) is invisible to route
+// handlers — exactly why only startup-context lines (the shipper beacon, the
+// framework console filter) ever shipped flat while 4k+ route-emitted
+// error/warn lines/day stayed drain-only (2026-07-21). globalThis is the one
+// object all bundle copies share; Symbol.for gives every copy the same slot.
+// Same trap + same fix as linkedin-quota's enforcer registration.
+const LOG_SINK_SLOT = Symbol.for("oxygen.log.sink");
 export function setLogSink(sink) {
-    logSink = sink;
+    globalThis[LOG_SINK_SLOT] = sink;
+}
+function getLogSink() {
+    return globalThis[LOG_SINK_SLOT] ?? null;
 }
 export function log(level, msg, fields) {
     const context = getLogContext();
@@ -89,6 +101,7 @@ export function log(level, msg, fields) {
     else {
         console.log(line);
     }
+    const logSink = getLogSink();
     if (!logSink)
         return;
     try {

package/node_modules/@oxygen/shared/dist/tags.d.ts

@@ -1,5 +1,5 @@
 /** Primitive kinds that participate in the workspace tag union today. */
-export declare const TAG_KINDS: readonly ["knowledge_page", "publishing_post", "sequence", "table", "workflow", "recipe"];
+export declare const TAG_KINDS: readonly ["knowledge_page", "publishing_post", "sequence", "table", "workflow", "recipe", "conversation", "mailbox", "sender", "record"];
 export type TagKind = (typeof TAG_KINDS)[number];
 export declare function isTagKind(value: unknown): value is TagKind;
 /** Hard cap per tagged item — matches the wiki's long-standing limit. */

package/node_modules/@oxygen/shared/dist/tags.js

@@ -12,6 +12,10 @@ export const TAG_KINDS = [
     "table",
     "workflow",
     "recipe",
+    "conversation",
+    "mailbox",
+    "sender",
+    "record",
 ];
 export function isTagKind(value) {
     return typeof value === "string" && TAG_KINDS.includes(value);

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,3 +1,3 @@
-export declare const OXYGEN_VERSION = "1.365.3";
+export declare const OXYGEN_VERSION = "1.377.3";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.365.3";
+export const OXYGEN_VERSION = "1.377.3";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/node_modules/@oxygen/shared/dist/workspace-agents.d.ts

@@ -1,11 +1,11 @@
-/** The three implemented Workspace Agent specialists, by stable slug. */
-export type WorkspaceAgentSlug = "inbox-reply-drafts" | "meeting-notetaker" | "knowledge-synthesis";
+/** The implemented general Workspace Agent and specialists (incl. the auto-tagger), by stable slug. */
+export type WorkspaceAgentSlug = "workspace" | "inbox-reply-drafts" | "meeting-notetaker" | "knowledge-synthesis" | "inbox-auto-tagger";
 /**
  * How the web layer builds a specialist's deep-link. A pure hint on the
  * descriptor (shared can't import the web URL helpers) that agent-registry
  * switches on to produce the actual `https://oxygen-agent.com/...` URL.
  */
-export type WorkspaceAgentDeepLinkKind = "inbox_reply_agent" | "notetaker" | "knowledge_agent";
+export type WorkspaceAgentDeepLinkKind = "workspace_agent" | "inbox_reply_agent" | "notetaker" | "knowledge_agent" | "inbox_auto_tagger";
 /** A pure, serializable descriptor for one Workspace Agent specialist. */
 export type WorkspaceAgentDescriptor = {
     /** Stable identifier used across CLI/MCP/API. Never derived from the title. */
@@ -54,12 +54,13 @@ export type WorkspaceAgentRunItem = {
     webUrl: string | null;
 };
 /**
- * The roster. Exactly three entries — one per implemented specialist. Order is
- * stable (it drives the default CLI/widget ordering). Adding a fourth entry is a
- * deliberate product decision that requires the specialist to actually ship first.
+ * The roster. The general Workspace Agent plus the implemented specialists
+ * (five entries). Order is stable (it drives the default CLI/widget ordering).
+ * Adding an entry is a deliberate product decision that requires the worker to
+ * actually ship first.
  */
 export declare const WORKSPACE_AGENT_ROSTER: readonly WorkspaceAgentDescriptor[];
-/** True when `value` is one of the three implemented specialist slugs. */
+/** True when `value` is one of the implemented specialist slugs. */
 export declare function isWorkspaceAgentSlug(value: unknown): value is WorkspaceAgentSlug;
 /** The descriptor for `slug`, or `undefined` when it is not a known specialist. */
 export declare function getWorkspaceAgentDescriptor(slug: string): WorkspaceAgentDescriptor | undefined;

package/node_modules/@oxygen/shared/dist/workspace-agents.js

@@ -1,11 +1,13 @@
 // The Agents primitive's roster (ADR 0011): the governed registry of OXYGEN's
-// built-in workspace agents. Still deliberately a *computed* registry — each
+// built-in workspace agents. The general Workspace Agent is backed by the
+// first-class ox_agents runtime; specialists remain computed from their owning
+// primitive stores. Each
 // entry is a product-defined agent that ships as an approval-gated, observable
 // behavior elsewhere in the product, surfaced under /agents and `oxygen agent`.
 // Agents are governed workspace workers: the runtime envelope (approval posture,
 // credit budgets, run observability) is platform-enforced, never agent-optional.
-// User-defined custom agents are ratified (ADR 0011) but arrive with the unified
-// runtime envelope in a later phase — until then there is no create/define verb,
+// User-defined custom agents are ratified (ADR 0011) but arrive after the unified
+// Workspace Agent runtime — until then there is no custom create/delete verb,
 // and there are never placeholder rows: the roster lists only agents that are
 // actually implemented today. CRM-hygiene, deliverability, and any other roadmap
 // agent stay OUT until they ship — the no-placeholder-surface rule.
@@ -15,11 +17,24 @@
 // (config read/write, run history, deep-links) lives in the web layer's
 // agent-registry, which composes these descriptors with the existing helpers.
 /**
- * The roster. Exactly three entries — one per implemented specialist. Order is
- * stable (it drives the default CLI/widget ordering). Adding a fourth entry is a
- * deliberate product decision that requires the specialist to actually ship first.
+ * The roster. The general Workspace Agent plus the implemented specialists
+ * (five entries). Order is stable (it drives the default CLI/widget ordering).
+ * Adding an entry is a deliberate product decision that requires the worker to
+ * actually ship first.
  */
 export const WORKSPACE_AGENT_ROSTER = [
+    {
+        slug: "workspace",
+        title: "Workspace Agent",
+        subtitle: "Runs organization-grounded goals through OXYGEN's governed capability catalog.",
+        description: "Takes a workspace goal, plans the work, and operates tables, CRM, context, workflows, sequences, files, and integrations as one durable Agent run.",
+        owningPrimitive: "Agents",
+        configCommand: "oxygen agent set workspace",
+        configApiPath: "/api/cli/agent/workspace",
+        mcpConfigTools: ["oxygen_agent_update", "oxygen_agent_run"],
+        approvalPosture: "Uses a versioned standing authorization with optional allow, ask, and deny rules; platform previews, caps, deny rules, and run provenance always apply.",
+        deepLinkKind: "workspace_agent",
+    },
     {
         slug: "inbox-reply-drafts",
         title: "AI Sales Agent",
@@ -56,8 +71,20 @@ export const WORKSPACE_AGENT_ROSTER = [
         approvalPosture: "Writes working knowledge pages as logged revisions; canonical and pinned pages still require proposal approval.",
         deepLinkKind: "knowledge_agent",
     },
+    {
+        slug: "inbox-auto-tagger",
+        title: "AI Inbox Tagger",
+        subtitle: "Auto-tags new inbound conversations from your tag allowlist.",
+        description: "Classifies every new inbound email, LinkedIn, and WhatsApp conversation against your workspace tag allowlist and applies the matching tags automatically.",
+        owningPrimitive: "Messages",
+        configCommand: "oxygen inbox auto-tagger",
+        configApiPath: "/api/cli/inbox/auto-tagger",
+        mcpConfigTools: ["oxygen_inbox_auto_tagger_get", "oxygen_inbox_auto_tagger_set"],
+        approvalPosture: "Auto-applies internal workspace tags only — additive, never re-adds a tag you removed, and needs no approval queue because tags never leave the workspace.",
+        deepLinkKind: "inbox_auto_tagger",
+    },
 ];
-/** True when `value` is one of the three implemented specialist slugs. */
+/** True when `value` is one of the implemented specialist slugs. */
 export function isWorkspaceAgentSlug(value) {
     return (typeof value === "string" &&
         WORKSPACE_AGENT_ROSTER.some((descriptor) => descriptor.slug === value));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.365.3",
+  "version": "1.377.3",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
@@ -32,9 +32,12 @@
     "README.md"
   ],
   "dependencies": {
+    "@aws-sdk/client-s3": "3.1050.0",
+    "@aws-sdk/s3-request-presigner": "3.1050.0",
     "@opentelemetry/api": "1.9.1",
     "commander": "14.0.3",
     "esbuild": "0.27.7",
+    "langfuse": "3.38.20",
     "read-excel-file": "6.0.3",
     "typescript": "6.0.3",
     "@oxygen/shared": "0.0.0",