@wrongstack/core 0.300.0 → 0.301.0

package/dist/core/instruction-template.d.ts

@@ -3,11 +3,12 @@
  *
  * Why this exists: `instructions/system.md` (and its `-lite` / `-pro`
  * variants) used to be injected as layer-1 verbatim, listing ~100 tool names
- * regardless of which tools the current request actually registered. At
- * `minimal`/`light` tier only the 15 TIER1 tools survive
+ * regardless of which tools the current request actually exposed. At
+ * `minimal`/`light` tier only the 15 TIER1 tools are sent directly
  * (`@wrongstack/tools` `selectBuiltinToolsForTier`), yet the prompt still
  * spent ~8k tokens explaining `kanban`, the browser tools, the SAGE memory
- * tools and the Telegram bridge — none of which the model could call. The
+ * tools and the Telegram bridge. Those tools may remain executable through
+ * lazy discovery, but are not legal direct calls in that request. The
  * token-saving tier was spending most of its savings back in the prompt, and
  * the text had to carry a "some of the above may be a lie" disclaimer to
  * compensate.
@@ -69,6 +70,8 @@ export interface InstructionTemplateContext {
     subagent: boolean;
     /** Values for plain `{{name}}` placeholders. Unknown names are left as-is. */
     vars?: Record<string, string | number> | undefined;
+    /** Drop lines that format a declared but unavailable tool as callable. */
+    strictToolReferences?: boolean | undefined;
 }
 /**
  * Render an instruction markdown layer against the live request.

package/dist/core/next-steps-slot.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Turn-scoped slot for `<nextsteps>` suggestions produced by the `nextsteps`
+ * tool, plus the renderer that turns them back into the canonical XML block.
+ *
+ * ## Why a slot and not a direct channel to the UI
+ *
+ * Every suggestion surface — the TUI history renderer, the WebUI and SimpleUI
+ * chat stores, the CLI REPL suggestion store, and the session replay/rehydrate
+ * paths — reads `<nextsteps>` out of the assistant's *message text* via
+ * `parseNextSteps` in `@wrongstack/tools/next-steps`. Handing the tool its own
+ * transport would mean teaching all of them a second source of truth, and any
+ * one of them lagging behind would silently drop suggestions.
+ *
+ * Instead the tool parks its steps here, and `maybeAppendPendingNextSteps`
+ * appends the rendered block to the turn-ending provider response before that
+ * response is emitted, persisted, or folded into `finalText`. Downstream code
+ * cannot tell the difference between a block the model typed and one the tool
+ * produced, which is exactly the point.
+ *
+ * ## Why this module duplicates the tag knowledge
+ *
+ * `core` sits below `tools` in the package DAG (enforced by
+ * `package-boundaries.test.ts`), so it cannot import the parser. The overlap is
+ * deliberately kept to the tag name and the item line shape; the round-trip
+ * test in `tests/next-steps-slot.test.ts` feeds this renderer's output through
+ * the real parser so the two cannot drift apart unnoticed.
+ */
+import type { Response } from '../types/provider.js';
+import type { Context } from './context.js';
+/** A single suggestion parked by the `nextsteps` tool. */
+export interface PendingNextStep {
+    text: string;
+    /** Opt-in unattended execution. Honored only on the first item. */
+    auto?: boolean | undefined;
+}
+/**
+ * Upper bound on parked steps. The parser accepts up to 6, but the leader
+ * prompt's contract is 1–4, so the slot enforces the tighter number and the
+ * tool's schema mirrors it.
+ */
+export declare const MAX_PENDING_NEXT_STEPS = 4;
+/**
+ * Park the steps for this turn, replacing anything already there.
+ *
+ * Replace (rather than append) matches `todo`'s whole-list semantics: a second
+ * call in the same turn is the model changing its mind, not adding to a list.
+ */
+export declare function writePendingNextSteps(ctx: Pick<Context, 'meta'>, steps: readonly PendingNextStep[]): void;
+/** Read the parked steps, or undefined when the slot is empty or malformed. */
+export declare function readPendingNextSteps(ctx: Pick<Context, 'meta'>): PendingNextStep[] | undefined;
+/**
+ * Empty the slot. Called at the start of every `run()` so a block produced for
+ * one prompt can never attach itself to the answer for the next one, and again
+ * after a successful append so it cannot repeat within the same run.
+ */
+export declare function clearPendingNextSteps(ctx: Pick<Context, 'meta'>): void;
+/** True when the text already carries a `<nextsteps>` block the model wrote. */
+export declare function hasNextStepsTag(text: string): boolean;
+/**
+ * Render parked steps as the canonical block.
+ *
+ * The output must satisfy `parseNextSteps` exactly: an opening tag with no
+ * attributes, one `N. text` line per item, `auto="true"` only ever on item 1,
+ * and a balanced closing tag.
+ */
+export declare function renderNextStepsBlock(steps: readonly PendingNextStep[]): string;
+/**
+ * Append the parked `<nextsteps>` block to the turn-ending response.
+ *
+ * Returns `res` untouched unless every gate passes:
+ *
+ * - **leader only** — subagent output is parsed or rolled up by its parent, so
+ *   a suggestion block there is noise that leaks into specs and plans. Same
+ *   check as `buildLiveNextStepsGateBlock`.
+ * - **turn-ending stop reason** — mid-turn prose must not surface suggestions;
+ *   every surface gates on this already.
+ * - **not aborted** — an interrupted turn has no answer to follow up on.
+ * - **no open todos** — finishing tracked work outranks proposing new work.
+ *   Enforced here rather than per-surface so the gate has one home.
+ * - **no block already in the text** — if the model also typed one, its own
+ *   wording is the fresher intent and wins.
+ *
+ * The block is *appended* to the last text block, never prepended: the WebUI
+ * only accepts a canonical-response update when it extends the text it already
+ * streamed (`session-handlers.ts`), so a prefix would be silently dropped.
+ */
+export declare function maybeAppendPendingNextSteps(ctx: Pick<Context, 'meta' | 'agentId' | 'todos' | 'signal'>, res: Response): Response;
+//# sourceMappingURL=next-steps-slot.d.ts.map

package/dist/core/system-prompt-builder.d.ts

@@ -7,7 +7,7 @@ import type { BuildContext, ModelCapabilities, SystemPromptBuilder, SystemPrompt
 import type { SystemPromptContributor } from '../types/system-prompt-contributor.js';
 import { type InstructionBundle, type InstructionBundlePaths } from './instruction-bundle.js';
 import { type InstructionTemplateContext } from './instruction-template.js';
-export { effectiveShell, shellGuidanceBlock, type EffectiveShell } from './system-prompt-shell.js';
+export { type EffectiveShell, effectiveShell, shellGuidanceBlock } from './system-prompt-shell.js';
 export declare const LAYER_1_IDENTITY: string;
 /**
  * Compose the layer-1 identity from the bundled default plus any override.
@@ -45,8 +45,8 @@ export interface DefaultSystemPromptBuilderOptions {
     injectMemory?: boolean | undefined;
     skillLoader?: SkillLoader | undefined;
     /**
-     * How skill bodies reach the prompt. `'eager'` (default) injects every
-     * discovered skill body; `'progressive'` injects only a name+trigger manifest
+     * How skill bodies reach the prompt. `'progressive'` (runtime default)
+     * injects only a name+trigger manifest; `'eager'` injects discovered bodies
      * and relies on the agent calling the `skill` tool to load a body on demand
      * (the agentskills.io progressive-disclosure model).
      */
@@ -131,6 +131,8 @@ export declare class DefaultSystemPromptBuilder implements SystemPromptBuilder {
     private skillBodyCache?;
     /** Tools from last build — used for memory relevance scoring. */
     private _lastBuildTools?;
+    /** Full executable catalog used to capability-gate progressive skills. */
+    private _lastCatalogTools?;
     /** Cached rendered online agents string, keyed by content fingerprint. */
     private _lastOnlineAgents?;
     /** Cached full buildToolUsage output — keyed by tools array ref + agents fingerprint + tier. */

package/dist/core/system-prompt-memory-skills.d.ts

@@ -46,6 +46,7 @@ export interface MemorySkillsContext {
     skillEagerMaxChars: number | undefined;
     /** Tools from the last build — used for memory relevance scoring. */
     lastBuildTools: Tool[] | undefined;
+    catalogTools: Tool[] | undefined;
     skillBodyCache: string | undefined;
 }
 /**

package/dist/core/system-prompt-skill-bodies.d.ts

@@ -1,5 +1,5 @@
 import type { SkillLoader } from '../types/skill.js';
-export declare function buildProgressiveSkillManifestText(loader: SkillLoader): Promise<string>;
-export declare function buildFullSkillBodiesText(loader: SkillLoader, budget?: number): Promise<string>;
-export declare function buildCompactSkillBodiesText(loader: SkillLoader, budget?: number): Promise<string>;
+export declare function buildProgressiveSkillManifestText(loader: SkillLoader, availableToolNames?: readonly string[]): Promise<string>;
+export declare function buildFullSkillBodiesText(loader: SkillLoader, budget?: number, availableToolNames?: readonly string[]): Promise<string>;
+export declare function buildCompactSkillBodiesText(loader: SkillLoader, budget?: number, availableToolNames?: readonly string[]): Promise<string>;
 //# sourceMappingURL=system-prompt-skill-bodies.d.ts.map