@oxygen-agent/cli 1.152.15 → 1.162.10

package/dist/transcript.d.ts

@@ -0,0 +1,21 @@
+export type TranscriptSource = "claude_code" | "codex" | "cursor" | "file";
+export type CapturedTranscript = {
+    source: TranscriptSource;
+    session_id: string | null;
+    tool: string;
+    event_count: number;
+    byte_size: number;
+    format: "jsonl.gz.b64";
+    content_b64: string;
+    truncated: boolean;
+    path: string;
+};
+export declare function redactTranscriptSecrets(text: string): string;
+export type CaptureOptions = {
+    sessionId?: string | null;
+    file?: string | null;
+};
+export declare class TranscriptCaptureError extends Error {
+}
+export declare function captureCurrentTranscript(options?: CaptureOptions): CapturedTranscript | null;
+export declare function collectFeedbackEnvironment(): Record<string, string>;

package/dist/transcript.js

@@ -0,0 +1,208 @@
+import { gzipSync } from "node:zlib";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { OXYGEN_VERSION } from "@oxygen/shared";
+// Keep at most the most-recent ~2MB of JSONL. gzip of conversational JSON lands
+// ~5–10x smaller, so the base64 payload stays well under Vercel's ~4.5MB body
+// limit without needing chunked upload. Past the cap we drop the oldest events.
+const MAX_RAW_BYTES = 2_000_000;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function transcriptRoots() {
+    const home = homedir();
+    return [
+        { dir: join(process.env.CLAUDE_HOME ?? join(home, ".claude"), "projects"), source: "claude_code", tool: "claude-code" },
+        { dir: join(process.env.CODEX_HOME ?? join(home, ".codex"), "sessions"), source: "codex", tool: "codex" },
+        { dir: join(process.env.CURSOR_HOME ?? join(home, ".cursor"), "projects"), source: "cursor", tool: "cursor" },
+    ];
+}
+// Bounded recursive walk for *.jsonl files. Depth-limited so a pathological tree
+// can't hang the CLI; symlink/permission errors are swallowed per-entry.
+function collectJsonl(dir, depth, out) {
+    if (depth < 0)
+        return;
+    let names = [];
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const full = join(dir, name);
+        let isDir = false;
+        let isFile = false;
+        try {
+            const stat = statSync(full);
+            isDir = stat.isDirectory();
+            isFile = stat.isFile();
+        }
+        catch {
+            continue;
+        }
+        if (isDir) {
+            collectJsonl(full, depth - 1, out);
+        }
+        else if (isFile && name.endsWith(".jsonl")) {
+            out.push(full);
+        }
+    }
+}
+function newestTranscriptFile() {
+    let newestPath = null;
+    let newestMtime = -1;
+    let newest = null;
+    for (const root of transcriptRoots()) {
+        if (!existsSync(root.dir))
+            continue;
+        const files = [];
+        collectJsonl(root.dir, 6, files);
+        for (const file of files) {
+            try {
+                const mtime = statSync(file).mtimeMs;
+                if (mtime > newestMtime) {
+                    newestMtime = mtime;
+                    newestPath = file;
+                    newest = root;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (!newestPath || !newest)
+        return null;
+    return { path: newestPath, source: newest.source, tool: newest.tool };
+}
+function findBySessionId(sessionId) {
+    for (const root of transcriptRoots()) {
+        if (!existsSync(root.dir))
+            continue;
+        const files = [];
+        collectJsonl(root.dir, 6, files);
+        // Case-insensitive: UUID session ids can be passed in any casing.
+        const needle = `${sessionId.toLowerCase()}.jsonl`;
+        const match = files.find((file) => file.toLowerCase().endsWith(needle));
+        if (match)
+            return { path: match, source: root.source, tool: root.tool };
+    }
+    return null;
+}
+function sessionIdFromPath(path) {
+    const base = path.split(/[\\/]/).pop() ?? "";
+    const stem = base.endsWith(".jsonl") ? base.slice(0, -".jsonl".length) : base;
+    return UUID_RE.test(stem) ? stem : null;
+}
+// Trim to the last `MAX_RAW_BYTES`, snapping to a newline so the first kept line
+// is whole. Returns the kept buffer and whether anything was dropped.
+function capToRecent(raw) {
+    if (raw.length <= MAX_RAW_BYTES)
+        return { kept: raw, truncated: false };
+    let start = raw.length - MAX_RAW_BYTES;
+    const nl = raw.indexOf(0x0a, start); // '\n'
+    if (nl !== -1 && nl + 1 < raw.length)
+        start = nl + 1;
+    return { kept: raw.subarray(start), truncated: true };
+}
+function countEvents(buf) {
+    const text = buf.toString("utf8");
+    let count = 0;
+    for (const line of text.split("\n")) {
+        if (line.trim().length > 0)
+            count += 1;
+    }
+    return count;
+}
+// Redact obvious credentials from transcript text before it leaves the machine.
+// Agent JSONL can embed API keys, auth headers, and tokens captured from tool
+// calls / shell output; scrub the common shapes so `oxygen feedback` never ships
+// raw secrets to the support API. Best-effort (not a guarantee) and deliberately
+// conservative — it targets credential shapes, not general prose, so the
+// transcript stays useful for debugging.
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "[REDACTED_PRIVATE_KEY]"],
+    [/\bsk-ant-[A-Za-z0-9_-]{12,}/g, "sk-ant-[REDACTED]"],
+    [/\bsk-[A-Za-z0-9_-]{20,}/g, "sk-[REDACTED]"],
+    [/\bAKIA[0-9A-Z]{16}\b/g, "AKIA[REDACTED]"],
+    [/\bAIza[0-9A-Za-z_-]{20,}/g, "AIza[REDACTED]"],
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, "ghx_[REDACTED]"],
+    [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g, "xox-[REDACTED]"],
+    [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}/g, "[REDACTED_JWT]"],
+    [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{16,}/gi, "$1 [REDACTED]"],
+    // "secret-ish key": "value"  /  secret_ish_key=value  (JSON + env shapes)
+    [/("?(?:api[_-]?key|apikey|secret|password|passwd|token|access[_-]?token|refresh[_-]?token|client[_-]?secret|authorization|auth[_-]?token|private[_-]?key)"?\s*[:=]\s*"?)([^"\s,}]{6,})/gi, "$1[REDACTED]"],
+];
+export function redactTranscriptSecrets(text) {
+    let out = text;
+    for (const [pattern, replacement] of SECRET_PATTERNS)
+        out = out.replace(pattern, replacement);
+    return out;
+}
+export class TranscriptCaptureError extends Error {
+}
+// Resolve and package the transcript. Returns null only when no transcript could
+// be found for the auto-detect path (so feedback can still send a note-only
+// report); an explicit --session-id / --file that doesn't resolve throws.
+export function captureCurrentTranscript(options = {}) {
+    let resolved = null;
+    if (options.file) {
+        if (!existsSync(options.file)) {
+            throw new TranscriptCaptureError(`Transcript file not found: ${options.file}`);
+        }
+        resolved = { path: options.file, source: "file", tool: "file" };
+    }
+    else if (options.sessionId) {
+        resolved = findBySessionId(options.sessionId);
+        if (!resolved) {
+            throw new TranscriptCaptureError(`No local transcript found for session ${options.sessionId}.`);
+        }
+    }
+    else {
+        resolved = newestTranscriptFile();
+        if (!resolved)
+            return null;
+    }
+    let raw;
+    try {
+        raw = readFileSync(resolved.path);
+    }
+    catch (error) {
+        throw new TranscriptCaptureError(`Could not read transcript ${resolved.path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const { kept, truncated } = capToRecent(raw);
+    // Scrub credentials from the raw bytes before gzip+base64 — the encoded blob is
+    // what leaves the machine, so redaction must happen here, not server-side.
+    const redacted = Buffer.from(redactTranscriptSecrets(kept.toString("utf8")), "utf8");
+    const content_b64 = gzipSync(redacted).toString("base64");
+    return {
+        source: resolved.source,
+        session_id: sessionIdFromPath(resolved.path),
+        tool: resolved.tool,
+        event_count: countEvents(redacted),
+        byte_size: redacted.length,
+        format: "jsonl.gz.b64",
+        content_b64,
+        truncated,
+        path: resolved.path,
+    };
+}
+// Lightweight, non-sensitive environment snapshot attached to feedback context so
+// staff can reproduce. Deliberately excludes env vars / secrets.
+export function collectFeedbackEnvironment() {
+    const env = {
+        os: `${process.platform} ${process.arch}`,
+        node: process.version,
+        cli_version: OXYGEN_VERSION,
+        cwd: process.cwd(),
+    };
+    const shell = (process.env.SHELL ?? "").trim();
+    if (shell)
+        env.shell = shell;
+    const term = (process.env.TERM_PROGRAM ?? "").trim();
+    if (term) {
+        const ver = (process.env.TERM_PROGRAM_VERSION ?? "").trim();
+        env.terminal = ver ? `${term} ${ver}` : term;
+    }
+    return env;
+}

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

@@ -5,9 +5,11 @@ export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./linkedin-sequences.js";
+export * from "./sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
+export * from "./sql-error.js";
 export * from "./telemetry.js";
 export declare const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export type JsonValue = string | number | boolean | null | JsonValue[] | {

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

@@ -6,9 +6,11 @@ export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./linkedin-sequences.js";
+export * from "./sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
+export * from "./sql-error.js";
 export * from "./telemetry.js";
 // Maximum rows a single row-loop write (insert/upsert/preview) may process. The
 // row-loop engine issues one DB round-trip per row, so a 500-row write already

package/node_modules/@oxygen/shared/dist/linkedin-sequences.d.ts

@@ -1,8 +1,10 @@
 /**
- * LinkedIn sequence step schema — the shared contract validated identically by
- * CLI, MCP, API, and web. A sequence is an ordered list of steps applied to
- * each enrolled lead; the worker dispatch engine materializes one
- * sequence_action per step as it comes due.
+ * LinkedIn-channel step types + helpers for the sequencer. These typed shapes
+ * describe the LinkedIn steps of a sequence and are consumed by the dispatch
+ * engine and the web flow editor/canvas. The canonical multichannel validator
+ * lives in `sequences.ts` (validateSequenceDefinition) — this module is types +
+ * the two pure helpers the dispatcher uses (renderLinkedInTemplate, the
+ * action-kind map, waitStepDelayMs). It carries no validator of its own.
  *
  * Step kinds:
  * - visit_profile        — view the lead's profile (warms up before an invite)
@@ -11,67 +13,90 @@
  *                          webhook) or timeout_days elapses; on timeout stop or
  *                          continue per on_timeout
  * - wait                 — fixed delay (days/hours) before the next step
- * - message              — send a message (opens a chat if none exists);
- *                          template supports {{column}} interpolation
- * - inmail               — send an InMail (works on non-connections); subject +
- *                          template
+ * - message              — send a message; template supports {{column}} interp
+ * - inmail               — send an InMail (works on non-connections)
  */
-export declare const LINKEDIN_SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "wait", "message", "inmail"];
+export declare const LINKEDIN_SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "wait", "message", "inmail", "branch", "stop"];
 export type LinkedInSequenceStepKind = typeof LINKEDIN_SEQUENCE_STEP_KINDS[number];
-export type LinkedInVisitProfileStep = {
+/** Conditions a `branch` step routes on. Both are LinkedIn-signal driven. */
+export declare const LINKEDIN_BRANCH_CONDITIONS: readonly ["connection_accepted", "already_connected"];
+export type LinkedInBranchCondition = typeof LINKEDIN_BRANCH_CONDITIONS[number];
+/** Every step carries a stable id so branch edges can target it by reference. */
+export type LinkedInStepBase = {
+    id: string;
+};
+export type LinkedInVisitProfileStep = LinkedInStepBase & {
     kind: "visit_profile";
 };
-export type LinkedInInviteStep = {
+export type LinkedInInviteStep = LinkedInStepBase & {
     kind: "invite";
     /** Optional connection-request note. Supports {{column}} interpolation. ~300 char max on LinkedIn. */
     note_template?: string;
 };
-export type LinkedInWaitForConnectionStep = {
+export type LinkedInWaitForConnectionStep = LinkedInStepBase & {
     kind: "wait_for_connection";
     /** Days to wait for the invite to be accepted before acting on on_timeout. */
     timeout_days: number;
     /** What to do if the invite is never accepted. Defaults to "stop". */
     on_timeout?: "stop" | "continue";
 };
-export type LinkedInWaitStep = {
+export type LinkedInWaitStep = LinkedInStepBase & {
     kind: "wait";
     /** Fixed delay before the next step. Provide days and/or hours (>= 1 total). */
     days?: number;
     hours?: number;
 };
-export type LinkedInMessageStep = {
+export type LinkedInMessageStep = LinkedInStepBase & {
     kind: "message";
     /** Message body. Supports {{column}} interpolation from the source-table row. */
     template: string;
 };
-export type LinkedInInMailStep = {
+export type LinkedInInMailStep = LinkedInStepBase & {
     kind: "inmail";
     subject_template: string;
     template: string;
 };
-export type LinkedInSequenceStep = LinkedInVisitProfileStep | LinkedInInviteStep | LinkedInWaitForConnectionStep | LinkedInWaitStep | LinkedInMessageStep | LinkedInInMailStep;
+/**
+ * A routing gate. Unlike a workflow branch (synchronous expression), a sequence
+ * branch routes on a LinkedIn signal that arrives over time:
+ * - `connection_accepted`: enter a wait until the invite is accepted (the
+ *   new_relation webhook sets connectedAt) or `timeout_days` elapses. Accepted →
+ *   `then_id`; timeout → `else_id` (omitted = stop).
+ * - `already_connected`: at entry, resolve whether the lead is already a
+ *   1st-degree connection. Connected → `then_id`; not → `else_id`.
+ * A missing `then_id`/`else_id` ends that path (enrollment completes/stops).
+ */
+export type LinkedInBranchStep = LinkedInStepBase & {
+    kind: "branch";
+    condition: LinkedInBranchCondition;
+    /** connection_accepted only: days to wait for acceptance. Defaults to 14. */
+    timeout_days?: number;
+    /** Step id to route to when the condition is TRUE. Omitted = end this path. */
+    then_id?: string;
+    /** Step id to route to when FALSE / timeout. Omitted = stop this path. */
+    else_id?: string;
+};
+/**
+ * Explicit terminal step. Ends the enrollment here regardless of any steps that
+ * follow in the array — the only way to give a `branch`'s two arms genuinely
+ * distinct endings (e.g. a "warm" message that stops, vs an invite→wait→"cold"
+ * message that stops), instead of forcing both arms to fall through into the
+ * same trailing step.
+ */
+export type LinkedInStopStep = LinkedInStepBase & {
+    kind: "stop";
+};
+export type LinkedInSequenceStep = LinkedInVisitProfileStep | LinkedInInviteStep | LinkedInWaitForConnectionStep | LinkedInWaitStep | LinkedInMessageStep | LinkedInInMailStep | LinkedInBranchStep | LinkedInStopStep;
 export type LinkedInSequenceDefinition = {
     steps: LinkedInSequenceStep[];
 };
 /**
  * The dispatch-queue action kind a step produces (matches the
- * ox_linkedin.sequence_actions.action_kind enum), or null for gate/wait steps
+ * ox_sequencer.sequence_actions.action_kind enum), or null for gate/wait steps
  * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
  * — visit_profile maps to the quota kind profile_view downstream.
  */
 export declare const LINKEDIN_STEP_ACTION_KIND: Record<LinkedInSequenceStepKind, "visit_profile" | "invite" | "message" | "inmail" | null>;
-export type LinkedInSequenceLintIssue = {
-    path: string;
-    message: string;
-};
-/**
- * Validate a raw sequence definition. Returns the normalized definition or
- * throws OxygenError("invalid_linkedin_sequence") with per-step issues. Pure —
- * safe to call from any surface.
- */
-export declare function validateLinkedInSequenceDefinition(input: unknown): LinkedInSequenceDefinition;
-/** Non-throwing variant for lint surfaces. */
-export declare function lintLinkedInSequenceDefinition(input: unknown): LinkedInSequenceLintIssue[];
 /** Total delay in milliseconds a `wait` step introduces. */
 export declare function waitStepDelayMs(step: LinkedInWaitStep): number;
 /**
@@ -79,5 +104,3 @@ export declare function waitStepDelayMs(step: LinkedInWaitStep): number;
  * render empty. Used by the dispatch engine to produce the final message text.
  */
 export declare function renderLinkedInTemplate(template: string, values: Record<string, unknown>): string;
-/** Column keys referenced by {{...}} placeholders across all steps. */
-export declare function linkedInTemplateVariables(definition: LinkedInSequenceDefinition): string[];

package/node_modules/@oxygen/shared/dist/linkedin-sequences.js

@@ -1,9 +1,10 @@
-import { OxygenError } from "./index.js";
 /**
- * LinkedIn sequence step schema — the shared contract validated identically by
- * CLI, MCP, API, and web. A sequence is an ordered list of steps applied to
- * each enrolled lead; the worker dispatch engine materializes one
- * sequence_action per step as it comes due.
+ * LinkedIn-channel step types + helpers for the sequencer. These typed shapes
+ * describe the LinkedIn steps of a sequence and are consumed by the dispatch
+ * engine and the web flow editor/canvas. The canonical multichannel validator
+ * lives in `sequences.ts` (validateSequenceDefinition) — this module is types +
+ * the two pure helpers the dispatcher uses (renderLinkedInTemplate, the
+ * action-kind map, waitStepDelayMs). It carries no validator of its own.
  *
  * Step kinds:
  * - visit_profile        — view the lead's profile (warms up before an invite)
@@ -12,10 +13,8 @@ import { OxygenError } from "./index.js";
  *                          webhook) or timeout_days elapses; on timeout stop or
  *                          continue per on_timeout
  * - wait                 — fixed delay (days/hours) before the next step
- * - message              — send a message (opens a chat if none exists);
- *                          template supports {{column}} interpolation
- * - inmail               — send an InMail (works on non-connections); subject +
- *                          template
+ * - message              — send a message; template supports {{column}} interp
+ * - inmail               — send an InMail (works on non-connections)
  */
 export const LINKEDIN_SEQUENCE_STEP_KINDS = [
     "visit_profile",
@@ -24,10 +23,14 @@ export const LINKEDIN_SEQUENCE_STEP_KINDS = [
     "wait",
     "message",
     "inmail",
+    "branch",
+    "stop",
 ];
+/** Conditions a `branch` step routes on. Both are LinkedIn-signal driven. */
+export const LINKEDIN_BRANCH_CONDITIONS = ["connection_accepted", "already_connected"];
 /**
  * The dispatch-queue action kind a step produces (matches the
- * ox_linkedin.sequence_actions.action_kind enum), or null for gate/wait steps
+ * ox_sequencer.sequence_actions.action_kind enum), or null for gate/wait steps
  * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
  * — visit_profile maps to the quota kind profile_view downstream.
  */
@@ -38,190 +41,9 @@ export const LINKEDIN_STEP_ACTION_KIND = {
     wait: null,
     message: "message",
     inmail: "inmail",
+    branch: null,
+    stop: null,
 };
-const MAX_STEPS = 25;
-const MAX_TEMPLATE_LENGTH = 8_000;
-const MAX_NOTE_LENGTH = 300;
-/**
- * Validate a raw sequence definition. Returns the normalized definition or
- * throws OxygenError("invalid_linkedin_sequence") with per-step issues. Pure —
- * safe to call from any surface.
- */
-export function validateLinkedInSequenceDefinition(input) {
-    const issues = [];
-    const steps = collectSteps(input, issues);
-    const normalized = [];
-    steps.forEach((rawStep, index) => {
-        const step = normalizeStep(rawStep, index, issues);
-        if (step)
-            normalized.push(step);
-    });
-    validateStructure(normalized, issues);
-    if (issues.length > 0) {
-        throw new OxygenError("invalid_linkedin_sequence", `Sequence definition is invalid: ${issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`, { details: { issues }, exitCode: 1 });
-    }
-    return { steps: normalized };
-}
-/** Non-throwing variant for lint surfaces. */
-export function lintLinkedInSequenceDefinition(input) {
-    try {
-        validateLinkedInSequenceDefinition(input);
-        return [];
-    }
-    catch (error) {
-        if (error instanceof OxygenError && error.details && typeof error.details === "object") {
-            const issues = error.details.issues;
-            if (Array.isArray(issues))
-                return issues;
-        }
-        return [{ path: "steps", message: error instanceof Error ? error.message : "Invalid sequence." }];
-    }
-}
-function collectSteps(input, issues) {
-    const record = isRecord(input) ? input : null;
-    const steps = record?.steps;
-    if (!Array.isArray(steps)) {
-        issues.push({ path: "steps", message: "steps must be an array." });
-        return [];
-    }
-    if (steps.length === 0) {
-        issues.push({ path: "steps", message: "A sequence needs at least one step." });
-    }
-    if (steps.length > MAX_STEPS) {
-        issues.push({ path: "steps", message: `A sequence may have at most ${MAX_STEPS} steps.` });
-    }
-    return steps;
-}
-function normalizeStep(// skipcq: JS-R1005 -- step normalization validates a discriminated sequence DSL with per-step fields.
-raw, index, issues) {
-    const path = `steps[${index}]`;
-    if (!isRecord(raw)) {
-        issues.push({ path, message: "Each step must be an object." });
-        return null;
-    }
-    const kind = raw.kind;
-    if (typeof kind !== "string" || !LINKEDIN_SEQUENCE_STEP_KINDS.includes(kind)) {
-        issues.push({
-            path: `${path}.kind`,
-            message: `kind must be one of: ${LINKEDIN_SEQUENCE_STEP_KINDS.join(", ")}.`,
-        });
-        return null;
-    }
-    switch (kind) {
-        case "visit_profile":
-            return { kind: "visit_profile" };
-        case "invite": {
-            const note = optionalTemplate(raw.note_template, `${path}.note_template`, MAX_NOTE_LENGTH, issues);
-            return note !== undefined ? { kind: "invite", note_template: note } : { kind: "invite" };
-        }
-        case "wait_for_connection": {
-            // timeout_days is optional (defaults to 14); only validate when provided.
-            const timeoutDays = raw.timeout_days === undefined || raw.timeout_days === null
-                ? undefined
-                : positiveInt(raw.timeout_days, `${path}.timeout_days`, issues);
-            const onTimeout = raw.on_timeout;
-            if (onTimeout !== undefined && onTimeout !== "stop" && onTimeout !== "continue") {
-                issues.push({ path: `${path}.on_timeout`, message: "on_timeout must be 'stop' or 'continue'." });
-            }
-            return {
-                kind: "wait_for_connection",
-                timeout_days: timeoutDays ?? 14,
-                on_timeout: onTimeout === "continue" ? "continue" : "stop",
-            };
-        }
-        case "wait": {
-            const days = optionalNonNegativeInt(raw.days, `${path}.days`, issues);
-            const hours = optionalNonNegativeInt(raw.hours, `${path}.hours`, issues);
-            if ((days ?? 0) + (hours ?? 0) <= 0) {
-                issues.push({ path, message: "A wait step needs days and/or hours totaling at least 1 hour." });
-            }
-            return {
-                kind: "wait",
-                ...(days !== undefined ? { days } : {}),
-                ...(hours !== undefined ? { hours } : {}),
-            };
-        }
-        case "message": {
-            const template = requiredTemplate(raw.template, `${path}.template`, issues);
-            return { kind: "message", template: template ?? "" };
-        }
-        case "inmail": {
-            const subject = requiredTemplate(raw.subject_template, `${path}.subject_template`, issues);
-            const template = requiredTemplate(raw.template, `${path}.template`, issues);
-            return { kind: "inmail", subject_template: subject ?? "", template: template ?? "" };
-        }
-        default:
-            return null;
-    }
-}
-/**
- * Structural rules across steps:
- * - The first send step must be invite or visit_profile (you can't message a
- *   stranger without connecting); a message before any invite/wait_for_connection
- *   is valid for warm lists whose leads are already 1st-degree connections.
- * - wait_for_connection must be preceded by an invite.
- * - Two consecutive wait/wait_for_connection steps are pointless.
- */
-function validateStructure(steps, issues) {
-    let sawInvite = false;
-    steps.forEach((step, index) => {
-        if (step.kind === "invite")
-            sawInvite = true;
-        if (step.kind === "wait_for_connection" && !sawInvite) {
-            issues.push({
-                path: `steps[${index}]`,
-                message: "wait_for_connection must come after an invite step.",
-            });
-        }
-        if (step.kind === "message" && !sawInvite && !steps.slice(0, index).some((s) => s.kind === "wait_for_connection")) {
-            // A message before connecting only works for existing 1st-degree
-            // connections. This is valid for warm lists; do not add a fatal issue
-            // until the API has a separate warning channel.
-        }
-    });
-}
-function requiredTemplate(value, path, issues) {
-    if (typeof value !== "string" || !value.trim()) {
-        issues.push({ path, message: "is required and must be a non-empty string." });
-        return undefined;
-    }
-    if (value.length > MAX_TEMPLATE_LENGTH) {
-        issues.push({ path, message: `must be at most ${MAX_TEMPLATE_LENGTH} characters.` });
-        return undefined;
-    }
-    return value;
-}
-function optionalTemplate(value, path, maxLength, issues) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "string") {
-        issues.push({ path, message: "must be a string." });
-        return undefined;
-    }
-    if (value.length > maxLength) {
-        issues.push({ path, message: `must be at most ${maxLength} characters.` });
-        return undefined;
-    }
-    return value;
-}
-function positiveInt(value, path, issues) {
-    const num = Number(value);
-    if (!Number.isInteger(num) || num <= 0) {
-        issues.push({ path, message: "must be a positive integer." });
-        return undefined;
-    }
-    return num;
-}
-function optionalNonNegativeInt(value, path, issues) {
-    if (value === undefined || value === null)
-        return undefined;
-    const num = Number(value);
-    if (!Number.isInteger(num) || num < 0) {
-        issues.push({ path, message: "must be a non-negative integer." });
-        return undefined;
-    }
-    return num;
-}
 /** Total delay in milliseconds a `wait` step introduces. */
 export function waitStepDelayMs(step) {
     const days = step.days ?? 0;
@@ -240,29 +62,3 @@ export function renderLinkedInTemplate(template, values) {
         return typeof value === "string" ? value : String(value);
     });
 }
-/** Column keys referenced by {{...}} placeholders across all steps. */
-export function linkedInTemplateVariables(definition) {
-    const vars = new Set();
-    const scan = (template) => {
-        if (!template)
-            return;
-        for (const match of template.matchAll(/\{\{\s*([\w.]+)\s*\}\}/g)) {
-            if (match[1])
-                vars.add(match[1]);
-        }
-    };
-    for (const step of definition.steps) {
-        if (step.kind === "invite")
-            scan(step.note_template);
-        if (step.kind === "message")
-            scan(step.template);
-        if (step.kind === "inmail") {
-            scan(step.subject_template);
-            scan(step.template);
-        }
-    }
-    return [...vars];
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}