@oxygen-agent/cli 1.1011.687 → 1.1011.800

package/node_modules/@oxygen/shared/dist/contracts/table-feed-update.js

@@ -0,0 +1,55 @@
+/** Native Table feed PATCH grammar. Scheduling and credit authority remain server-owned. */
+import { arr, bool, enumOf, int, nullable, obj, str, validateContract } from "./schema.js";
+const json = { type: "object", additionalProperties: true };
+const path = () => nullable(str());
+export const TABLE_FEED_LANE_CONTRACT = obj({
+    tool_id: str({ minLength: 1 }), request: json,
+    rows_path: path(), row_mapping: nullable(json), cursor_path: path(), cursor_request_key: path(),
+}, { required: ["tool_id", "request"] });
+export const TABLE_FEED_ROUTE_CONTRACT = obj({
+    ...TABLE_FEED_LANE_CONTRACT.properties,
+    tool_ids: arr(str({ minLength: 1 })), lanes: arr(TABLE_FEED_LANE_CONTRACT, { minItems: 1 }),
+    max_pages: int({ minimum: 1 }), upsert_key: path(),
+}, { required: ["tool_id", "request"] });
+export const TABLE_FEED_GET_OPTIONS_CONTRACT = obj({ include_route: bool({ description: "Complete frozen request/mappings/lanes; no runtime cursor or resolved credentials." }) });
+export const TABLE_FEED_UPDATE_CONTRACT = obj({
+    feed: str({ minLength: 1 }), name: str(), status: enumOf(["active", "disabled"]),
+    run_state: enumOf(["idle", "running", "error", "exhausted"]),
+    sync: obj({
+        every: nullable(str({ description: "hourly, every_6h, daily@<0-23>, weekly@<day><hour>; UTC. null removes the cron." })),
+        max_credits_per_cycle: { type: "number", exclusiveMinimum: 0, description: "Future-cycle ceiling; configuration spends nothing." },
+        max_rows_per_cycle: int({ minimum: 1 }),
+    }, { description: "Omitted fields keep their values." }),
+    route: { ...TABLE_FEED_ROUTE_CONTRACT, description: "Full frozen route from feeds_get(include_route=true). Replacement resets cursor/error. Scheduled replacements require one executable lane; distinct fallbacks require no cadence." },
+    filters: json, intent_id: str(), input_shape: str(), route_id: str(), registry_version: str(), source_prompt: str(),
+    approved: bool({ description: "Human authorization for expanded recurring scope; a free config call grants no future spend." }),
+}, { required: ["feed"] });
+/** New surfaces refuse provenance edits the native PATCH would otherwise ignore. */
+export function tableFeedUpdateIssues(args) {
+    const checked = validateContract(TABLE_FEED_UPDATE_CONTRACT, args, { unknown: "reject", overMax: "reject" });
+    const errors = checked.ok ? [] : checked.issues.map(issue => issue.message);
+    if (!args.route && ["filters", "intent_id", "input_shape", "route_id", "registry_version", "source_prompt"].some(key => args[key] !== undefined)) {
+        errors.push("Source provenance changes require the complete route; edit its request to change executable filters.");
+    }
+    return errors;
+}
+export const TABLE_FEED_UPDATE_OPERATION = {
+    id: "tables.feeds.update", route: "/api/cli/tables/feeds", method: "PATCH", contract: TABLE_FEED_UPDATE_CONTRACT,
+    generated: { cli: false, mcp: false },
+    cli: { path: ["feeds", "update"], summary: "Update an existing Table feed in place; changed cadence, increased cap or source scope can require renewed standing authorization." },
+    mcp: { name: "oxygen_feeds_update", title: "Oxygen: Update Table Feed", pack: "signals",
+        description: "Update an existing Table feed in place. Inspect feeds_get(include_route=true) first. Replacement resets cursor/error. Changed cadence, raised cap or source can require approved=true. Scheduled replacements require one executable lane; distinct fallbacks require no cadence. Native approval, budget and incremental guards apply. Configuration is free; future spend remains governed. Omitted fields stay unchanged. Use table_webhook_update for inbound endpoints." },
+    mutates: true, spends: false,
+};
+/** The existing native PATCH scope comparison, separate from configuration cost. */
+export function tableFeedUpdateScopeChange(args, current) {
+    const sync = args.sync && typeof args.sync === "object" && !Array.isArray(args.sync) ? args.sync : args;
+    const cadenceGiven = Object.hasOwn(args, "every") || Object.hasOwn(args, "cadence") || Object.hasOwn(sync, "every") || Object.hasOwn(sync, "cadence");
+    const every = cadenceGiven ? typeof (sync.every ?? sync.cadence) === "string" && String(sync.every ?? sync.cadence).trim() ? String(sync.every ?? sync.cadence).trim() : null : current.every;
+    const rawCap = sync.max_credits_per_cycle ?? sync.maxCreditsPerCycle ?? sync.max_credits ?? sync.maxCredits;
+    const cap = rawCap === undefined || rawCap === null || rawCap === "" ? null : Number(rawCap);
+    const raisesCap = cap !== null && current.maxCredits !== null && cap > current.maxCredits;
+    const replacesSource = Boolean(args.route && typeof args.route === "object" && !Array.isArray(args.route)) || Boolean(args.source && typeof args.source === "object" && !Array.isArray(args.source));
+    const changesCadence = cadenceGiven && every !== null && every !== current.every;
+    return { every, raisesCap, replacesSource, changesCadence, needsReapproval: raisesCap || replacesSource || changesCadence };
+}

package/node_modules/@oxygen/shared/dist/contracts/table-list.d.ts

@@ -0,0 +1,31 @@
+/** Bounded table discovery, shared by the HTTP query, CLI flags and MCP. */
+import { type Infer } from "./schema.js";
+export declare const TABLE_LIST_QUERY_CONTRACT: import("./schema.js").ContractObject<{
+    readonly project: import("./schema.js").StringProperty;
+    readonly tag: import("./schema.js").StringProperty;
+    readonly include_archived: import("./schema.js").BooleanProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly query: import("./schema.js").StringProperty;
+    readonly projection: {
+        type: "string";
+        enum: readonly ("full" | "summary")[];
+        description?: string;
+    };
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export type TableListQuery = Infer<typeof TABLE_LIST_QUERY_CONTRACT>;
+/** Unknown query keys are ignored for compatibility; only declared keys travel. */
+export declare function tableListQueryParams(query: TableListQuery): URLSearchParams;

package/node_modules/@oxygen/shared/dist/contracts/table-list.js

@@ -0,0 +1,22 @@
+/** Bounded table discovery, shared by the HTTP query, CLI flags and MCP. */
+import { bool, enumOf, int, obj, str } from "./schema.js";
+export const TABLE_LIST_QUERY_CONTRACT = obj({
+    project: str({ minLength: 1, maxLength: 200 }),
+    tag: str(),
+    include_archived: bool(),
+    limit: int({ minimum: 1, maximum: 1000, clamp: true }),
+    cursor: str({ maxLength: 2000 }),
+    query: str({ maxLength: 200, description: "Name/slug substring." }),
+    projection: enumOf(["full", "summary"]),
+    max_chars: int({ minimum: 2000, maximum: 40000 }),
+});
+/** Unknown query keys are ignored for compatibility; only declared keys travel. */
+export function tableListQueryParams(query) {
+    const params = new URLSearchParams();
+    for (const key of Object.keys(TABLE_LIST_QUERY_CONTRACT.properties)) {
+        const value = query[key];
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}

package/node_modules/@oxygen/shared/dist/contracts/table-operations.d.ts

@@ -0,0 +1,58 @@
+export declare const MAX_TABLE_RECOVERY_ITEMS = 1000;
+export declare const TABLE_FAVORITES_LIST_CONTRACT: import("./schema.js").ContractObject<{
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const TABLE_FAVORITE_CONTRACT: import("./schema.js").ContractObject<{
+    readonly table: import("./schema.js").StringProperty;
+    readonly folder: import("./schema.js").StringProperty;
+    readonly favorite: import("./schema.js").BooleanProperty;
+}, "favorite">;
+export declare const TABLE_LINK_SUGGEST_CONTRACT: import("./schema.js").ContractObject<{
+    readonly table: import("./schema.js").StringProperty;
+    readonly to: import("./schema.js").StringProperty;
+    readonly on: import("./schema.js").StringProperty;
+    readonly scan_limit: {
+        type: "number";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, "table" | "to">;
+export declare const TABLE_EFFECT_OUTCOMES: readonly ["applied", "not_applied"];
+export declare const TABLE_ITEM_RESOLVE_CONTRACT: import("./schema.js").ContractObject<{
+    readonly outcome: {
+        type: "string";
+        enum: readonly ("applied" | "not_applied")[];
+        description?: string;
+    };
+    readonly note: import("./schema.js").StringProperty;
+    readonly value: {
+        type?: never;
+        description?: string;
+    };
+}, "outcome">;
+export declare const TABLE_RECOVER_PENDING_CONTRACT: import("./schema.js").ContractObject<{
+    readonly table: import("./schema.js").StringProperty;
+    readonly max_items: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, "table">;

package/node_modules/@oxygen/shared/dist/contracts/table-operations.js

@@ -0,0 +1,30 @@
+/** Customer Table operations; the native routes retain identity and effect guards. */
+import { bool, enumOf, int, jsonValue, num, obj, str } from "./schema.js";
+const table = str({ minLength: 1, description: "Table id, slug, or Oxygen table URL." });
+export const MAX_TABLE_RECOVERY_ITEMS = 1000;
+export const TABLE_FAVORITES_LIST_CONTRACT = obj({
+    limit: int({ minimum: 1, maximum: 200, description: "Page size; MCP default 20." }),
+    cursor: str({ maxLength: 512, description: "Previous next_cursor; restart if stars changed." }),
+    max_chars: int({ minimum: 500, maximum: 10_000, description: "Complete response cap in characters." }),
+});
+export const TABLE_FAVORITE_CONTRACT = obj({
+    table: str({ minLength: 1, description: "Table id, slug, or Oxygen table URL. Pass exactly one of table or folder." }),
+    folder: str({ minLength: 1, description: "Folder id or slug. Pass exactly one of table or folder." }),
+    favorite: bool({ description: "true stars; false unstars." }),
+}, { required: ["favorite"] });
+export const TABLE_LINK_SUGGEST_CONTRACT = obj({
+    table,
+    to: table,
+    on: str({ description: "Optional join column key or id." }),
+    scan_limit: num({ description: "Native planner scan limit; bounded server-side." }),
+}, { required: ["table", "to"] });
+export const TABLE_EFFECT_OUTCOMES = ["applied", "not_applied"];
+export const TABLE_ITEM_RESOLVE_CONTRACT = obj({
+    outcome: enumOf(TABLE_EFFECT_OUTCOMES),
+    note: str(),
+    value: jsonValue({ description: "Verified cell result; any JSON, including null." }),
+}, { required: ["outcome"] });
+export const TABLE_RECOVER_PENDING_CONTRACT = obj({
+    table: str({ minLength: 1, description: "Table id or slug." }),
+    max_items: int({ minimum: 1, maximum: MAX_TABLE_RECOVERY_ITEMS, description: "Pending requests to poll; default 1000." }),
+}, { required: ["table"] });

package/node_modules/@oxygen/shared/dist/contracts/workflow-run-list.d.ts

@@ -0,0 +1,79 @@
+export declare const WORKFLOW_RUN_STATUS_VALUES: readonly ["queued", "running", "waiting", "awaiting_approval", "completed", "failed", "canceling", "canceled"];
+export declare const WORKFLOW_RUN_MODE_VALUES: readonly ["dry_run", "live", "smoke_test"];
+export declare const WORKFLOW_RUN_LIST_CONTRACT: import("./schema.js").ContractObject<{
+    readonly projection: {
+        type: "string";
+        enum: readonly ("full" | "summary" | "value")[];
+        description?: string;
+    };
+    readonly path: import("./schema.js").StringProperty;
+    readonly value_cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly workflow: import("./schema.js").StringProperty;
+    readonly workflow_id: import("./schema.js").StringProperty;
+    readonly status: import("./schema.js").StringProperty;
+    readonly mode: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly run_id: import("./schema.js").StringProperty;
+}, never>;
+export declare const WORKFLOW_RUN_LIST_MCP_CONTRACT: import("./schema.js").ContractObject<{
+    readonly projection: {
+        type: "string";
+        enum: readonly ("full" | "summary" | "value")[];
+        description?: string;
+    };
+    readonly path: import("./schema.js").StringProperty;
+    readonly value_cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly workflow: import("./schema.js").StringProperty;
+    readonly workflow_id: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly run_id: import("./schema.js").StringProperty;
+    readonly status: {
+        type: "string";
+        enum: readonly ("awaiting_approval" | "canceled" | "canceling" | "completed" | "failed" | "queued" | "running" | "waiting")[];
+        description?: string;
+    };
+    readonly mode: {
+        type: "string";
+        enum: readonly ("dry_run" | "live" | "smoke_test")[];
+        description?: string;
+    };
+}, never>;
+/** The native GET keeps raw strings, canonical alias precedence and absent
+ * values. CLI legacy trimming is an explicit adapter above this contract. */
+export declare function workflowRunListQueryParams(args: Record<string, unknown>): URLSearchParams;
+/** Exact native HTTP scalar selection, including blank canonical precedence. */
+export declare function readWorkflowRunListSelectors(params: URLSearchParams): {
+    workflowIdOrSlug: string | null;
+    status: string | null;
+    mode: string | null;
+    cursor: string | null;
+    runId: string | null;
+};

package/node_modules/@oxygen/shared/dist/contracts/workflow-run-list.js

@@ -0,0 +1,38 @@
+import { enumOf, int, obj, str } from "./schema.js";
+import { STORED_READ_WINDOW_FIELDS } from "./stored-read-window.js";
+export const WORKFLOW_RUN_STATUS_VALUES = ["queued", "running", "waiting", "awaiting_approval", "completed", "failed", "canceling", "canceled"];
+export const WORKFLOW_RUN_MODE_VALUES = ["dry_run", "live", "smoke_test"];
+export const WORKFLOW_RUN_LIST_CONTRACT = obj({
+    workflow: str({ minLength: 1, maxLength: 400, description: "Workflow id, slug, exact name, or copied URL." }),
+    workflow_id: str({ minLength: 1, maxLength: 400, description: "Canonical workflow ref; takes precedence over workflow on HTTP/MCP." }),
+    status: str({ description: "Stored status filter: queued, running, waiting, awaiting_approval, completed, failed, canceling, canceled. Native validation trims and ignores case." }),
+    mode: str({ description: "Stored execution mode filter: dry_run, live or smoke_test. Never runs a workflow." }),
+    cursor: str({ description: "Previous nextCursor, echoed unchanged with the same filters." }),
+    limit: int({ minimum: 1, maximum: 500, description: "Runs per page; native default 50." }),
+    run_id: str({ minLength: 1, maxLength: 80, description: "Exact stored run UUID within the same workflow/status/mode/cursor filters; opt-in windows only." }),
+    ...STORED_READ_WINDOW_FIELDS,
+});
+export const WORKFLOW_RUN_LIST_MCP_CONTRACT = obj({
+    ...WORKFLOW_RUN_LIST_CONTRACT.properties,
+    status: enumOf(WORKFLOW_RUN_STATUS_VALUES, { description: "Stored run status filter." }),
+    mode: enumOf(WORKFLOW_RUN_MODE_VALUES, { description: "Stored execution mode filter; executes nothing." }),
+});
+/** The native GET keeps raw strings, canonical alias precedence and absent
+ * values. CLI legacy trimming is an explicit adapter above this contract. */
+export function workflowRunListQueryParams(args) {
+    const pairs = [];
+    for (const key of Object.keys(WORKFLOW_RUN_LIST_CONTRACT.properties)) {
+        const value = args[key];
+        if (value !== undefined && value !== null)
+            pairs.push([key, String(value)]);
+    }
+    return new URLSearchParams(pairs);
+}
+/** Exact native HTTP scalar selection, including blank canonical precedence. */
+export function readWorkflowRunListSelectors(params) {
+    return {
+        workflowIdOrSlug: params.get("workflow_id") ?? params.get("workflow"),
+        status: params.get("status"), mode: params.get("mode"),
+        cursor: params.get("cursor"), runId: params.get("run_id"),
+    };
+}

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

@@ -12,8 +12,8 @@ export declare const COPILOT_JOURNEYS: readonly [{
     readonly slug: "inbound-led-outbound";
     readonly title: "Inbound-led outbound";
     readonly description: "Turn the people who engage with your LinkedIn posts into a capped, evidence-gated warm sequence with replies routed to your CRM.";
-    readonly recipeSlugs: readonly ["inbound-led-outbound", "linkedin-network-first-motion", "founder-posting-system", "reply-to-meeting"];
-    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me set up inbound-led outbound for my LinkedIn posts: watch who engages with them every day, assess each person against my ICP, hand me the strong fits, put the possible fits into a draft LinkedIn sequence on a schedule, move replies into my CRM, and write what we learn back into my knowledge wiki. Inspect the workspace first, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
+    readonly recipeSlugs: readonly ["inbound-led-outbound", "founder-posting-system", "reply-to-meeting"];
+    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me turn the people paying attention to me on LinkedIn into conversations: capture a small sample, score each person against my ideal customer, show me the good fits and draft a LinkedIn message I approve. Inspect the workspace first and resume from what exists. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
 }, {
     readonly slug: "email-infra-setup";
     readonly title: "Outbound infrastructure";

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

@@ -2,8 +2,8 @@ export declare const COPILOT_JOURNEYS_GENERATED: readonly [{
     readonly slug: "inbound-led-outbound";
     readonly title: "Inbound-led outbound";
     readonly description: "Turn the people who engage with your LinkedIn posts into a capped, evidence-gated warm sequence with replies routed to your CRM.";
-    readonly recipeSlugs: readonly ["inbound-led-outbound", "linkedin-network-first-motion", "founder-posting-system", "reply-to-meeting"];
-    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me set up inbound-led outbound for my LinkedIn posts: watch who engages with them every day, assess each person against my ICP, hand me the strong fits, put the possible fits into a draft LinkedIn sequence on a schedule, move replies into my CRM, and write what we learn back into my knowledge wiki. Inspect the workspace first, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
+    readonly recipeSlugs: readonly ["inbound-led-outbound", "founder-posting-system", "reply-to-meeting"];
+    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me turn the people paying attention to me on LinkedIn into conversations: capture a small sample, score each person against my ideal customer, show me the good fits and draft a LinkedIn message I approve. Inspect the workspace first and resume from what exists. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
 }, {
     readonly slug: "email-infra-setup";
     readonly title: "Outbound infrastructure";

package/node_modules/@oxygen/shared/dist/copilot-journeys.generated.js

@@ -6,8 +6,8 @@ export const COPILOT_JOURNEYS_GENERATED = [
         slug: "inbound-led-outbound",
         title: "Inbound-led outbound",
         description: "Turn the people who engage with your LinkedIn posts into a capped, evidence-gated warm sequence with replies routed to your CRM.",
-        recipeSlugs: ["inbound-led-outbound", "linkedin-network-first-motion", "founder-posting-system", "reply-to-meeting"],
-        seedMessage: "I chose the inbound-led-outbound recipe. Help me set up inbound-led outbound for my LinkedIn posts: watch who engages with them every day, assess each person against my ICP, hand me the strong fits, put the possible fits into a draft LinkedIn sequence on a schedule, move replies into my CRM, and write what we learn back into my knowledge wiki. Inspect the workspace first, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.",
+        recipeSlugs: ["inbound-led-outbound", "founder-posting-system", "reply-to-meeting"],
+        seedMessage: "I chose the inbound-led-outbound recipe. Help me turn the people paying attention to me on LinkedIn into conversations: capture a small sample, score each person against my ideal customer, show me the good fits and draft a LinkedIn message I approve. Inspect the workspace first and resume from what exists. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.",
     },
     {
         slug: "email-infra-setup",

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

@@ -1,15 +1,15 @@
 export declare const COPILOT_PLAYBOOKS_GENERATED: readonly [{
     readonly slug: "icp-to-account-map";
     readonly title: "TAM sourcing";
-    readonly prompt: "Turn our ICP into a scored list of target accounts, with the evidence behind each score, so I can see which segments fit best.";
+    readonly prompt: "Find about 25 companies that look like our best customers, grade how well each one fits and why, and show me which kinds fit best. If I share a list, portfolio page or event list, grade that instead.";
 }, {
     readonly slug: "founder-posting-system";
     readonly title: "LinkedIn content strategy";
-    readonly prompt: "Help me post on LinkedIn consistently in my own voice: draft posts from our positioning and ICP, let me approve each one, and track how they perform.";
+    readonly prompt: "Help me post on LinkedIn regularly in my own voice: draft a few posts about what we do and who we help, or plan a whole week, let me approve each one before it goes out, and show me how they do.";
 }, {
     readonly slug: "inbound-led-outbound";
     readonly title: "Inbound-led outbound";
-    readonly prompt: "Turn the people who react to and comment on LinkedIn posts I pick into pipeline: score them against our ICP and message only the good fits from a capped sequence.";
+    readonly prompt: "Turn the people paying attention to us on LinkedIn into pipeline: people reacting to my posts or to posts by people I pick, my followers and connections, or my profile viewers. Score them against our ideal customer and message only the good fits on LinkedIn, a few a day.";
 }, {
     readonly slug: "daily-warm-lead-queue";
     readonly title: "Signal-based outbound";

package/node_modules/@oxygen/shared/dist/copilot-playbooks.generated.js

@@ -6,17 +6,17 @@ export const COPILOT_PLAYBOOKS_GENERATED = [
     {
         slug: "icp-to-account-map",
         title: "TAM sourcing",
-        prompt: "Turn our ICP into a scored list of target accounts, with the evidence behind each score, so I can see which segments fit best.",
+        prompt: "Find about 25 companies that look like our best customers, grade how well each one fits and why, and show me which kinds fit best. If I share a list, portfolio page or event list, grade that instead.",
     },
     {
         slug: "founder-posting-system",
         title: "LinkedIn content strategy",
-        prompt: "Help me post on LinkedIn consistently in my own voice: draft posts from our positioning and ICP, let me approve each one, and track how they perform.",
+        prompt: "Help me post on LinkedIn regularly in my own voice: draft a few posts about what we do and who we help, or plan a whole week, let me approve each one before it goes out, and show me how they do.",
     },
     {
         slug: "inbound-led-outbound",
         title: "Inbound-led outbound",
-        prompt: "Turn the people who react to and comment on LinkedIn posts I pick into pipeline: score them against our ICP and message only the good fits from a capped sequence.",
+        prompt: "Turn the people paying attention to us on LinkedIn into pipeline: people reacting to my posts or to posts by people I pick, my followers and connections, or my profile viewers. Score them against our ideal customer and message only the good fits on LinkedIn, a few a day.",
     },
     {
         slug: "daily-warm-lead-queue",

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

@@ -240,6 +240,23 @@ export const LEGACY_MANAGED_AI_COLUMN_MODELS = {
     "deepseek/deepseek-v4-pro": "medium",
     "moonshotai/kimi-k2.6": "high",
 };
+/**
+ * Managed model ids OXYGEN ran that never sat in the registry above, mapped to
+ * the tier they read as. Labeling only: unlike LEGACY_MANAGED_AI_COLUMN_MODELS,
+ * none of these is a valid managed column pin. The credit ledger keeps every id
+ * it ever recorded, so `billing usage` and `billing audit --group-by model`
+ * returned them raw (OXP-1.6.96, 2026-10-04): in production 25 workspaces hold
+ * managed openai/gpt-4.1-mini spend from before the July registry, billed at the
+ * low tier; gpt-4.1-nano ran on dev only; deepseek/deepseek-chat is the spintax
+ * generator's fixed model.
+ */
+const UNREGISTERED_MANAGED_MODEL_LEVELS = {
+    "openai/gpt-4.1-mini": "low",
+    "openai/gpt-4.1-nano": "low",
+    "deepseek/deepseek-chat": "low",
+};
+/** Dev throughput probe pin (tenant-db `resolveManagedAiModelTier` bills it at low). */
+const PERF_TEST_MODEL_ENV = "OXYGEN_OPENROUTER_MODEL_PERF_TEST";
 /** The tier a retired managed AI-column model id billed at, or null. */
 export function legacyManagedAiColumnLevel(model) {
     return Object.prototype.hasOwnProperty.call(LEGACY_MANAGED_AI_COLUMN_MODELS, model)
@@ -442,6 +459,13 @@ function managedModelLabels(preferredUseCase, env = typeof process === "undefine
         if (!labels.has(model))
             labels.set(model, MANAGED_AI_TIER_LABELS[level]);
     }
+    for (const [model, level] of Object.entries(UNREGISTERED_MANAGED_MODEL_LEVELS)) {
+        if (!labels.has(model))
+            labels.set(model, MANAGED_AI_TIER_LABELS[level]);
+    }
+    const perfTestModel = readTrimmedEnv(env, PERF_TEST_MODEL_ENV);
+    if (perfTestModel && !labels.has(perfTestModel))
+        labels.set(perfTestModel, MANAGED_AI_TIER_LABELS.low);
     for (const useCase of ordered) {
         for (const spec of Object.values(HOSTED_AI_MODEL_REGISTRY[useCase])) {
             for (const fallback of spec.fallbackModels) {

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

@@ -13,7 +13,7 @@ export declare const RECIPE_PRIMITIVES: readonly ["knowledge-graph", "recipes",
 export type RecipePrimitive = typeof RECIPE_PRIMITIVES[number];
 export declare const RECIPE_PREREQUISITE_KINDS: readonly ["sender", "mailbox", "domain", "integration", "knowledge", "asset", "plan", "data"];
 export type RecipePrerequisiteKind = typeof RECIPE_PREREQUISITE_KINDS[number];
-export declare const RECIPE_BODY_SECTIONS: readonly ["The Play", "What You Get", "When To Run (And When Not To)", "Before You Start", "Steps", "Ready Assets", "Calibrate", "Troubleshooting", "Operator Notes", "Related"];
+export declare const RECIPE_BODY_SECTIONS: readonly ["The Play", "Before You Start", "Steps", "If It Goes Wrong"];
 export declare const RECIPE_SLUG_PATTERN: RegExp;
 export declare function recipeWikiSlug(recipeSlug: string): string;
 export declare const RECIPE_KIT_MAX_STAGES = 6;

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

@@ -67,19 +67,14 @@ export const RECIPE_PREREQUISITE_KINDS = [
     "plan",
     "data",
 ];
-// The ten body sections every recipe carries, in order. The catalog lint
-// enforces exact H2 headings so the fleet of authors cannot drift.
+// The four body sections every recipe carries, in order and no others
+// (founder, 2026-10-04): a production audit found lost founders' agents
+// stalling in ten-section essays. The catalog lint enforces exact H2 headings.
 export const RECIPE_BODY_SECTIONS = [
     "The Play",
-    "What You Get",
-    "When To Run (And When Not To)",
     "Before You Start",
     "Steps",
-    "Ready Assets",
-    "Calibrate",
-    "Troubleshooting",
-    "Operator Notes",
-    "Related",
+    "If It Goes Wrong",
 ];
 export const RECIPE_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,119}$/;
 // Wiki slug an install writes: slots into the starter wiki's seeded

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

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1011.687";
+export declare const OXYGEN_BUILD_VERSION = "1.1011.800";

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

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1011.687";
+export const OXYGEN_BUILD_VERSION = "1.1011.800";

package/node_modules/@oxygen/workflows/dist/graph/expression.d.ts

@@ -32,6 +32,7 @@ export declare class WorkflowValueCoercionError extends Error {
 export declare class WorkflowValueRefUnresolvedError extends Error {
     readonly path: string;
     readonly code = "workflow_value_ref_unresolved";
+    readonly nextStep: string;
     constructor(path: string);
 }
 /** Apply one explicit scalar conversion without lossy truthiness or truncation. */

package/node_modules/@oxygen/workflows/dist/graph/expression.js

@@ -40,14 +40,29 @@ function unresolvedRefRemedy(path) {
     const skeleton = parts.slice(2).reduceRight((inner, key) => ({ [key]: inner }), "…");
     return ` Supply it with --input-json '${JSON.stringify(skeleton)}'.`;
 }
+/**
+ * The caller-facing repair, short enough to survive the run-fault collapse
+ * (`next_step` is the one free-text field it keeps). An absent optional input
+ * is the common case: lint and publish accept the ref, and only the run fails.
+ */
+function unresolvedRefNextStep(path) {
+    const parts = path.split(".");
+    const coalesce = `bind it as a formula, COALESCE(${path}, ""), so a missing value is allowed`;
+    if (parts.length >= 3 && parts[0] === "trigger" && parts[1] === "input") {
+        return `'${path}' was not in the run input. Pass it in --input-json, list it in input_schema.required, or ${coalesce}.`;
+    }
+    return `'${path}' was not produced by an earlier step. Check that step's output, or ${coalesce}.`;
+}
 /** A direct mapping named data the run does not carry; sending undefined is never intentional. */
 export class WorkflowValueRefUnresolvedError extends Error {
     path;
     code = "workflow_value_ref_unresolved";
+    nextStep;
     constructor(path) {
         super(`Mapped field '${path}' did not resolve in this run.${unresolvedRefRemedy(path)}`);
         this.path = path;
         this.name = "WorkflowValueRefUnresolvedError";
+        this.nextStep = unresolvedRefNextStep(path);
     }
 }
 /** Apply one explicit scalar conversion without lossy truthiness or truncation. */

package/node_modules/@oxygen/workflows/dist/graph/lint.js

@@ -138,7 +138,11 @@ export function assertWorkflowGraphManifest(value, options = {}) {
     if (result.ok)
         return;
     const first = result.issues[0];
-    throw new Error(first ? `${first.code}: ${first.message}` : "Invalid workflow graph manifest.");
+    // The path is the only pointer to the offending node once a caller turns
+    // this throw into a typed error (the CLI's local compile keeps the message).
+    throw new Error(first
+        ? `${first.code}: ${first.message}${first.path ? ` (at ${first.path})` : ""}`
+        : "Invalid workflow graph manifest.");
 }
 /**
  * Validate one nested oxygen-js-v1 envelope without requiring its surrounding
@@ -1484,7 +1488,9 @@ value, path, add, scope, depth = 0) {
     if (value.type === "compare") {
         validateValueRef(value.left, `${path}.left`, add, scope);
         if (!isCompareOp(value.op)) {
-            add(`${path}.op`, "invalid_condition", "Condition compare op is invalid.");
+            // Blind evals reached for `is_true`, a Tables filter op: name the valid
+            // workflow ops and the boolean spelling instead of only saying "invalid".
+            add(`${path}.op`, "invalid_condition", `Condition op ${JSON.stringify(value.op)?.slice(0, 40) ?? "(missing)"} is not a workflow operator. Use one of: ${[...WORKFLOW_COMPARE_OPS].join(", ")}. For a boolean, compare eq with a literal true.`);
             return;
         }
         if (isUnaryCompareOp(value.op)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1011.687",
+  "version": "1.1011.800",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",