@openscout/protocol 0.2.63 → 0.2.82

package/dist/runtime-execution.js

@@ -0,0 +1,327 @@
+import { SCOUT_RUNTIME_CATALOG_DATA } from "./runtime-catalog.generated.js";
+import { SCOUT_LAUNCHABLE_HARNESSES, SCOUT_REASONING_EFFORT_LABELS, SCOUT_REASONING_EFFORTS, } from "./runtime-catalog-contract.js";
+export * from "./runtime-catalog-contract.js";
+/**
+ * Scout's versioned product catalog. Harness vendors are execution adapters,
+ * not catalog authorities: availability, ordering, labels, defaults, and the
+ * per-model effort ladder come from runtime-catalog.v1.json. Running brokers
+ * may replace this bundled last-known-good seed with a newer valid revision.
+ */
+export const SCOUT_RUNTIME_CATALOG = SCOUT_RUNTIME_CATALOG_DATA;
+export function scoutRuntimeHarness(harness, catalog = SCOUT_RUNTIME_CATALOG) {
+    return catalog.harnesses.find((entry) => entry.id === harness);
+}
+export function isScoutRuntimeHarnessEnabled(harness, catalog = SCOUT_RUNTIME_CATALOG) {
+    return scoutRuntimeHarness(harness, catalog)?.enabled === true;
+}
+/** Enabled and offered as its own picker row. Hidden transports remain legal. */
+export function isScoutRuntimeHarnessListed(harness, catalog = SCOUT_RUNTIME_CATALOG) {
+    const entry = scoutRuntimeHarness(harness, catalog);
+    return entry?.enabled === true && entry.listed !== false;
+}
+export function scoutRuntimeDefaultHarness(catalog = SCOUT_RUNTIME_CATALOG) {
+    return catalog.harnesses.find((entry) => entry.enabled && entry.default)?.id
+        ?? catalog.harnesses.find((entry) => entry.enabled)?.id
+        ?? null;
+}
+export function scoutRuntimeDefaultModel(harness, catalog = SCOUT_RUNTIME_CATALOG) {
+    const entry = scoutRuntimeHarness(harness, catalog);
+    return entry?.models.find((model) => model.enabled && model.default)?.id
+        ?? entry?.models.find((model) => model.enabled)?.id
+        ?? null;
+}
+export function scoutRuntimeReasoningEfforts(harness, model, catalog = SCOUT_RUNTIME_CATALOG) {
+    const entry = scoutRuntimeHarness(harness, catalog);
+    if (!entry || !entry.enabled)
+        return null;
+    const selected = model
+        ? entry.models.find((candidate) => candidate.enabled && candidate.id === model)
+        : undefined;
+    return selected?.reasoningEfforts === null
+        ? null
+        : selected?.reasoningEfforts ?? entry.reasoningEfforts;
+}
+export function scoutRuntimeDefaultReasoningEffort(harness, model, catalog = SCOUT_RUNTIME_CATALOG) {
+    const entry = scoutRuntimeHarness(harness, catalog);
+    const selected = model
+        ? entry?.models.find((candidate) => candidate.enabled && candidate.id === model)
+        : undefined;
+    const efforts = scoutRuntimeReasoningEfforts(harness, model, catalog);
+    const preferred = selected?.defaultReasoningEffort ?? entry?.defaultReasoningEffort ?? null;
+    return preferred && efforts?.includes(preferred) ? preferred : efforts?.[0] ?? null;
+}
+export function scoutRuntimeDefaultsByHarness(catalog = SCOUT_RUNTIME_CATALOG) {
+    return Object.fromEntries(catalog.harnesses
+        .filter((entry) => entry.enabled)
+        .map((entry) => {
+        const model = scoutRuntimeDefaultModel(entry.id, catalog);
+        return [entry.id, {
+                model,
+                reasoningEffort: scoutRuntimeDefaultReasoningEffort(entry.id, model, catalog),
+            }];
+    }));
+}
+export const SCOUT_RUNTIME_DEFAULTS_BY_HARNESS = scoutRuntimeDefaultsByHarness();
+export const SCOUT_REASONING_EFFORTS_BY_HARNESS = Object.fromEntries(SCOUT_RUNTIME_CATALOG.harnesses
+    .filter((entry) => entry.enabled)
+    .map((entry) => {
+    const supported = SCOUT_REASONING_EFFORTS.filter((effort) => entry.reasoningEfforts?.includes(effort)
+        || entry.models.some((model) => model.enabled && model.reasoningEfforts?.includes(effort)));
+    return [entry.id, supported];
+}));
+/** Project one nested catalog into the flat API model list. */
+export function scoutRuntimeModelCatalog(catalog = SCOUT_RUNTIME_CATALOG) {
+    const models = new Map();
+    for (const harness of catalog.harnesses) {
+        if (!harness.enabled)
+            continue;
+        for (const model of harness.models) {
+            if (!model.enabled)
+                continue;
+            const existing = models.get(model.id);
+            if (existing) {
+                if (!existing.harnesses.includes(harness.id))
+                    existing.harnesses.push(harness.id);
+                continue;
+            }
+            models.set(model.id, {
+                id: model.id,
+                label: model.label,
+                ...(model.description ? { description: model.description } : {}),
+                harnesses: [harness.id],
+                source: "default",
+                ...(model.family ? { family: model.family } : {}),
+                ...(model.version ? { version: model.version } : {}),
+            });
+        }
+    }
+    return Array.from(models.values());
+}
+/** Projections retained for API compatibility; SCOUT_RUNTIME_CATALOG owns them. */
+export const SCOUT_RUNTIME_MODEL_CATALOG = scoutRuntimeModelCatalog();
+const SCOUT_RUNTIME_EFFORT_DESCRIPTIONS = {
+    none: "No extra thinking",
+    minimal: "Smallest reasoning budget",
+    low: "Fast responses with lighter reasoning",
+    medium: "Balanced speed and reasoning depth",
+    high: "Greater reasoning depth for complex work",
+    xhigh: "Extra high reasoning depth",
+    max: "Maximum reasoning depth",
+    ultra: "Maximum reasoning with delegation",
+};
+export function scoutRuntimeEffortCatalog(catalog = SCOUT_RUNTIME_CATALOG) {
+    return SCOUT_REASONING_EFFORTS.flatMap((id) => {
+        const harnesses = [];
+        const restrictedModels = [];
+        for (const harness of catalog.harnesses) {
+            if (!harness.enabled)
+                continue;
+            const enabledModels = harness.models.filter((model) => model.enabled);
+            const supportingModels = enabledModels.filter((model) => (model.reasoningEfforts ?? harness.reasoningEfforts)?.includes(id));
+            const supportedWithoutModel = enabledModels.length === 0 && harness.reasoningEfforts?.includes(id);
+            if (supportingModels.length === 0 && !supportedWithoutModel)
+                continue;
+            harnesses.push(harness.id);
+            if (enabledModels.length > 0 && supportingModels.length < enabledModels.length) {
+                restrictedModels.push(...supportingModels.map((model) => model.id));
+            }
+        }
+        if (harnesses.length === 0)
+            return [];
+        return [{
+                id,
+                label: SCOUT_REASONING_EFFORT_LABELS[id],
+                description: SCOUT_RUNTIME_EFFORT_DESCRIPTIONS[id],
+                harnesses,
+                ...(restrictedModels.length > 0 ? { models: restrictedModels } : {}),
+            }];
+    });
+}
+export const SCOUT_RUNTIME_EFFORT_CATALOG = scoutRuntimeEffortCatalog();
+/** Canonical model aliases shared by every request boundary and spawn path. */
+export function normalizeScoutRuntimeModel(harness, input) {
+    const requested = input.trim();
+    if (!requested) {
+        return { ok: false, requested, error: "model cannot be empty" };
+    }
+    const normalizedHarness = harness.trim().toLowerCase();
+    const lower = requested.toLowerCase();
+    if (normalizedHarness === "codex") {
+        if (lower === "5.6" || lower === "gpt-5.6") {
+            return { ok: true, requested, resolved: "gpt-5.6-sol" };
+        }
+        if (/^\d+(?:\.\d+)*(?:-[a-z0-9][a-z0-9._-]*)?$/u.test(lower)) {
+            return { ok: true, requested, resolved: `gpt-${lower}` };
+        }
+        return { ok: true, requested, resolved: requested };
+    }
+    if (normalizedHarness === "claude") {
+        const aliases = {
+            fable: "claude-fable-5",
+            opus: "claude-opus-5",
+            sonnet: "claude-sonnet-4-6",
+            haiku: "claude-haiku-4-5",
+        };
+        return { ok: true, requested, resolved: aliases[lower] ?? requested };
+    }
+    return { ok: true, requested, resolved: requested };
+}
+/** Parse the shell-safe `<harness>[/<model>[/<effort>]]` production. */
+export function parseScoutRuntimeSpec(input) {
+    const raw = input.trim();
+    const parts = raw.split("/");
+    if (!raw || parts.length > 3 || parts.some((part) => !part.trim())) {
+        return {
+            ok: false,
+            error: "runtime must be <harness>[/<model>[/<effort>]]",
+        };
+    }
+    const harness = parts[0].trim().toLowerCase();
+    if (!isScoutLaunchableHarness(harness)) {
+        return {
+            ok: false,
+            error: `unsupported runtime harness "${parts[0]}"; expected one of: ${SCOUT_LAUNCHABLE_HARNESSES.join(", ")}`,
+        };
+    }
+    const model = parts[1]?.trim();
+    const effortRaw = parts[2]?.trim();
+    const reasoningEffort = effortRaw ? normalizeScoutReasoningEffort(effortRaw) : null;
+    if (effortRaw && !reasoningEffort) {
+        return {
+            ok: false,
+            error: `unsupported reasoning effort "${effortRaw}"; expected one of: ${SCOUT_REASONING_EFFORTS.join(", ")}`,
+        };
+    }
+    const issues = validateScoutRuntimeTuple({ harness, model, reasoningEffort });
+    if (issues.length > 0) {
+        return { ok: false, error: issues.map((issue) => issue.message).join("; ") };
+    }
+    return {
+        ok: true,
+        value: {
+            harness,
+            ...(model ? { model } : {}),
+            ...(reasoningEffort ? { reasoningEffort } : {}),
+        },
+    };
+}
+export function formatScoutRuntimeSpec(spec) {
+    if (spec.reasoningEffort && !spec.model) {
+        throw new Error("runtime literal cannot encode effort without a model; use --harness and --effort");
+    }
+    return [spec.harness, spec.model, spec.reasoningEffort]
+        .filter((part) => Boolean(part))
+        .join("/");
+}
+export function isScoutLaunchableHarness(value) {
+    return Boolean(value)
+        && SCOUT_LAUNCHABLE_HARNESSES.includes(value.trim().toLowerCase());
+}
+export function normalizeScoutReasoningEffort(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized && SCOUT_REASONING_EFFORTS.includes(normalized)
+        ? normalized
+        : null;
+}
+export function runtimeDimensionResolution(input) {
+    const requested = input.requested?.trim() || undefined;
+    const resolved = input.resolved?.trim() || undefined;
+    const observed = input.observed?.trim() || undefined;
+    const drift = !observed || !resolved
+        ? "unknown"
+        : observed.toLowerCase() === resolved.toLowerCase()
+            ? "match"
+            : "mismatch";
+    return {
+        ...(requested ? { requested } : {}),
+        ...(resolved ? { resolved } : {}),
+        ...(input.source && resolved ? { source: input.source } : {}),
+        ...(observed ? { observed } : {}),
+        ...(observed && input.observedAt !== undefined ? { observedAt: input.observedAt } : {}),
+        drift,
+    };
+}
+export function createScoutExecutionResolution(input) {
+    const dimension = (key) => runtimeDimensionResolution({
+        requested: input.requested?.[key],
+        resolved: input.resolved?.[key],
+        source: input.source?.[key],
+        observed: input.observed?.[key],
+        observedAt: input.observedAt,
+    });
+    return {
+        schemaVersion: "openscout.execution-resolution.v1",
+        harness: dimension("harness"),
+        model: dimension("model"),
+        reasoningEffort: dimension("reasoningEffort"),
+        ...(input.sessionId?.trim() ? { sessionId: input.sessionId.trim() } : {}),
+        ...(input.resolvedAt !== undefined ? { resolvedAt: input.resolvedAt } : {}),
+        ...(input.observedAt !== undefined ? { observedAt: input.observedAt } : {}),
+    };
+}
+export function validateScoutRuntimeTuple(input, catalog) {
+    const harness = input.harness?.trim().toLowerCase();
+    const model = input.model?.trim();
+    const effortRaw = input.reasoningEffort?.trim();
+    const issues = [];
+    if (harness && !isScoutLaunchableHarness(harness)) {
+        issues.push({
+            code: "unsupported_harness",
+            dimension: "harness",
+            message: `unsupported harness "${input.harness}"; expected one of: ${SCOUT_LAUNCHABLE_HARNESSES.join(", ")}`,
+        });
+        return issues;
+    }
+    const effort = effortRaw ? normalizeScoutReasoningEffort(effortRaw) : null;
+    if (effortRaw && !effort) {
+        issues.push({
+            code: "unsupported_reasoning_effort",
+            dimension: "reasoningEffort",
+            message: `unsupported reasoning effort "${effortRaw}"; expected one of: ${SCOUT_REASONING_EFFORTS.join(", ")}`,
+        });
+    }
+    else if (effort && harness) {
+        const catalogEffort = catalog?.efforts.find((candidate) => candidate.id === effort);
+        let supported = catalogEffort
+            ? catalogEffort.harnesses.includes(harness)
+            : (scoutRuntimeReasoningEfforts(harness, model) ?? []).includes(effort);
+        if (supported && catalogEffort?.models?.length && model) {
+            const harnessModels = new Set(catalog?.models
+                .filter((candidate) => candidate.harnesses.includes(harness))
+                .map((candidate) => candidate.id.toLowerCase()) ?? []);
+            const scopedModels = catalogEffort.models.filter((candidate) => (harnessModels.has(candidate.toLowerCase())));
+            if (harnessModels.has(model.toLowerCase()) && scopedModels.length > 0) {
+                supported = scopedModels.some((candidate) => candidate.toLowerCase() === model.toLowerCase());
+            }
+        }
+        if (!supported) {
+            issues.push({
+                code: "reasoning_effort_harness_mismatch",
+                dimension: "reasoningEffort",
+                message: `reasoning effort "${effort}" is not supported by harness "${harness}"`,
+            });
+        }
+    }
+    const modelSelectableHarness = harness === "claude"
+        || harness === "codex"
+        || harness === "grok"
+        || harness === "grok-acp";
+    if (model && harness && !modelSelectableHarness) {
+        issues.push({
+            code: "unsupported_model_dimension",
+            dimension: "model",
+            message: `model selection is not supported by harness "${harness}"`,
+        });
+    }
+    else if (model && harness && catalog) {
+        const known = catalog.models.find((candidate) => candidate.id.toLowerCase() === model.toLowerCase());
+        if (known && !known.harnesses.includes(harness)) {
+            issues.push({
+                code: "model_harness_mismatch",
+                dimension: "model",
+                message: `model "${model}" is not supported by harness "${harness}"`,
+            });
+        }
+    }
+    return issues;
+}

package/dist/runtime-profiles.d.ts

@@ -0,0 +1,12 @@
+import { type ScoutReasoningEffort } from "./runtime-execution.js";
+/**
+ * Reserved natural-language profile names. Their execution definitions stay
+ * broker-owned; clients use this list only to recognize unambiguous syntax.
+ */
+export declare const SCOUT_RESERVED_RUNTIME_PROFILE_IDS: readonly ["fable", "kimi", "grok", "opus"];
+export type ScoutReservedRuntimeProfileId = (typeof SCOUT_RESERVED_RUNTIME_PROFILE_IDS)[number];
+export declare const SCOUT_RUNTIME_PROFILE_REASONING_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export type ScoutRuntimeProfileReasoningEffort = ScoutReasoningEffort;
+export declare function normalizeReservedRuntimeProfileId(value: string): ScoutReservedRuntimeProfileId | null;
+export declare function normalizeRuntimeProfileReasoningEffort(value: string): ScoutRuntimeProfileReasoningEffort | null;
+//# sourceMappingURL=runtime-profiles.d.ts.map

package/dist/runtime-profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-profiles.d.ts","sourceRoot":"","sources":["../src/runtime-profiles.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,kCAAkC,4CAKrC,CAAC;AAEX,MAAM,MAAM,6BAA6B,GACvC,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtD,eAAO,MAAM,uCAAuC,gFAA0B,CAAC;AAE/E,MAAM,MAAM,kCAAkC,GAAG,oBAAoB,CAAC;AAEtE,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,MAAM,GACZ,6BAA6B,GAAG,IAAI,CAGtC;AAED,wBAAgB,sCAAsC,CACpD,KAAK,EAAE,MAAM,GACZ,kCAAkC,GAAG,IAAI,CAE3C"}

package/dist/runtime-profiles.js

@@ -0,0 +1,20 @@
+import { normalizeAgentSelectorSegment } from "./agent-identity.js";
+import { normalizeScoutReasoningEffort, SCOUT_REASONING_EFFORTS, } from "./runtime-execution.js";
+/**
+ * Reserved natural-language profile names. Their execution definitions stay
+ * broker-owned; clients use this list only to recognize unambiguous syntax.
+ */
+export const SCOUT_RESERVED_RUNTIME_PROFILE_IDS = [
+    "fable",
+    "kimi",
+    "grok",
+    "opus",
+];
+export const SCOUT_RUNTIME_PROFILE_REASONING_EFFORTS = SCOUT_REASONING_EFFORTS;
+export function normalizeReservedRuntimeProfileId(value) {
+    const normalized = normalizeAgentSelectorSegment(value);
+    return SCOUT_RESERVED_RUNTIME_PROFILE_IDS.find((id) => id === normalized) ?? null;
+}
+export function normalizeRuntimeProfileReasoningEffort(value) {
+    return normalizeScoutReasoningEffort(normalizeAgentSelectorSegment(value));
+}

package/dist/scout-agent-card.d.ts

@@ -39,6 +39,14 @@ export interface ScoutReturnAddress {
     sessionId?: string;
     metadata?: MetadataMap;
 }
+export interface ScoutAgentCardLifecycle {
+    kind: "persistent" | "one_time";
+    createdAt?: number;
+    createdById?: ScoutId;
+    expiresAt?: number;
+    maxUses?: number;
+    inboxConversationId?: ScoutId;
+}
 /**
  * Scout's local discovery and routing card for one addressable agent target.
  *
@@ -75,7 +83,9 @@ export interface ScoutAgentCard {
     createdById?: ScoutId;
     brokerRegistered: boolean;
     inboxConversationId?: ScoutId;
+    lifecycle?: ScoutAgentCardLifecycle;
     returnAddress: ScoutReturnAddress;
     metadata?: MetadataMap;
 }
 export declare function buildScoutReturnAddress(input: ScoutReturnAddress): ScoutReturnAddress;
+//# sourceMappingURL=scout-agent-card.d.ts.map

package/dist/scout-agent-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scout-agent-card.d.ts","sourceRoot":"","sources":["../src/scout-agent-card.ts"],"names":[],"mappings":"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"}

package/dist/scout-composer.d.ts

@@ -0,0 +1,27 @@
+import type { ScoutRouteTarget } from "./scout-dispatch.js";
+export declare const SCOUT_COMPOSER_ROUTE_OPERATOR: ">>";
+export declare const SCOUT_TARGET_HANDLE_SHORTHAND: "\u2316";
+export type ScoutComposerRouteDiagnosticCode = "missing_target" | "invalid_target";
+export interface ScoutComposerRouteDiagnostic {
+    code: ScoutComposerRouteDiagnosticCode;
+    message: string;
+    start: number;
+    end: number;
+}
+export interface ScoutComposerRoute {
+    operator: typeof SCOUT_COMPOSER_ROUTE_OPERATOR;
+    token: string;
+    target: ScoutRouteTarget;
+    operatorStart: number;
+    operatorEnd: number;
+    targetStart: number;
+    targetEnd: number;
+}
+export interface ScoutComposerRouteParseResult {
+    route: ScoutComposerRoute | null;
+    body: string;
+    diagnostics: ScoutComposerRouteDiagnostic[];
+}
+export declare function parseScoutComposerRouteTarget(value: string): ScoutRouteTarget | null;
+export declare function parseScoutComposerRoute(input: string): ScoutComposerRouteParseResult;
+//# sourceMappingURL=scout-composer.d.ts.map

package/dist/scout-composer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scout-composer.d.ts","sourceRoot":"","sources":["../src/scout-composer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,eAAO,MAAM,6BAA6B,EAAG,IAAa,CAAC;AAC3D,eAAO,MAAM,6BAA6B,EAAG,QAAY,CAAC;AAE1D,MAAM,MAAM,gCAAgC,GACxC,gBAAgB,GAChB,gBAAgB,CAAC;AAErB,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,gCAAgC,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,6BAA6B,CAAC;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,4BAA4B,EAAE,CAAC;CAC7C;AA+HD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAyBpF;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,6BAA6B,CA8DpF"}

package/dist/scout-composer.js

@@ -0,0 +1,192 @@
+import { parseAgentIdentity } from "./agent-identity.js";
+import { AGENT_HARNESSES } from "./actors.js";
+export const SCOUT_COMPOSER_ROUTE_OPERATOR = ">>";
+export const SCOUT_TARGET_HANDLE_SHORTHAND = "⌖";
+const WHITESPACE_PATTERN = /\s/;
+const TRAILING_TARGET_PUNCTUATION_PATTERN = /[.,!?;)\]}]+$/;
+const ROUTE_VALUE_PATTERN = /^\S+$/;
+const AGENT_LABEL_START_PATTERN = /^[A-Za-z0-9]/;
+const SESSION_ROUTE_HARNESSES = new Set(AGENT_HARNESSES);
+function findRouteOperator(input) {
+    let searchFrom = 0;
+    while (searchFrom < input.length) {
+        const index = input.indexOf(SCOUT_COMPOSER_ROUTE_OPERATOR, searchFrom);
+        if (index === -1) {
+            return null;
+        }
+        const previous = index > 0 ? input[index - 1] : "";
+        if (index === 0 || WHITESPACE_PATTERN.test(previous)) {
+            return {
+                start: index,
+                end: index + SCOUT_COMPOSER_ROUTE_OPERATOR.length,
+            };
+        }
+        searchFrom = index + SCOUT_COMPOSER_ROUTE_OPERATOR.length;
+    }
+    return null;
+}
+function routeBodyWithoutTarget(input, start, end) {
+    return `${input.slice(0, start)} ${input.slice(end)}`.replace(/\s+/g, " ").trim();
+}
+function trimRouteTargetToken(value) {
+    return value
+        .trim()
+        .replace(TRAILING_TARGET_PUNCTUATION_PATTERN, "");
+}
+function isRouteValue(value) {
+    return value.length > 0 && ROUTE_VALUE_PATTERN.test(value);
+}
+function parseAgentLabelTarget(value) {
+    const label = value.replace(/^@+/, "");
+    if (!AGENT_LABEL_START_PATTERN.test(label)) {
+        return null;
+    }
+    if (!parseAgentIdentity(label)) {
+        return null;
+    }
+    return { kind: "agent_label", label, value };
+}
+function parseTargetHandleTarget(rawValue) {
+    const handle = rawValue.replace(/^[@⌖]+/, "");
+    if (!isRouteValue(handle)) {
+        return null;
+    }
+    return { kind: "target_handle", handle, value: `target:${handle}` };
+}
+function parseRouteAliasTarget(rawValue) {
+    const alias = rawValue.replace(/^@+/, "").trim().toLowerCase();
+    if (!isRouteValue(alias))
+        return null;
+    return { kind: "route_alias", alias, value: `alias:${alias}` };
+}
+function parseSessionRouteTarget(rawValue) {
+    const value = rawValue.replace(/^@+/, "");
+    if (!isRouteValue(value)) {
+        return null;
+    }
+    const harnessSeparator = value.indexOf(":");
+    if (harnessSeparator > 0) {
+        const maybeHarness = value.slice(0, harnessSeparator);
+        const sessionId = value.slice(harnessSeparator + 1);
+        if (SESSION_ROUTE_HARNESSES.has(maybeHarness) && isRouteValue(sessionId)) {
+            return {
+                kind: "session_id",
+                sessionId,
+                harness: maybeHarness,
+                value: `session:${maybeHarness}:${sessionId}`,
+            };
+        }
+    }
+    return { kind: "session_id", sessionId: value, value: `session:${value}` };
+}
+function parsePrefixedRouteTarget(prefix, rawValue) {
+    const value = rawValue.replace(/^@+/, "");
+    if (!isRouteValue(value)) {
+        return null;
+    }
+    if (prefix === "agent" || prefix === "a") {
+        return parseAgentLabelTarget(value);
+    }
+    if (prefix === "alias" || prefix === "route-alias" || prefix === "route_alias") {
+        return parseRouteAliasTarget(rawValue);
+    }
+    if (prefix === "target" || prefix === "target-handle" || prefix === "target_handle") {
+        return parseTargetHandleTarget(rawValue);
+    }
+    if (prefix === "ref" || prefix === "binding" || prefix === "binding-ref") {
+        return { kind: "binding_ref", ref: value, value: `ref:${value}` };
+    }
+    if (prefix === "project" || prefix === "project-path" || prefix === "project_path") {
+        return { kind: "project_path", projectPath: value, value: `project:${value}` };
+    }
+    if (prefix === "id" || prefix === "agent-id" || prefix === "agent_id") {
+        return { kind: "agent_id", agentId: value, value: `id:${value}` };
+    }
+    if (prefix === "session" || prefix === "session-id" || prefix === "session_id" || prefix === "sid" || prefix === "s") {
+        return parseSessionRouteTarget(rawValue);
+    }
+    if (prefix === "channel" || prefix === "chan" || prefix === "ch") {
+        return { kind: "channel", channel: value, value: `channel:${value}` };
+    }
+    return null;
+}
+export function parseScoutComposerRouteTarget(value) {
+    const token = trimRouteTargetToken(value);
+    if (!isRouteValue(token)) {
+        return null;
+    }
+    if (token === "broadcast") {
+        return { kind: "broadcast", value: token };
+    }
+    if (token.startsWith(SCOUT_TARGET_HANDLE_SHORTHAND)) {
+        return parseTargetHandleTarget(token);
+    }
+    const separatorIndex = token.indexOf(":");
+    if (separatorIndex > 0) {
+        const prefix = token.slice(0, separatorIndex).toLowerCase();
+        const rawValue = token.slice(separatorIndex + 1);
+        const prefixed = parsePrefixedRouteTarget(prefix, rawValue);
+        if (prefixed) {
+            return prefixed;
+        }
+    }
+    return parseAgentLabelTarget(token);
+}
+export function parseScoutComposerRoute(input) {
+    const operator = findRouteOperator(input);
+    if (!operator) {
+        return {
+            route: null,
+            body: input.trim(),
+            diagnostics: [],
+        };
+    }
+    let targetStart = operator.end;
+    while (targetStart < input.length && WHITESPACE_PATTERN.test(input[targetStart] ?? "")) {
+        targetStart += 1;
+    }
+    if (targetStart >= input.length) {
+        return {
+            route: null,
+            body: routeBodyWithoutTarget(input, operator.start, operator.end),
+            diagnostics: [{
+                    code: "missing_target",
+                    message: "route operator requires a target after >>",
+                    start: operator.start,
+                    end: operator.end,
+                }],
+        };
+    }
+    let targetEnd = targetStart;
+    while (targetEnd < input.length && !WHITESPACE_PATTERN.test(input[targetEnd] ?? "")) {
+        targetEnd += 1;
+    }
+    const rawToken = input.slice(targetStart, targetEnd);
+    const token = trimRouteTargetToken(rawToken);
+    const target = parseScoutComposerRouteTarget(token);
+    if (!target) {
+        return {
+            route: null,
+            body: routeBodyWithoutTarget(input, operator.start, targetEnd),
+            diagnostics: [{
+                    code: "invalid_target",
+                    message: `invalid route target: ${rawToken}`,
+                    start: targetStart,
+                    end: targetEnd,
+                }],
+        };
+    }
+    return {
+        route: {
+            operator: SCOUT_COMPOSER_ROUTE_OPERATOR,
+            token,
+            target,
+            operatorStart: operator.start,
+            operatorEnd: operator.end,
+            targetStart,
+            targetEnd,
+        },
+        body: routeBodyWithoutTarget(input, operator.start, targetEnd),
+        diagnostics: [],
+    };
+}