@oxygen-agent/cli 1.287.12 → 1.310.0

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -2,7 +2,7 @@ import { extname } from "node:path";
 import readXlsxFile from "read-excel-file/node";
 import { inferImportColumnDataType, parseDateValueToIso, } from "./column-types.js";
 import { OxygenError } from "./cli-result.js";
-const MAX_IDENTIFIER_LENGTH = 63;
+import { makeUniqueIdentifier, toSnakeIdentifier } from "./identifiers.js";
 export const MAX_BUFFERED_IMPORT_PARSE_BYTES = 10 * 1024 * 1024;
 export function inferRowsFileFormat(path) {
     const extension = extname(path).toLowerCase();
@@ -118,17 +118,12 @@ export function normalizeRowsForNewTable(rows) {
         }),
     };
 }
+// Alias of the canonical @oxygen/shared identifier normalizer. Keep this name:
+// it MATCHES imported file headers back to the column key MINTED by tenant-db's
+// toSnakeIdentifier, and has call sites across web/CLI/API. The two must never
+// diverge \u2014 see packages/shared/src/identifiers.ts + identifiers.test.ts.
 export function normalizeImportColumnKey(value) {
-    const normalized = value
-        .normalize("NFKD")
-        .replace(/[\u0300-\u036f]/g, "") // skipcq: JS-0117
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "_")
-        .replace(/^_+|_+$/g, "")
-        .replace(/_+/g, "_");
-    const base = normalized || "column";
-    const prefixed = /^[0-9]/.test(base) ? `c_${base}` : base;
-    return prefixed.slice(0, MAX_IDENTIFIER_LENGTH);
+    return toSnakeIdentifier(value, "column");
 }
 async function parseXlsxRows(buffer, options) {
     let rows;
@@ -471,21 +466,8 @@ function parseCsvRecords(text) {
     return records;
 }
 function makeUniqueImportKey(label, taken) {
-    const normalized = normalizeImportColumnKey(label);
-    if (!taken.has(normalized)) {
-        taken.add(normalized);
-        return normalized;
-    }
-    for (let index = 2; index < 10_000; index += 1) {
-        const suffix = `_${index}`;
-        const candidate = `${normalized.slice(0, MAX_IDENTIFIER_LENGTH - suffix.length)}${suffix}`;
-        if (!taken.has(candidate)) {
-            taken.add(candidate);
-            return candidate;
-        }
-    }
-    throw new OxygenError("identifier_exhausted", "Unable to create a unique column key.", {
-        details: { label },
-        exitCode: 1,
+    return makeUniqueIdentifier(label, taken, {
+        exhaustedMessage: "Unable to create a unique column key.",
+        exhaustedDetails: { label },
     });
 }

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

@@ -0,0 +1,23 @@
+export declare const MAX_IDENTIFIER_LENGTH = 63;
+/**
+ * Canonical column/identifier key normalizer. This is the single source of
+ * truth for turning a human label into a physical snake_case key: it is used
+ * both to MINT a column's key (tenant-db) and to MATCH an imported file header
+ * back to that column (shared file-import). The two sides must return the same
+ * string for the same label forever — hence one implementation, one home.
+ *
+ * The chain deliberately mangles non-ASCII (e.g. "Größe" -> "gro_e") — a latent
+ * i18n wart that is identical on both sides, so it is not drift. Do not "fix" it
+ * here without a migration: changing it would silently re-key existing columns.
+ */
+export declare function toSnakeIdentifier(value: string, fallback?: string): string;
+/**
+ * Normalize `base` and disambiguate it against `taken` with a numeric suffix,
+ * respecting the 63-byte cap. `options` only customizes the exhaustion error so
+ * distinct call sites (column key vs. generic identifier) keep their own message
+ * and details key without duplicating the loop.
+ */
+export declare function makeUniqueIdentifier(base: string, taken: Set<string>, options?: {
+    exhaustedMessage?: string;
+    exhaustedDetails?: Record<string, unknown>;
+}): string;

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

@@ -0,0 +1,48 @@
+import { OxygenError } from "./cli-result.js";
+// Postgres identifiers are capped at NAMEDATALEN - 1 = 63 bytes.
+export const MAX_IDENTIFIER_LENGTH = 63;
+/**
+ * Canonical column/identifier key normalizer. This is the single source of
+ * truth for turning a human label into a physical snake_case key: it is used
+ * both to MINT a column's key (tenant-db) and to MATCH an imported file header
+ * back to that column (shared file-import). The two sides must return the same
+ * string for the same label forever — hence one implementation, one home.
+ *
+ * The chain deliberately mangles non-ASCII (e.g. "Größe" -> "gro_e") — a latent
+ * i18n wart that is identical on both sides, so it is not drift. Do not "fix" it
+ * here without a migration: changing it would silently re-key existing columns.
+ */
+export function toSnakeIdentifier(value, fallback = "column") {
+    const normalized = value
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "") // skipcq: JS-0117
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .replace(/_+/g, "_");
+    const base = normalized || fallback;
+    const prefixed = /^[0-9]/.test(base) ? `c_${base}` : base;
+    return prefixed.slice(0, MAX_IDENTIFIER_LENGTH);
+}
+/**
+ * Normalize `base` and disambiguate it against `taken` with a numeric suffix,
+ * respecting the 63-byte cap. `options` only customizes the exhaustion error so
+ * distinct call sites (column key vs. generic identifier) keep their own message
+ * and details key without duplicating the loop.
+ */
+export function makeUniqueIdentifier(base, taken, options) {
+    const normalized = toSnakeIdentifier(base);
+    if (!taken.has(normalized)) {
+        taken.add(normalized);
+        return normalized;
+    }
+    for (let index = 2; index < 10_000; index += 1) {
+        const suffix = `_${index}`;
+        const candidate = `${normalized.slice(0, MAX_IDENTIFIER_LENGTH - suffix.length)}${suffix}`;
+        if (!taken.has(candidate)) {
+            taken.add(candidate);
+            return candidate;
+        }
+    }
+    throw new OxygenError("identifier_exhausted", options?.exhaustedMessage ?? "Unable to create a unique identifier.", { details: options?.exhaustedDetails ?? { base }, exitCode: 1 });
+}

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

@@ -1,4 +1,4 @@
-export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
+export { MANAGED_INBOX_MINIMUM_CLI_VERSION, OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION, } from "./version.js";
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export * from "./billing.js";
 export * from "./budget-scopes.js";
@@ -10,10 +10,14 @@ export * from "./credit-guidance.js";
 export * from "./directory.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
+export * from "./error-redaction.js";
+export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
+export * from "./knowledge-seed-content.js";
 export * from "./linkedin-post-url.js";
+export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";
 export * from "./networks.js";
 export * from "./sequence-template.js";
@@ -24,6 +28,8 @@ export * from "./signup-lead-deliveries.js";
 export * from "./sql-error.js";
 export * from "./telemetry.js";
 export * from "./tenant-database-secret.js";
+export * from "./timing.js";
+export * from "./type-guards.js";
 export * from "./worker-failures-queue.js";
 export declare const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export type SemanticVersion = {

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

@@ -1,4 +1,4 @@
-export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
+export { MANAGED_INBOX_MINIMUM_CLI_VERSION, OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION, } from "./version.js";
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export * from "./billing.js";
 export * from "./budget-scopes.js";
@@ -10,10 +10,14 @@ export * from "./credit-guidance.js";
 export * from "./directory.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
+export * from "./error-redaction.js";
+export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
+export * from "./knowledge-seed-content.js";
 export * from "./linkedin-post-url.js";
+export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";
 export * from "./networks.js";
 export * from "./sequence-template.js";
@@ -24,6 +28,8 @@ export * from "./signup-lead-deliveries.js";
 export * from "./sql-error.js";
 export * from "./telemetry.js";
 export * from "./tenant-database-secret.js";
+export * from "./timing.js";
+export * from "./type-guards.js";
 export * from "./worker-failures-queue.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/knowledge-constants.d.ts

@@ -34,5 +34,7 @@ export declare const KNOWLEDGE_PAGE_BODY_MAX_CHARS = 120000;
 export declare const KNOWLEDGE_PAGE_SUMMARY_MAX_CHARS = 1000;
 export declare const KNOWLEDGE_GRAPH_DEFAULT_MAX_NODES = 500;
 export declare const KNOWLEDGE_GRAPH_MAX_NODES = 2000;
+export declare const KNOWLEDGE_GRAPH_DEFAULT_DEPTH = 1;
+export declare const KNOWLEDGE_GRAPH_MAX_DEPTH = 3;
 export declare const KNOWLEDGE_SYNC_MAX_PAGE_BATCH = 200;
 export declare const RESERVED_KNOWLEDGE_FRONTMATTER_KEYS: readonly ["oxygen_page", "id", "slug", "type", "title", "status", "tags", "canonical", "summary", "revision", "updated_at", "web_url"];

package/node_modules/@oxygen/shared/dist/knowledge-constants.js

@@ -118,6 +118,10 @@ export const KNOWLEDGE_PAGE_BODY_MAX_CHARS = 120_000;
 export const KNOWLEDGE_PAGE_SUMMARY_MAX_CHARS = 1_000;
 export const KNOWLEDGE_GRAPH_DEFAULT_MAX_NODES = 500;
 export const KNOWLEDGE_GRAPH_MAX_NODES = 2_000;
+// Local-graph neighborhood depth: default one hop around a center page, clamped to three
+// (the BFS issues one query per hop, so depth bounds round-trips).
+export const KNOWLEDGE_GRAPH_DEFAULT_DEPTH = 1;
+export const KNOWLEDGE_GRAPH_MAX_DEPTH = 3;
 export const KNOWLEDGE_SYNC_MAX_PAGE_BATCH = 200;
 // Frontmatter keys the deterministic renderer owns; user `data` keys colliding
 // with these are skipped at render time (the stored jsonb keeps them).

package/node_modules/@oxygen/shared/dist/knowledge-seed-content.d.ts

@@ -0,0 +1,24 @@
+import type { KnowledgePageType, KnowledgePageStatus } from "./knowledge-constants.js";
+/** Monotonic scaffold cursor stored in knowledge_state.scaffold_version. Bump to ship a
+ *  new wave of starter pages (tag them with a higher minScaffoldVersion). */
+export declare const KNOWLEDGE_SCAFFOLD_VERSION = 1;
+export type KnowledgeScaffoldPage = {
+    /** Immutable slug; must be valid kebab grammar and NOT a reserved slug. */
+    slug: string;
+    type: KnowledgePageType;
+    title: string;
+    /** Nav pages ship active; content stubs ship draft so they never ground AI copy. */
+    status: Extract<KnowledgePageStatus, "active" | "draft">;
+    tags: string[];
+    summary: string;
+    body: string;
+    /** The first scaffold version that includes this page — seeded when current < this <= target. */
+    minScaffoldVersion: number;
+};
+/**
+ * The 9-page starter pack. Two active nav pages first (start-here + the conventions schema
+ * page), then the seven draft stub hubs (tag `seed`). `positioning` seeds as a NON-canonical
+ * draft so it writes freely — pinning canonical positioning stays a separate human-approved
+ * act. All at minScaffoldVersion 1 (the first wave).
+ */
+export declare const KNOWLEDGE_SEED_PAGES: readonly KnowledgeScaffoldPage[];

package/node_modules/@oxygen/shared/dist/knowledge-seed-content.js

@@ -0,0 +1,301 @@
+// Knowledge Graph starter pack (the Karpathy LLM-wiki scaffold). A fresh workspace
+// self-seeds this page set on first onboarding / `oxygen knowledge seed` so the wiki
+// arrives alive: two active nav pages ([[start-here]] + the [[conventions]] schema page)
+// and seven draft stub hubs that show the shape of a healthy second brain without
+// grounding any AI copy until a human fills them.
+//
+// The seeder (tenant-db `ensureKnowledgeScaffold`) is purely additive and version-gated:
+// it creates a page only when its slug is free (never overwriting a user's edits) and
+// only when `minScaffoldVersion` sits in (current, target]. Bump KNOWLEDGE_SCAFFOLD_VERSION
+// and add pages with a higher `minScaffoldVersion` to ship a new wave; existing pages are
+// never rewritten by the scaffold. Bodies are the single source of truth for the starter
+// content — keep them dense and wikilinked.
+/** Monotonic scaffold cursor stored in knowledge_state.scaffold_version. Bump to ship a
+ *  new wave of starter pages (tag them with a higher minScaffoldVersion). */
+export const KNOWLEDGE_SCAFFOLD_VERSION = 1;
+const START_HERE_BODY = `# Start here
+
+This is the workspace's knowledge wiki — one shared, compounding second brain for every human and every AI agent here. It replaces scattered Notion docs, chat history, and one-off prompts.
+
+## The contract (read once)
+- **Read before you answer.** Skim [[conventions]], then the index (\`oxygen knowledge index\`). Open only the pages you need and cite them by slug, e.g. "per [[icp]]".
+- **Route before reading.** Use the index and \`oxygen knowledge search\` as a map. Don't scan page bodies to orient.
+- **File durable answers back.** An answer that will be asked again becomes a page + a \`log append\`. Never strand company knowledge in chat or a commit message.
+- **Trust travels.** Every claim cites its source. Canonical live copy (voice / brand / [[positioning]]) is human-approved; everything else auto-writes as revertible revisions. See [[conventions]].
+
+## Hubs
+- [[icp]] — who we sell to
+- [[positioning]] — how we describe ourselves vs. alternatives
+- [[offers]] — what we sell and for how much
+- [[competitors]] — competitor teardowns (map of content)
+- [[playbooks]] — how we run each GTM motion (map of content)
+- [[campaign-learnings]] — what outreach and meetings taught us
+- [[decisions]] — standing GTM decisions and what would reverse them
+
+## Seeing the shape
+\`oxygen knowledge graph\` (or the web graph) shows hubs, orphans, and dashed unresolved links — the gaps worth filling next. \`oxygen knowledge lint\` is the health report.
+
+> Most hub pages are stubs right now. Filling a stub needs no approval — replace the body with cited content and set \`status: active\`. The how-to is in [[conventions]].
+`;
+const CONVENTIONS_BODY = `# Conventions (schema)
+
+This page defines how the wiki is structured so agents make the same choices a careful human would. Amending it is a human/approved act — propose changes with evidence from the log.
+
+## Working loop
+Index-first → open only relevant pages → answer citing slugs → file durable answers back as a page + \`log append\`. Details in [[start-here]].
+
+## Page types (pick the most specific; \`other\` is last resort)
+| Type | Use for |
+|---|---|
+| \`entity\` | one real-world noun: a company, person, product, tool, market |
+| \`topic\` | a concept hub linking entities/notes (a map of content) |
+| \`research_note\` | dated findings from one investigation |
+| \`source_summary\` | condensed digest of ONE raw source — cite, don't copy |
+| \`report\` | a human-facing rollup (weekly synthesis, audit) |
+| \`competitor\` | one competitor: teardown, where they win, how we counter |
+| \`persona\` | one buyer persona: pains, triggers, language |
+| \`strategy\` | durable direction: ICP, offers, bets, quarterly focus |
+| \`campaign\` | one bounded GTM push + its results |
+| \`positioning\` | how we're described vs. alternatives — canonical is gated |
+| \`voice\` / \`brand\` | writing voice / brand facts — canonical is gated |
+| \`playbook\` / \`message_playbook\` | how-we-do-it / message patterns — pinned default is gated |
+| \`schema\` | describes the wiki itself (this page) |
+
+## Slugs
+Flat kebab: lowercase alphanumerics + dashes, no slashes, ≤120 chars. **Immutable once created** — choose the durable name (\`competitor-clay\`, not \`clay-notes-july\`). No folders; types, tags, and [[wikilinks]] organize. Reserved (never create): \`index\`, \`log\`, \`schema\`, \`company-profile\`, \`readme\`.
+
+## Wikilinks
+\`[[slug]]\`, \`[[slug|alias]]\`, \`[[slug#heading]]\` all key to the slug. **Linking to a page that doesn't exist yet is good** — the dashed node is a visible to-do. Every page should link out (avoid dead-ends) and be linked to (avoid orphans).
+
+## New page vs. edit
+New page when it's a distinct entity/concept you'd link to from elsewhere. Edit in place when it's an attribute or update of an existing page. Search first (\`oxygen knowledge search\`) — near-duplicate slugs rot the graph.
+
+## Density bar (the compression rule)
+A page must be denser than the sources it distills. If a page is roughly the size of, or a 1:1 mirror of, something cheaper to re-fetch (a live CRM field, one short doc), it's negative value — collapse it into a dense table/summary or delete it. A page is either trusted at query time or it shouldn't exist: never ship "verify against source" pages. No filler, no hedging boilerplate.
+
+## Trust tiers (two words, they travel on the page)
+- **verified** — a human confirmed it. Tag \`verified\`.
+- **agent-derived** — machine-authored hint, not yet confirmed. Default for auto-written pages.
+Prune agent-derived claims once a human verifies the same fact. A contested claim gets tag \`disputed\` (excluded from AI grounding).
+
+## What auto-files where (write path)
+- Raw outcomes (reply classifications, bounces, won/lost deals, meetings, A/B winners, human edits to AI drafts) auto-file as **immutable sources** on learnings pages — no approval. See [[campaign-learnings]].
+- Working pages auto-write as logged, revertible revisions.
+- **Gated:** editing or pinning the canonical (pinned) instance of voice/brand/[[positioning]]/playbook/message_playbook files a proposal — a human approves. Never bypass this.
+
+## Decision pages
+Record standing calls in [[decisions]] using the template there. Every decision needs a rationale AND a \`## Reversal condition\` — the observable evidence that would flip it — so agents can flag when new data contradicts a standing decision.
+
+## Stub-fill contract
+Seeded stubs (tag \`seed\`, still at revision 1, \`status: draft\`) are scaffolding. Replace the body with real cited content, keep the [[wikilinks]], set \`status: active\`. **No approval needed.** Until filled they stay draft and never ground AI copy. \`oxygen knowledge lint\` lists unfilled stubs.
+
+## Lint discipline
+Run \`oxygen knowledge lint\` regularly. It reports orphans, dead-ends, unresolved links (ranked by demand), untagged pages, duplicate titles, oversized hubs, missing summaries/canonicals, stale/oversized pages, unfilled stubs, and decisions missing a reversal condition. \`oxygen knowledge lint relink\` rebuilds edges after bulk edits.
+`;
+const ICP_BODY = `# ICP — ideal customer profile
+
+> **Stub — fill me.** Seeded scaffolding. Replace with real, cited content, keep the [[wikilinks]], then set \`status: active\`. No approval needed. Draft stubs do not ground AI copy. How-to: [[conventions]].
+
+## Firmographics
+- Company type / size / stage:
+- Industry / vertical:
+- Geography:
+
+## Triggers (why now)
+- Signals that a fit account is in-market:
+
+## Disqualifiers (hard no)
+- Who we should NOT pursue and why:
+
+## Buyer personas
+- Link one [[persona]] page per buyer (economic buyer, champion, user).
+
+## Basis
+- Cite the deals, calls, or market data this is drawn from. Contradicting evidence should route through [[campaign-learnings]] and update [[positioning]].
+`;
+const POSITIONING_BODY = `# Positioning
+
+> **Stub — fill me.** Non-canonical draft. Fill it, then a human pins the canonical version (\`oxygen knowledge page pin positioning --approved\`) — pinning is gated because canonical positioning grounds live copy. See [[conventions]].
+
+## For whom
+- Our [[icp]], and the moment they buy.
+
+## Category / alternative
+- What buyers compare us to (status quo, a [[competitors|competitor]], in-house).
+
+## Core value
+- The one thing we do better and why it matters:
+
+## Proof
+- Evidence: outcomes, references, [[campaign-learnings]].
+
+## Changes our mind if
+- Observable evidence that would force a repositioning (see the reversal rule in [[decisions]]).
+`;
+const OFFERS_BODY = `# Offers
+
+> **Stub — fill me.** Seeded scaffolding — fill, keep [[wikilinks]], set \`status: active\`. See [[conventions]].
+
+## Offers
+For each: name, who it's for ([[icp]]), price/packaging, the outcome it delivers, and qualifying criteria.
+
+- Offer 1 —
+- Offer 2 —
+
+## Positioning link
+Tie each offer to the value in [[positioning]] and the motions in [[playbooks]].
+`;
+const COMPETITORS_BODY = `# Competitors (map of content)
+
+> **Stub — fill me.** This is a hub. Create one \`competitor\` page per rival (e.g. \`[[competitor-clay]]\`) and link it here; then fill this overview. See [[conventions]].
+
+## Landscape
+- One line per competitor + link to its teardown page.
+- [[competitor-example]] — replace with real teardowns.
+
+## Our stance
+- Where we consistently win / lose (draw from [[positioning]] and [[campaign-learnings]]).
+`;
+const PLAYBOOKS_BODY = `# Playbooks (map of content)
+
+> **Stub — fill me.** Hub. Create one \`playbook\` page per motion and link it here. The pinned/canonical playbook that backs live sends is gated — see [[conventions]].
+
+## Motions
+- [[playbook-outbound]] — cold outbound
+- [[playbook-nurture]] — nurture / re-engagement
+- (add: demo, onboarding, expansion)
+
+Each playbook cites the [[campaign-learnings]] that shaped it and the [[offers]] it sells.
+`;
+const CAMPAIGN_LEARNINGS_BODY = `# Campaign learnings (map of content)
+
+> **Stub — fill me.** Hub for the learning loop. See [[conventions]] for the write path.
+
+## How this fills itself
+Learning-worthy outcomes auto-file as **immutable sources** (facts, no approval) onto working learnings pages:
+- reply classifications, bounces, opt-outs → [[outreach-learnings]] and per-sequence \`campaign-learnings-<id>\` pages
+- closed won/lost deals → [[won-lost-learnings]]
+- completed meetings + notes → [[meeting-learnings]]
+- A/B auto-winners and human edits to AI drafts → the relevant learnings page
+
+## Distill
+\`oxygen knowledge synthesize\` (and the opt-in scheduled agent) turns accumulated sources into learnings-page revisions — with citations and a "what would change our mind" line per recommendation. Retrieval then grounds the NEXT campaign's drafts on them.
+
+## Read before a new campaign
+Skim the learnings pages above; message drafts and AI columns also retrieve them automatically.
+`;
+const DECISIONS_BODY = `# Decisions (log)
+
+> **Stub — fill me.** Hub for standing GTM decisions. Each decision is its own page (tag it \`decision\`) linked here, or a short entry below for small calls. See [[conventions]].
+
+## Template (copy for each decision)
+\`\`\`
+### <decision, one line>
+- **Date / owner:**
+- **Decision:** what we chose
+- **Rationale:** why, in 2–3 lines
+- **Basis:** cited sources ([[campaign-learnings]], deals, [[competitors]])
+## Reversal condition
+The observable evidence that would flip this decision.
+\`\`\`
+
+Every decision MUST have a \`## Reversal condition\` — \`oxygen knowledge lint\` flags decision pages that lack one. Record the call in the log too: \`oxygen knowledge log append --event decision --slug <page> --summary "<what/why>"\`.
+`;
+/**
+ * The 9-page starter pack. Two active nav pages first (start-here + the conventions schema
+ * page), then the seven draft stub hubs (tag `seed`). `positioning` seeds as a NON-canonical
+ * draft so it writes freely — pinning canonical positioning stays a separate human-approved
+ * act. All at minScaffoldVersion 1 (the first wave).
+ */
+export const KNOWLEDGE_SEED_PAGES = [
+    {
+        slug: "start-here",
+        type: "topic",
+        title: "Start here",
+        status: "active",
+        tags: ["moc", "start-here"],
+        summary: "Home of the workspace wiki and its contract for humans and agents: read index-first, cite slugs by [[wikilink]], file durable answers back as pages. Links every hub.",
+        body: START_HERE_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "conventions",
+        type: "schema",
+        title: "Conventions (schema)",
+        status: "active",
+        tags: ["schema", "conventions"],
+        summary: "The wiki's schema file: page types, slug grammar, wikilink rules, new-page-vs-edit heuristic, the density/compression bar, trust tiers, what auto-files where, and the decision-page template with reversal conditions. Read before writing.",
+        body: CONVENTIONS_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "icp",
+        type: "strategy",
+        title: "ICP — ideal customer profile",
+        status: "draft",
+        tags: ["seed", "icp"],
+        summary: "Stub: the ideal customer profile — firmographics, triggers, and disqualifiers that define who we sell to. Fill with cited content and set active.",
+        body: ICP_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "positioning",
+        type: "positioning",
+        title: "Positioning",
+        status: "draft",
+        tags: ["seed", "positioning"],
+        summary: "Stub (non-canonical): how we describe ourselves against alternatives — for whom, the core value, and proof. Pinning the canonical positioning is a separate human-approved act.",
+        body: POSITIONING_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "offers",
+        type: "strategy",
+        title: "Offers",
+        status: "draft",
+        tags: ["seed", "offers"],
+        summary: "Stub: what we sell — packages, pricing, and the qualifying criteria per offer. Fill with cited content and set active.",
+        body: OFFERS_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "competitors",
+        type: "topic",
+        title: "Competitors (map of content)",
+        status: "draft",
+        tags: ["seed", "moc", "competitors"],
+        summary: "Stub map-of-content: index of competitor teardown pages. Create one [[competitor-<name>]] page each; this hub links them and summarizes our overall competitive stance.",
+        body: COMPETITORS_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "playbooks",
+        type: "topic",
+        title: "Playbooks (map of content)",
+        status: "draft",
+        tags: ["seed", "moc", "playbooks"],
+        summary: "Stub map-of-content: index of how-we-run-it playbooks (outbound, nurture, demo, expansion). Create one playbook page per motion and link it here.",
+        body: PLAYBOOKS_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "campaign-learnings",
+        type: "topic",
+        title: "Campaign learnings (map of content)",
+        status: "draft",
+        tags: ["seed", "moc", "learnings"],
+        summary: "Stub map-of-content for the learning loop: explains that outreach/meeting/deal outcomes auto-file as immutable sources, and how synthesis distills them into learnings pages that ground the next campaign.",
+        body: CAMPAIGN_LEARNINGS_BODY,
+        minScaffoldVersion: 1,
+    },
+    {
+        slug: "decisions",
+        type: "topic",
+        title: "Decisions (log)",
+        status: "draft",
+        tags: ["seed", "moc", "decisions"],
+        summary: "Stub decision-log map-of-content with the decision template. Standing GTM decisions each get rationale, cited basis, and a reversal condition; log the call with 'log append --event decision'.",
+        body: DECISIONS_BODY,
+        minScaffoldVersion: 1,
+    },
+];

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

@@ -0,0 +1,19 @@
+export type LinkedinUrlNormalization = {
+    normalized: string;
+    handle: string;
+} | null;
+export declare function normalizeLinkedinProfileUrl(raw: string | null | undefined): LinkedinUrlNormalization;
+/**
+ * Extract the addressable activity id from a LinkedIn post URL. Returns null for
+ * a bare id (already addressable — pass it through), and null for a linkedin.com
+ * URL that is not a post.
+ */
+export declare function linkedinPostIdFromUrl(raw: string | null | undefined): string | null;
+/**
+ * True when a value is a URL rather than a provider identifier. Unipile addresses
+ * members, posts, and chats as PATH SEGMENTS, so a URL that reaches one is always
+ * a bug on our side — and the provider reports it as a permission or validation
+ * error that reads like the customer's account is broken. Callers use this to
+ * fail closed with an honest message instead.
+ */
+export declare function looksLikeUrlIdentifier(value: string): boolean;

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

@@ -0,0 +1,105 @@
+// Canonicalize + validate a LinkedIn personal-profile URL. A LinkedIn URL is a
+// strong personal identifier, so a false positive contaminates every downstream
+// step (email finding, outreach, CRM sync). This lives in @oxygen/shared so both
+// the enrichment identity validator and the sequencer (enroll-time acceptance in
+// apps/web + send-time provider-id resolution in @oxygen/integrations) validate a
+// profile URL with the exact same logic — one source of truth for "is this a
+// dispatchable /in/ profile URL".
+// Reject URLs that are not personal profile pages. Sales Navigator, Recruiter,
+// search-result deep links, and company URLs all surface from loosely-typed
+// provider responses and would otherwise pollute the column.
+const PROFILE_REJECT_PATH_FRAGMENTS = [
+    "/sales/",
+    "/recruiter/",
+    "/search/",
+    "/talent/",
+    "/learning/",
+    "/jobs/",
+    "/feed/",
+    "/posts/",
+    "/company/",
+    "/school/",
+    "/groups/",
+];
+export function normalizeLinkedinProfileUrl(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(trimmed.startsWith("http") ? trimmed : `https://${trimmed}`);
+    }
+    catch {
+        return null;
+    }
+    const host = parsed.hostname.replace(/^www\./i, "").toLowerCase();
+    if (host !== "linkedin.com" && !host.endsWith(".linkedin.com"))
+        return null;
+    const path = parsed.pathname.replace(/\/+$/, "");
+    const lowerPath = path.toLowerCase();
+    if (PROFILE_REJECT_PATH_FRAGMENTS.some((fragment) => lowerPath.includes(fragment)))
+        return null;
+    const parts = path.split("/").filter(Boolean);
+    const markerIndex = parts.findIndex((part) => part.toLowerCase() === "in" || part.toLowerCase() === "pub");
+    if (markerIndex < 0 || markerIndex >= parts.length - 1)
+        return null;
+    const rawHandle = parts[markerIndex + 1];
+    if (!rawHandle)
+        return null;
+    let handle;
+    try {
+        handle = decodeURIComponent(rawHandle).trim().toLowerCase();
+    }
+    catch {
+        handle = rawHandle.trim().toLowerCase();
+    }
+    if (!handle)
+        return null;
+    return {
+        normalized: `https://www.linkedin.com/in/${handle}`,
+        handle,
+    };
+}
+// A LinkedIn post URL carries the numeric activity id we address the post by:
+//   /posts/{slug}-activity-{19 digits}-{4 chars}
+//   /feed/update/urn:li:activity:{19 digits}
+// Anything else that happens to live on linkedin.com (a job, a company page) is
+// NOT a post, and must not be handed to a posts endpoint — callers get null and
+// fail closed rather than shipping a URL the provider answers with a confusing
+// "Invalid Post ID".
+const POST_ACTIVITY_ID_PATTERNS = [
+    /activity[:-](\d{6,})/i,
+    /urn:li:share:(\d{6,})/i,
+];
+/**
+ * Extract the addressable activity id from a LinkedIn post URL. Returns null for
+ * a bare id (already addressable — pass it through), and null for a linkedin.com
+ * URL that is not a post.
+ */
+export function linkedinPostIdFromUrl(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    // Only URLs are rewritten. A bare id or an activity URN is already addressable,
+    // so it returns null and the caller passes it through untouched.
+    if (!trimmed || !looksLikeUrlIdentifier(trimmed))
+        return null;
+    for (const pattern of POST_ACTIVITY_ID_PATTERNS) {
+        const match = pattern.exec(trimmed);
+        if (match?.[1])
+            return match[1];
+    }
+    return null;
+}
+/**
+ * True when a value is a URL rather than a provider identifier. Unipile addresses
+ * members, posts, and chats as PATH SEGMENTS, so a URL that reaches one is always
+ * a bug on our side — and the provider reports it as a permission or validation
+ * error that reads like the customer's account is broken. Callers use this to
+ * fail closed with an honest message instead.
+ */
+export function looksLikeUrlIdentifier(value) {
+    return /^https?:\/\//i.test(value.trim()) || /(^|\.)linkedin\.com\//i.test(value.trim());
+}