@yanlinglabs/winter-agent-runtime 0.0.27

package/dist/subagents/resolution.d.ts

@@ -0,0 +1,56 @@
+import type { ChildInheritance } from "./child-handle.js";
+export interface ModelCatalog {
+    aliases?: Readonly<Record<string, string>>;
+    availableModels?: readonly string[];
+    fallbackModel?: string;
+}
+export declare class UnresolvableModelAliasError extends Error {
+    readonly requested: string;
+    constructor(requested: string);
+}
+export interface ResolvedModel {
+    effectiveModel: string;
+    substitutedFrom?: string;
+}
+export declare function resolveModelAlias(requested: string, catalog?: ModelCatalog): ResolvedModel;
+export declare function describeRequestedModel(req: {
+    model?: string;
+    definition?: {
+        model?: string;
+    };
+}): string | undefined;
+export interface ResolvedEffort {
+    requestedEffort?: string;
+    effectiveEffort: string;
+}
+export declare function resolveEffort(inheritedEffort: string): ResolvedEffort;
+export interface RecordedModelEffort {
+    requestedModel?: string;
+    effectiveModel: string;
+    requestedEffort?: string;
+    effectiveEffort: string;
+    /**
+     * WS-13c §3: the provider the child's model actually resolved to.
+     *
+     * `effectiveModel` is a catalog KEY, whose provider half is only readable by string-splitting it --
+     * and a child spawned onto another family reaches a provider the parent's own record never names.
+     * WS-13c §8 makes the child's own record AUTHORITATIVE on resume, so the provider has to be a field
+     * here rather than something re-derived from the parent's live selection at resume time.
+     */
+    effectiveProvider?: string;
+    /**
+     * WS-13c §3: the SLOT the request named, if it named one.
+     *
+     * `requestedModel` is the raw string; this says what it meant and where it came from. Typed as
+     * `ChildInheritance["slot"]` rather than re-declared, so the record and the inheritance that
+     * produced it cannot drift apart on the `source` union.
+     */
+    slot?: ChildInheritance["slot"];
+}
+export declare function recordModelEffort(opts: {
+    requestedModel?: string;
+    resolved: ResolvedModel;
+    effort: ResolvedEffort;
+    effectiveProvider?: string;
+    slot?: ChildInheritance["slot"];
+}): RecordedModelEffort;

package/dist/subagents/restore.d.ts

@@ -0,0 +1,9 @@
+import type { SessionStore } from "@yanlinglabs/winter-agent-sdk";
+import type { ChildHandle, ChildSessionRecord } from "./child-handle.js";
+import { type RosterKey } from "./roster.js";
+export declare function restoredChildHandle(record: ChildSessionRecord): ChildHandle;
+export interface RestoredChildRoster {
+    handles: ChildHandle[];
+    remove(): void;
+}
+export declare function restoreChildRoster(store: SessionStore, key: RosterKey): Promise<RestoredChildRoster>;

package/dist/subagents/roster.d.ts

@@ -0,0 +1,17 @@
+import type { SessionStore } from "@yanlinglabs/winter-agent-sdk";
+import type { ChildSessionRecord } from "./child-handle.js";
+export interface RosterKey {
+    projectKey: string;
+    sessionId: string;
+}
+export type RosterEntry = {
+    ok: true;
+    record: ChildSessionRecord;
+    reconciled?: "orphaned";
+} | {
+    ok: false;
+    agentId: string;
+    reason: string;
+};
+export declare function rebuildChildRoster(store: SessionStore, key: RosterKey): Promise<RosterEntry[]>;
+export declare function successfulRecords(entries: RosterEntry[]): ChildSessionRecord[];

package/dist/subagents/test-fakes.d.ts

@@ -0,0 +1,12 @@
+import type { ChildHandle, ChildSessionRecord } from "./child-handle.js";
+import type { Provider, ProviderTurn } from "../engine.js";
+export interface ScriptedProviderFake extends Provider {
+    /** Every `ProviderRequest.model` this fake was asked to serve, in call order (`""` when absent). */
+    readonly servedModels: string[];
+    /** How many times `generate()` was called -- equivalent to `servedModels.length`, offered for readability at call sites. */
+    callCount(): number;
+}
+export declare function createScriptedProviderFake(turn?: ProviderTurn | (() => ProviderTurn)): ScriptedProviderFake;
+export declare function createFakeChildHandle(recordOverrides?: Partial<ChildSessionRecord>): ChildHandle & {
+    simulateCompletion(content: string): void;
+};

package/dist/subagents/tool-pools.d.ts

@@ -0,0 +1,69 @@
+import { type BrandProfile } from "@yanlinglabs/winter-agent-sdk";
+/**
+ * Research §A6, "Removed from EVERY subagent": TaskOutput, ExitPlanMode (kept in plan mode --
+ * CALLER's job: this set is applied UNLESS the child's own permission mode is `plan`, exactly as
+ * claude's own parenthetical says), EnterPlanMode, memory_list/read/write, AskUserQuestion, Poll,
+ * ConnectGitHub, WaitForMcpServers, RefreshMcpTools, Workflow (non-internal), ScheduleWakeup,
+ * ReadNotifications, ProposeGoal, EndConversation.
+ *
+ * THREE OF THE FOURTEEN HAVE NO WINTER EQUIVALENT AND ARE OMITTED, DISCLOSED (not silently dropped):
+ *   - `memory_list`/`memory_read`/`memory_write` -- Winter's memory is FILE-BASED (CLAUDE.md's own
+ *     "a MEMDIR of markdown written with ordinary write/edit -- no dedicated memory tools"). There is
+ *     nothing named `memory_*` to exclude; a subagent's memory access is already governed by whether
+ *     it holds `Read`/`Write`/`Edit` at all, which this pool does not touch.
+ *   - `Poll` -- no Winter tool of this name or shape exists.
+ *   - `ConnectGitHub` -- no Winter tool of this name or shape exists.
+ * Every other claude name below has a Winter tool of the identical shape and an unchanged name
+ * (`Agent`/`Artifact`/`ExitPlanMode`/`Edit`/`Write`/`NotebookEdit`/`AskUserQuestion`/
+ * `WaitForMcpServers`/`RefreshMcpTools`/`Workflow`/`ScheduleWakeup`/`ProposeGoal`/`EndConversation`/
+ * `TaskOutput` all register under their own bare names -- see `tools/descriptors/*.ts`), so no
+ * rename table is needed for those.
+ */
+export declare const SUBAGENT_EXCLUDED_TOOLS: readonly string[];
+/**
+ * Research §A6: a BACKGROUNDED subagent's tool pool is further limited to this allowlist (on top of
+ * whatever `SUBAGENT_EXCLUDED_TOOLS` above already removed) -- "`Agent` (depth-gated) and MCP tools
+ * pass regardless", which is why neither rides in this literal list: the depth gate and the MCP
+ * passthrough are structural exceptions the CALLER applies alongside this allowlist, not members of
+ * it (mirroring claude's own "pass regardless" wording exactly).
+ *
+ * ONE CLAUDE ENTRY HAS NO WINTER EQUIVALENT, DISCLOSED: "Search/List Plugins/Skills" -- Winter has no
+ * tool that enumerates installed plugins or searches the skill catalog (its `Skill` tool INVOKES a
+ * named skill, already listed below; there is no separate discovery tool to allow through).
+ *
+ * `GetTask` (claude's name) is Winter's `TaskGet`.
+ */
+export declare const BACKGROUND_AGENT_TOOL_ALLOWLIST: readonly string[];
+/**
+ * Tools that pass a background subagent's allowlist REGARDLESS of the literal list above -- claude's
+ * own "Agent (depth-gated) and MCP tools pass regardless." `Agent` itself is named so the CALLER can
+ * union it in only when the depth gate (research §A6's own nesting-limit check, `subagents/limits.ts`)
+ * still permits a further spawn; MCP tools are recognised by their `mcp__` prefix, not by name, so
+ * there is nothing to list for them here.
+ */
+export declare const BACKGROUND_AGENT_ALWAYS_ALLOWED_TOOL: string;
+export interface SubagentToolPoolOptions {
+    /** The child runs in `plan` mode -- `ExitPlanMode` stays (claude's own parenthetical). */
+    planMode: boolean;
+    /** The child is below the spawn-depth limit -- only then does it keep `Agent` (research §A6). */
+    mayNest: boolean;
+    /** The child is backgrounded -- its pool is further narrowed to the allowlist above. */
+    background: boolean;
+    /** The session's brand: names Winter's own standing-server twins (`mcp__<server>__send_message`, ...). */
+    brand?: Pick<BrandProfile, "mcpServerName">;
+}
+/**
+ * The child's EFFECTIVE tool pool, from the pool it would otherwise inherit (research §A6):
+ *   1. every name in `SUBAGENT_EXCLUDED_TOOLS` is removed (`ExitPlanMode` kept in plan mode);
+ *   2. `Agent` is removed once the child is at the spawn-depth limit (a child that cannot spawn must
+ *      not be offered the tool -- claude's depth-gated `Agent`);
+ *   3. a BACKGROUND child keeps only `BACKGROUND_AGENT_TOOL_ALLOWLIST`, plus `Agent` (depth-gated)
+ *      and every MCP tool, which pass regardless.
+ *
+ * WINTER'S OWN DEFAULT TOOLS ARE JUDGED BY THEIR BUILT-IN NAME. `SendMessage`, `ListAgents`,
+ * `ReadNotifications` and `advisor` are also registered as standing-server twins under
+ * `mcp__<server>__<tool>` (WS-09 §10); a twin is the same tool, so it follows its built-in name's
+ * verdict here rather than slipping through step 3's MCP passthrough (or step 1's exclusion) on its
+ * prefix alone. Only a genuine MCP server's tool is an "MCP tool" in claude's sense.
+ */
+export declare function applySubagentToolPool(tools: readonly string[], opts: SubagentToolPoolOptions): string[];

package/dist/subagents/watchdog.d.ts

@@ -0,0 +1,13 @@
+import { type BrandProfile } from "@yanlinglabs/winter-agent-sdk";
+export declare class ChildStalledError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, varName?: string);
+}
+export declare function resolveStallTimeoutMs(env?: Record<string, string | undefined>, brand?: Pick<BrandProfile, "envPrefix">): number;
+export interface StallWatchdog {
+    poke(): void;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+}
+export declare function createStallWatchdog(timeoutMs: number, onStall: (err: ChildStalledError) => void): StallWatchdog;

package/dist/subagents/workspace.d.ts

@@ -0,0 +1,27 @@
+import { type BrandProfile } from "@yanlinglabs/winter-agent-sdk";
+export type IsolationType = "normal" | "worktree";
+export type CleanupPolicy = "auto-remove-if-unchanged" | "keep";
+export interface Workspace {
+    root: string;
+    isolationType: IsolationType;
+    cleanupPolicy: CleanupPolicy;
+    branch?: string;
+}
+export type CreateWorkspaceResult = {
+    ok: true;
+    workspace: Workspace;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function createWorkspace(opts: {
+    parentCwd: string;
+    isolation?: "worktree";
+    agentId: string;
+    brand?: Pick<BrandProfile, "projectDirName">;
+}): Promise<CreateWorkspaceResult>;
+export interface CleanupResult {
+    removed: boolean;
+    reason: string;
+}
+export declare function cleanupWorkspace(workspace: Workspace): Promise<CleanupResult>;

package/dist/testing.d.ts

@@ -0,0 +1,5 @@
+import type { SpawnedRuntimeProcess } from "@yanlinglabs/winter-agent-sdk";
+import { type Provider, type ToolExecutor } from "./engine.js";
+import "./tools/descriptors/index.ts";
+import "./tools/impl/index.ts";
+export declare function inMemoryProcess(argv: string[], provider?: Provider, tools?: ToolExecutor, env?: Record<string, string | undefined>): SpawnedRuntimeProcess;

package/dist/testing.js

@@ -0,0 +1,194 @@
+import {
+  registerTool2,
+  runEngine2,
+  echoProvider2,
+  resolveEngineSession2
+} from "./index-9qgkpv56.js";
+import"./index-bef62z3r.js";
+import {
+  registerDefaultChildEngineFactory,
+  loadResumedChain,
+  buildProductionWiring,
+  withAutoSkillPermissions,
+  restoreChildRoster
+} from "./index-584yahed.js";
+import {
+  Queue
+} from "./index-97t2rmtf.js";
+
+// src/testing.ts
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { encodeFrame, splitFrames, WINTER_BRAND, envName, storeHomeEnvName } from "@yanlinglabs/winter-agent-sdk";
+import { WinterCompatibilitySessionStore, compatibilityKeys } from "@yanlinglabs/winter-agent-sdk";
+function registerEquivalenceStandIn(name) {
+  const echo = {
+    async execute(input) {
+      return { output: `${name}:${JSON.stringify(input)}` };
+    }
+  };
+  registerTool2({
+    descriptor: {
+      canonicalName: name,
+      advertisedName: name,
+      source: "sdk",
+      inputSchema: { type: "object" },
+      description: "Test-only equivalence-corpus stand-in (testing.ts) -- not a WS-06 tool.",
+      exposure: "hidden",
+      permissionClass: "read",
+      availability: {},
+      capabilityRequirements: [],
+      disposition: "implement-now"
+    },
+    executor: echo
+  });
+}
+for (const name of ["test_tool", "long_task", "mystery_tool"]) {
+  registerEquivalenceStandIn(name);
+}
+function resolveInMemoryWinterHome(config, env) {
+  if (config.winterHome !== undefined)
+    return config.winterHome;
+  const override = env?.[envName(config.brand ?? WINTER_BRAND, "HOME")];
+  if (override !== undefined && override.trim() !== "")
+    return override;
+  return mkdtempSync(join(tmpdir(), "winter-inmemory-"));
+}
+function resolveInMemoryStoreHome(config, env) {
+  if (config.storeHome !== undefined)
+    return config.storeHome;
+  return env?.[storeHomeEnvName(config.brand ?? WINTER_BRAND)];
+}
+function parseConfigFromArgv(argv) {
+  const idx = argv.indexOf("--config-json");
+  const raw = idx === -1 ? undefined : argv[idx + 1];
+  if (raw === undefined)
+    throw new Error("inMemoryProcess: argv is missing '--config-json <json>'");
+  return JSON.parse(raw);
+}
+function inMemoryProcess(argv, provider = echoProvider2, tools, env) {
+  const config = parseConfigFromArgv(argv);
+  let memoizedWinterHome;
+  const winterHomeOnce = () => memoizedWinterHome ??= resolveInMemoryWinterHome(config, env);
+  const stdin = new Queue;
+  const stdout = new Queue;
+  const stderr = new Queue;
+  const input = async function* () {
+    let carry = "";
+    for await (const chunk of stdin) {
+      const split = splitFrames(chunk, carry);
+      carry = split.carry;
+      for (const frame of split.frames)
+        yield frame;
+    }
+  }();
+  const output = {
+    write(frame) {
+      stdout.write(encodeFrame(frame));
+    },
+    end() {
+      stdout.end();
+    }
+  };
+  let settleExited;
+  const exited = new Promise((resolve) => {
+    settleExited = resolve;
+  });
+  let settled = false;
+  (async () => {
+    try {
+      const { config: effectiveConfig, store, initialMessages, approvalStore, autoStateStore } = await resolveEngineSession2({
+        config,
+        resolveWinterHome: winterHomeOnce,
+        resolveStoreHome: () => resolveInMemoryStoreHome(config, env),
+        env: env ?? {}
+      });
+      const childWinterHome = winterHomeOnce();
+      const childDurableRoot = resolveInMemoryStoreHome(config, env) ?? childWinterHome;
+      const childStore = config.persistSession === false ? undefined : new WinterCompatibilitySessionStore({ winterHome: childDurableRoot });
+      const providerChain = await loadResumedChain(store, initialMessages);
+      const wiring = await buildProductionWiring({
+        config: effectiveConfig,
+        env: env ?? {},
+        winterHome: winterHomeOnce(),
+        ...store !== undefined ? { persistence: store } : {},
+        provider: {
+          testProviders: () => provider,
+          chain: () => providerChain,
+          home: (env ?? {})["HOME"] ?? winterHomeOnce()
+        }
+      });
+      for (const warning of wiring.warnings)
+        stderr.write(`winter: ${warning}
+`);
+      registerDefaultChildEngineFactory({
+        provider: wiring.providerWiring.provider,
+        config: effectiveConfig,
+        env: env ?? {},
+        warn: (line) => stderr.write(`${line}
+`),
+        ...childStore !== undefined ? { store: childStore } : {},
+        ...childWinterHome !== undefined ? { winterHome: childWinterHome } : {},
+        ...wiring.childFactoryOptions
+      });
+      const restoredChildren = childStore !== undefined && config.forkSession !== true && (config.resume !== undefined || config.continue === true) ? await restoreChildRoster(childStore, { projectKey: compatibilityKeys(effectiveConfig.cwd).transcriptProjectKey, sessionId: effectiveConfig.sessionId }) : undefined;
+      try {
+        const code = await runEngine2({
+          config: withAutoSkillPermissions(wiring.config),
+          ...wiring.engineOptions,
+          input,
+          output,
+          provider: wiring.providerWiring.provider,
+          ...tools !== undefined ? { tools } : {},
+          ...store !== undefined ? { store } : {},
+          ...initialMessages.length > 0 ? { initialMessages } : {},
+          ...approvalStore !== undefined ? { approvalStore } : {},
+          ...autoStateStore !== undefined ? { autoStateStore } : {},
+          ...env !== undefined ? { env } : {}
+        });
+        if (!settled) {
+          settled = true;
+          stderr.end();
+          settleExited({ code, signal: null });
+        }
+      } finally {
+        restoredChildren?.remove();
+        wiring.dispose();
+      }
+    } catch {
+      if (!settled) {
+        settled = true;
+        stdout.end();
+        stderr.end();
+        settleExited({ code: 1, signal: null });
+      }
+    }
+  })();
+  return {
+    stdin: {
+      write(chunk) {
+        stdin.write(chunk);
+      },
+      end() {
+        stdin.end();
+      }
+    },
+    stdout,
+    stderr,
+    kill(signal) {
+      if (settled)
+        return;
+      settled = true;
+      stdout.end();
+      stderr.end();
+      stdin.end();
+      settleExited({ code: null, signal: signal ?? "SIGTERM" });
+    },
+    exited,
+    pid: null
+  };
+}
+export {
+  inMemoryProcess
+};

package/dist/tools/background-tasks.d.ts

@@ -0,0 +1,10 @@
+import { type SessionTempDirPaths } from "../paths/temp.js";
+export type SessionTempRootResolver = () => SessionTempDirPaths;
+export declare function configureBackgroundTaskRoot(resolver: SessionTempRootResolver): void;
+export declare function resetBackgroundTaskRootForTest(): void;
+export type BackgroundTaskKind = "bash" | "monitor" | "monitor_ws" | "workflow" | "agent";
+export declare function wireTaskType(kind: BackgroundTaskKind): string;
+export declare function createBackgroundTask(kind: BackgroundTaskKind): {
+    taskId: string;
+    outputPath: string;
+};

package/dist/tools/descriptors/_shared.d.ts

@@ -0,0 +1,34 @@
+import type { WinterToolDefinition } from "@yanlinglabs/winter-agent-sdk/tools";
+import { type ToolDescriptor } from "../registry.js";
+export declare function stub(descriptor: ToolDescriptor): void;
+/**
+ * The MODEL-FACING half of a descriptor, taken from the SDK's own definition (user ruling R-8-1).
+ *
+ * Winter's default tools are declared once, in `@yanlinglabs/winter-agent-sdk/tools`, because three
+ * copies of the same schema is how "both runtime branches present this exact model-facing schema"
+ * stops being true. A descriptor that binds one of them spreads THIS and then supplies only the
+ * registry POLICY the SDK deliberately does not carry (ruling P-8): `canonicalName`,
+ * `advertisedName`, `source`, `exposure`, `availability`, `capabilityRequirements`, `disposition`
+ * and `deferred`.
+ *
+ * THE SCHEMA OBJECTS PASS THROUGH BY REFERENCE, not by copy — `one-definition.test.ts` asserts
+ * identity (`toBe`), because two structurally identical literals pass every equality check on the
+ * day they are written and drift the moment one of them is edited.
+ *
+ * The cast is the price of two structural schema types that were written independently: the SDK's
+ * `JsonSchemaObject` types `properties` as `Record<string, unknown>` (it advertises schema DATA and
+ * validates nothing), while this registry's `JSONSchema` recurses into itself. Neither is a
+ * validator, both describe the same JSON, and widening either one to match the other would be a
+ * worse trade than one cast in one helper.
+ */
+export declare function definitionFields(definition: WinterToolDefinition): Pick<ToolDescriptor, "description" | "inputSchema" | "permissionClass"> & Partial<Pick<ToolDescriptor, "outputSchema" | "searchHint" | "annotations">>;
+/**
+ * The name a definition registers under on the NATIVE side: the official SDK's own built-in name
+ * when there is one, the bare tool name otherwise.
+ *
+ * A definition carries a bare name plus an alias key precisely so each host derives its own
+ * spelling; this is that derivation, in one place, so a descriptor never re-types a string the
+ * definition already knows.
+ */
+export declare function builtinNameOf(definition: WinterToolDefinition): string;
+export declare const ALWAYS_AVAILABLE: {};

package/dist/tools/descriptors/advisor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/agent.d.ts

@@ -0,0 +1,47 @@
+import type { JSONSchema } from "../registry.js";
+export interface AgentToolGateState {
+    /** R-S5: is `subagent_type: "fork"` selectable this session? */
+    forkEnabled: boolean;
+    /** research §A2: is `run_in_background` withheld because a host kill-switch is set? (`subagents/policy.ts`'s own `resolveBackgroundTasksDisabled`.) */
+    backgroundDisabled: boolean;
+    /** research §A3: is the `general-purpose` built-in actually available this session (R-S6's `allBuiltinsDisabled` kill switch off, or a same-named override present)? Governs the omitted-`subagent_type` sentence. */
+    generalPurposeAvailable: boolean;
+    /**
+     * I4 (fix wave): the EFFECTIVE default `subagents/policy.ts`'s `resolveForegroundBackground`
+     * actually applies at its own stage 5, when `run_in_background` is advertised at all (i.e. neither
+     * `forkEnabled` nor `backgroundDisabled` is true -- see `agentInputSchemaFor` below). `true` (SDK
+     * 0.0.16, matching claude) unless a host opted out via `RuntimeConfig.backgroundByDefault` / the
+     * `WINTER_BACKGROUND_BY_DEFAULT` env fallback. Optional (default `true`) so every pre-I4 gate
+     * object literal in this file's own tests keeps typechecking unchanged.
+     */
+    backgroundByDefault?: boolean;
+}
+/** The gate-OFF defaults the static registration below uses -- byte-identical to this descriptor's pre-parity shape wherever every gate reads as it always has (fork off, background on and the default, general-purpose present). */
+export declare const AGENT_TOOL_GATE_DEFAULTS: AgentToolGateState;
+/**
+ * research §A2's own field table, gate-aware (scope item 5: drop `run_in_background` when fork is on
+ * or a background kill switch is set; `name` stays withheld per the pre-existing P4-J(d) ruling,
+ * untouched by this lane).
+ */
+export declare function agentInputSchemaFor(gates?: AgentToolGateState): JSONSchema;
+export declare const OMITTED_TYPE_SENTENCE_AVAILABLE = "If omitted, the general-purpose agent is used.";
+/** The shared head of both omitted-type texts (research §A3/§A7): the description's sentence and the runtime refusal's message. */
+export declare const OMITTED_TYPE_REQUIRED_PREFIX = "subagent_type is required: the general-purpose agent is not available in this session";
+export declare const OMITTED_TYPE_SENTENCE_UNAVAILABLE = "subagent_type is required: the general-purpose agent is not available in this session, so choose one of the listed agent types.";
+/**
+ * research §A3's own structure, Winter-worded, gate-aware.
+ *
+ * R-S10 (whole-branch review r2 finding 3, controller ruling): a tool DESCRIPTION is multi-sentence
+ * prose and must be Winter-authored throughout, including its OPENING sentences -- an earlier
+ * version of this function argued the opening two sentences were "mechanism statements... reused as
+ * given, not claude prose" and left them byte-identical to claude's own pinned text (the exact
+ * strings the review's r2 finding 3 names). That argument does not survive R-S10: a fact being true
+ * of Winter's own runtime does not license copying the SENTENCE Anthropic used to state it. Both
+ * opening sentences below are reworded to carry the identical information (how an agent is launched
+ * and specialized; that the available types are announced in an injected reminder) in Winter's own
+ * words. `OMITTED_TYPE_SENTENCE_AVAILABLE`/`_UNAVAILABLE` are UNCHANGED -- R-S10's own allowance
+ * covers a short functional one-liner reused as BOTH a description sentence and a refusal message
+ * (the shared-constant discipline two lines up exists precisely so the two never drift), which is
+ * the category the ruling exempts.
+ */
+export declare function renderAgentToolDescription(gates?: AgentToolGateState): string;

package/dist/tools/descriptors/artifact.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/ask-user-question.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/bash.d.ts

@@ -0,0 +1,20 @@
+/** The name `engine.ts`'s `toolSpecFor` branches on, so no tool name is a literal there. */
+export declare const BASH_CANONICAL_NAME = "Bash";
+/** The static, sandbox-agnostic description -- what a session with no sandbox advertises, and what any reader outside a session sees. */
+export declare const BASH_DESCRIPTION = "Fresh shell per call; cwd changes persist only within allowed working directories; env exports do not persist. run_in_background returns a background task. Recognized read-only forms are built-in pre-approvals.";
+export declare const BASH_SANDBOX_HEADING = "## Bash command sandbox";
+/** The facts the section is rendered from. Absent (`bashDescriptionFor(undefined)`) means commands do not run in a sandbox at all. */
+export interface BashSandboxFacts {
+    /** The Seatbelt profile's resolved network posture (`resolveNetworkPosture`). `false` in every v1 configuration. */
+    networkAllowed: boolean;
+    /**
+     * Whether `dangerouslyDisableSandbox` can take a command out of the sandbox at all --
+     * `sandbox.allowUnsandboxedCommands !== false`. When it cannot, claude's "disabled by policy"
+     * bullets replace the override guidance (the runtime then ignores the flag, `sandbox/spawn.ts`).
+     * Absent reads as allowed.
+     */
+    unsandboxedAllowed?: boolean;
+}
+export declare function bashSandboxSection(facts: BashSandboxFacts): string;
+/** The description a session advertises: the base text, plus the sandbox section when its commands run sandboxed. */
+export declare function bashDescriptionFor(facts: BashSandboxFacts | undefined): string;

package/dist/tools/descriptors/claude-design.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/cron-create.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/cron-delete.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/cron-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/edit.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/end-conversation.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/enter-plan-mode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/enter-worktree.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/exit-plan-mode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/exit-worktree.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/glob.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/grep.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/index.d.ts

@@ -0,0 +1,59 @@
+import "./agent.ts";
+import "./artifact.ts";
+import "./ask-user-question.ts";
+import "./advisor.ts";
+import "./bash.ts";
+import "./claude-design.ts";
+import "./cron-create.ts";
+import "./cron-delete.ts";
+import "./cron-list.ts";
+import "./edit.ts";
+import "./end-conversation.ts";
+import "./enter-plan-mode.ts";
+import "./enter-worktree.ts";
+import "./exit-plan-mode.ts";
+import "./exit-worktree.ts";
+import "./glob.ts";
+import "./grep.ts";
+import "./list-agents.ts";
+import "./list-mcp-resources-tool.ts";
+import "./lsp.ts";
+import "./monitor.ts";
+import "./notebook-edit.ts";
+import "./powershell.ts";
+import "./projects.ts";
+import "./propose-goal.ts";
+import "./propose-skills.ts";
+import "./push-notification.ts";
+import "./read.ts";
+import "./read-mcp-resource-dir-tool.ts";
+import "./read-mcp-resource-tool.ts";
+import "./read-notifications.ts";
+import "./refresh-mcp-tools.ts";
+import "./remote-trigger.ts";
+import "./repl.ts";
+import "./report-findings.ts";
+import "./schedule-wakeup.ts";
+import "./send-feedback.ts";
+import "./send-message.ts";
+import "./send-user-file.ts";
+import "./share-onboarding-guide.ts";
+import "./show-onboarding-role-picker.ts";
+import "./skill.ts";
+import "./structured-output.ts";
+import "./task-create.ts";
+import "./task-get.ts";
+import "./task-list.ts";
+import "./task-output.ts";
+import "./task-stop.ts";
+import "./task-update.ts";
+import "./todo-write.ts";
+import "./tool-search.ts";
+import "./wait-for-mcp-servers.ts";
+import "./web-fetch.ts";
+import "./web-search.ts";
+import "./winter-list-agents.ts";
+import "./winter-send-message.ts";
+import "./workflow.ts";
+import "./write.ts";
+export declare const DESCRIPTORS_REGISTERED = true;

package/dist/tools/descriptors/list-agents.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/list-mcp-resources-tool.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/lsp.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/monitor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/descriptors/notebook-edit.d.ts

@@ -0,0 +1 @@
+export {};