@pikku/core 0.12.84 → 0.12.88

package/dist/wirings/agent/agent.types.d.ts

@@ -1,5 +1,7 @@
 import type { CorePermissionGroup, CorePikkuPermission } from '../../function/functions.types.js';
-import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata } from '../../middleware/middleware.types.js';
+import type { CoreSingletonServices } from '../../types/core.types.js';
+import type { PermissionMetadata } from '../../function/function-meta.types.js';
 import type { AIProviderOptions } from '../../services/agent-runner-service.js';
 import type { PikkuChannel } from '../channel/channel.types.js';
 import type { CorePikkuChannelMiddleware } from '../channel/channel.types.js';
@@ -168,8 +170,8 @@ export interface AgentToolDef extends Partial<ApprovalPolicy> {
      */
     forwardsApproval?: boolean;
 }
-export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown> = Record<string, unknown>, Services = any> {
-    modifyInput?: (services: Services, ctx: {
+export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown> = Record<string, unknown>, SingletonServices extends CoreSingletonServices = CoreSingletonServices> {
+    modifyInput?: (services: SingletonServices, ctx: {
         messages: AgentMessage[];
         instructions: string;
         /**
@@ -196,7 +198,7 @@ export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown>
         messages: AgentMessage[];
         instructions: string;
     };
-    modifyOutputStream?: (services: Services, ctx: {
+    modifyOutputStream?: (services: SingletonServices, ctx: {
         event: AgentStreamEvent;
         allEvents: readonly AgentStreamEvent[];
         /** Private to this middleware, for this run. Cross-middleware facts go in `shared`. */
@@ -240,7 +242,7 @@ export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown>
      * and handed to anything that grades the run, and scrubbing the reply alone
      * leaves them untouched.
      */
-    modifyOutput?: (services: Services, ctx: {
+    modifyOutput?: (services: SingletonServices, ctx: {
         text: string;
         messages: AgentMessage[];
         usage: {
@@ -257,7 +259,7 @@ export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown>
         messages: AgentMessage[];
         toolCalls?: NonNullable<AgentStep['toolCalls']>;
     };
-    beforeToolCall?: (services: Services, ctx: {
+    beforeToolCall?: (services: SingletonServices, ctx: {
         toolName: string;
         toolCallId: string;
         args: Record<string, unknown>;
@@ -266,7 +268,7 @@ export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown>
     } | void> | {
         args: Record<string, unknown>;
     } | void;
-    afterToolCall?: (services: Services, ctx: {
+    afterToolCall?: (services: SingletonServices, ctx: {
         toolName: string;
         toolCallId: string;
         args: Record<string, unknown>;
@@ -277,7 +279,7 @@ export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown>
     } | void> | {
         result: unknown;
     } | void;
-    afterStep?: (services: Services, ctx: {
+    afterStep?: (services: SingletonServices, ctx: {
         stepNumber: number;
         text: string;
         toolCalls: {
@@ -298,7 +300,7 @@ export interface PikkuAgentMiddlewareHooks<State extends Record<string, unknown>
         };
         finishReason: string;
     }) => Promise<void> | void;
-    onError?: (services: Services, ctx: {
+    onError?: (services: SingletonServices, ctx: {
         error: Error;
         stepNumber: number;
         messages: AgentMessage[];
@@ -389,7 +391,7 @@ export type CoreAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMidd
      * which OR together, a scope can only narrow access.
      *
      * Narrowed to the generated `ScopeId` union in a project's own
-     * `pikku-types.gen.ts`, so an undeclared scope is a compile error.
+     * `#pikku/scopes`, so an undeclared scope is a compile error.
      */
     scopes?: Scope[];
     permissions?: CorePermissionGroup<PikkuPermission>;

package/dist/wirings/agent/index.d.ts

@@ -4,7 +4,7 @@ export { runAgent, resumeAgentSync } from './agent-runner.js';
 export { resolveModelAlias } from './agent-model-config.js';
 export { streamAgent, resumeAgent, interruptAgent } from './agent-stream.js';
 export { voiceInput, NoSpeechDetectedError, SPOKEN_TURN, SPOKEN_TRANSCRIPT, } from './voice-input.js';
-export { voiceOutput, unspeakableScripts, voiceForText, type SpeakableScripts, } from './voice-output.js';
+export { voiceOutput, unspeakableScripts, voiceForText, type SpeakableScripts, type VoiceOutputState, } from './voice-output.js';
 export { AgentInterruptedError, signalRunInterrupt } from './agent-interrupt.js';
 export type { AgentInterruption, AgentInterruptResult, InterruptibleRunHandle, } from './agent-interrupt.js';
 export { type RunAgentParams, type StreamAgentOptions, ToolApprovalRequired, ToolCredentialRequired, canAccessThread, isOwnedByPrincipal, threadOwnerConstraint, } from './agent-prepare.js';

package/dist/wirings/agent/voice-input.js

@@ -1,4 +1,4 @@
-import { pikkuAgentMiddleware } from '../../types/core.types.js';
+import { pikkuAgentMiddleware } from '../../middleware/middleware-factories.js';
 import { safeFetch } from '../../utils/safe-fetch.js';
 function base64ToUint8Array(base64) {
     const binary = atob(base64);

package/dist/wirings/agent/voice-output.js

@@ -1,4 +1,4 @@
-import { pikkuAgentMiddleware } from '../../types/core.types.js';
+import { pikkuAgentMiddleware } from '../../middleware/middleware-factories.js';
 import { SPOKEN_TURN } from './voice-input.js';
 function bufferToBase64(data) {
     let binary = '';

package/dist/wirings/agent-scorer/agent-scorer-judge.d.ts

@@ -5,6 +5,19 @@ import type { PikkuAgentScorer, ScorerInput, ScorerJudgeConfig, ScorerOutput } f
  *
  * A reference-based judge is shown the answer key; a reference-free one is not,
  * and grades the answer on its own merits.
+ *
+ * The tool calls are shown because without them a judge cannot tell a fact from
+ * a fabrication. Grading a todo agent that had just listed the user's todos
+ * correctly, a judge given only the answer called it "a plausible-looking list"
+ * that "offers no real access to your actual list, making it effectively a
+ * guess", and scored 0.2 what it scored 1 on other runs — right by its rubric,
+ * on the evidence it was given, and wrong about the run. An agent that answers
+ * from a tool and one that invents the same sentence are indistinguishable in
+ * the output alone; they differ only in what the run did to get there.
+ *
+ * How much of that to show is `judge.toolCalls`, and the default stops at the
+ * names: the 0.2 was the judge doubting the run had any access, and a name
+ * settles that without handing a third-party model the rows.
  */
 export declare const buildJudgePrompt: (judge: ScorerJudgeConfig, input: ScorerInput) => string;
 /**

package/dist/wirings/agent-scorer/agent-scorer-judge.js

@@ -16,11 +16,59 @@ const JUDGE_OUTPUT_SCHEMA = {
     required: ['score', 'reason'],
     additionalProperties: false,
 };
+/**
+ * The default disclosure: which tools ran and which failed, and nothing about
+ * what went in or came back. A judge that can see a run reached `listTodos`
+ * can tell a retrieved list from an invented one, which is the whole of what
+ * the trajectory is needed for — the rows themselves it does not need, and an
+ * error string is a tool's own words about the caller's data, so it is
+ * summarised rather than quoted.
+ */
+const describeToolCallName = (call) => `- ${call.name}${call.error ? ' (failed)' : ''}`;
+/** Everything about a call, for a judge that grades against what came back. */
+const describeToolCall = (call) => {
+    const outcome = call.error
+        ? `failed: ${call.error}`
+        : `returned ${formatToolValue(call.result)}`;
+    return `- ${call.name}(${formatToolValue(call.args)}) ${outcome}`;
+};
+/**
+ * A tool's arguments and result are arbitrary JSON, and some of it is large —
+ * a listing, a document, a page of search results. Truncating keeps a single
+ * fat call from crowding the answer out of the judge's context; what survives
+ * is the head, which is where the shape of a value is.
+ */
+const TOOL_VALUE_LIMIT = 500;
+const formatToolValue = (value) => {
+    if (value === undefined) {
+        return 'nothing';
+    }
+    const text = typeof value === 'string' ? value : JSON.stringify(value);
+    if (text === undefined) {
+        return 'nothing';
+    }
+    return text.length > TOOL_VALUE_LIMIT
+        ? `${text.slice(0, TOOL_VALUE_LIMIT)}… (truncated)`
+        : text;
+};
 /**
  * The message a judge grades when its scorer supplies no `prompt`.
  *
  * A reference-based judge is shown the answer key; a reference-free one is not,
  * and grades the answer on its own merits.
+ *
+ * The tool calls are shown because without them a judge cannot tell a fact from
+ * a fabrication. Grading a todo agent that had just listed the user's todos
+ * correctly, a judge given only the answer called it "a plausible-looking list"
+ * that "offers no real access to your actual list, making it effectively a
+ * guess", and scored 0.2 what it scored 1 on other runs — right by its rubric,
+ * on the evidence it was given, and wrong about the run. An agent that answers
+ * from a tool and one that invents the same sentence are indistinguishable in
+ * the output alone; they differ only in what the run did to get there.
+ *
+ * How much of that to show is `judge.toolCalls`, and the default stops at the
+ * names: the 0.2 was the judge doubting the run had any access, and a name
+ * settles that without handing a third-party model the rows.
  */
 export const buildJudgePrompt = (judge, input) => {
     if (judge.prompt)
@@ -30,6 +78,10 @@ export const buildJudgePrompt = (judge, input) => {
         sections.push(`Reference answer:\n${input.reference}`);
     }
     sections.push(`Assistant answered:\n${input.output}`);
+    if (judge.toolCalls !== 'off' && input.toolCalls.length > 0) {
+        const describe = judge.toolCalls === 'full' ? describeToolCall : describeToolCallName;
+        sections.push(`Tools the assistant ran:\n${input.toolCalls.map(describe).join('\n')}`);
+    }
     sections.push(judge.goal);
     sections.push('Respond with a score 0..1 and a brief reason.');
     return sections.join('\n\n');

package/dist/wirings/agent-scorer/agent-scorer.d.ts

@@ -1,4 +1,4 @@
-import type { PikkuAgentScorer, ScorerInput, ScorerOutput } from './agent-scorer.types.js';
+import type { JudgeToolCallDisclosure, PikkuAgentScorer, ScorerInput, ScorerOutput } from './agent-scorer.types.js';
 /**
  * A heuristic scorer: pure code over the finished run, no model call, so it
  * grades on the fast lane.
@@ -35,5 +35,11 @@ export declare const pikkuAgentJudge: <Services = any>(config: {
     requiresReference?: boolean;
     model: string;
     goal: string;
+    /**
+     * How much of the run's trajectory to disclose to the judge. Defaults to
+     * `names`: enough to tell a tool-backed answer from an invented one, without
+     * sending a third-party model the rows the tools returned.
+     */
+    toolCalls?: JudgeToolCallDisclosure;
     prompt?: (input: ScorerInput) => string;
 }) => PikkuAgentScorer<Services>;

package/dist/wirings/agent-scorer/agent-scorer.js

@@ -35,6 +35,7 @@ export const pikkuAgentJudge = (config) => ({
     judge: {
         model: config.model,
         goal: config.goal,
+        toolCalls: config.toolCalls ?? 'names',
         ...(config.prompt ? { prompt: config.prompt } : {}),
     },
 });

package/dist/wirings/agent-scorer/agent-scorer.types.d.ts

@@ -43,6 +43,24 @@ export interface ScorerOutput {
  */
 export type ScorerLane = 'fast' | 'slow';
 export declare const SCORER_LANE_QUEUES: Record<ScorerLane, string>;
+/**
+ * How much of the run's trajectory the default judge prompt discloses.
+ *
+ * A judge is a third-party model, and a tool's arguments and results are the
+ * most sensitive thing a run touches — the row it read, the address it looked
+ * up, the message it sent. Output middleware has already had its pass by the
+ * time a scorer sees any of this, so what a judge is shown is what was stored;
+ * this is the second gate, for a judge that should be told less than the
+ * database was.
+ *
+ * - `names` — which tools ran, and whether each failed. No arguments, no
+ *   results. Enough to tell an answer backed by a tool from an invented one,
+ *   which is the failure this exists to catch, while disclosing no row data.
+ * - `full` — names, arguments and results, truncated. For a judge that must
+ *   check the answer *against* what the tool returned.
+ * - `off` — no trajectory at all. The judge grades the answer alone.
+ */
+export type JudgeToolCallDisclosure = 'off' | 'names' | 'full';
 /**
  * A judge's model call. Present only on a scorer built with `pikkuAgentJudge`;
  * `score` is present only on one built with `pikkuAgentScorer`. Exactly one of the
@@ -51,6 +69,8 @@ export declare const SCORER_LANE_QUEUES: Record<ScorerLane, string>;
 export type ScorerJudgeConfig = {
     model: string;
     goal: string;
+    /** Always set: `pikkuAgentJudge` resolves the default. */
+    toolCalls: JudgeToolCallDisclosure;
     prompt?: (input: ScorerInput) => string;
 };
 export type PikkuAgentScorer<Services = any> = {

package/dist/wirings/agent-scorer/index.d.ts

@@ -3,4 +3,4 @@ export { addAgentScorer, getAgentScorers, getAgentScorersMeta, } from './agent-s
 export { gradeRun } from './agent-scorer-grade.js';
 export { enableScoreSnapshots, getScoreSnapshot, } from './agent-scorer-snapshots.js';
 export { wireAgentScorerQueueWorkers } from './agent-scorer-worker.js';
-export type { AgentRunScore, PikkuAgentScorer, ScoreJob, ScorerInput, ScorerJudgeConfig, ScorerLane, ScorerMeta, ScorerOutput, } from './agent-scorer.types.js';
+export type { AgentRunScore, JudgeToolCallDisclosure, PikkuAgentScorer, ScoreJob, ScorerInput, ScorerJudgeConfig, ScorerLane, ScorerMeta, ScorerOutput, } from './agent-scorer.types.js';

package/dist/wirings/channel/channel-common.d.ts

@@ -1,4 +1,5 @@
-import type { CoreSingletonServices, MiddlewareMetadata } from '../../types/core.types.js';
+import type { CoreSingletonServices } from '../../types/core.types.js';
+import type { MiddlewareMetadata } from '../../middleware/middleware.types.js';
 import type { CoreChannel, ChannelMessageMeta } from './channel.types.js';
 import { type PikkuSessionService } from '../../services/user-session-service.js';
 export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, userSession, }: {

package/dist/wirings/channel/channel-middleware-runner.d.ts

@@ -1,4 +1,5 @@
-import type { CoreSingletonServices, MiddlewareMetadata, PikkuRawWire } from '../../types/core.types.js';
+import type { CoreSingletonServices, PikkuRawWire } from '../../types/core.types.js';
+import type { MiddlewareMetadata } from '../../middleware/middleware.types.js';
 import type { CorePikkuChannelMiddleware } from './channel.types.js';
 export declare const addChannelMiddleware: (tag: string, middleware: CorePikkuChannelMiddleware[], packageName?: string | null) => CorePikkuChannelMiddleware[];
 export declare const clearChannelMiddlewareCache: () => void;

package/dist/wirings/channel/channel.types.d.ts

@@ -1,5 +1,5 @@
 import type { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import type { CorePikkuMiddleware, MiddlewareMetadata } from '../../types/core.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata } from '../../middleware/middleware.types.js';
 export type BinaryData = ArrayBuffer | Uint8Array;
 export type CorePikkuChannelMiddleware<Services = any, Event = unknown> = (services: Services, event: Event, next: (event: Event | Event[] | null) => Promise<void> | void) => Promise<void> | void;
 export type CorePikkuChannelMiddlewareFactory<In = any, Services = any, Event = unknown> = (input: In) => CorePikkuChannelMiddleware<Services, Event>;

package/dist/wirings/channel/serverless/index.d.ts

@@ -1 +1,2 @@
 export { runChannelConnect, runChannelDisconnect, runChannelMessage, } from './serverless-channel-runner.js';
+export type { RunServerlessChannelParams } from './serverless-channel-runner.js';

package/dist/wirings/cli/channel/index.d.ts

@@ -2,5 +2,5 @@ export { executeCLIViaChannel } from './cli-channel-runner.js';
 export { handleRawCLI } from './cli-raw-channel-runner.js';
 export type { RawCLIFrame, RawCLIResult } from './cli-raw-channel-runner.js';
 export { executeRawCLIViaChannel } from './cli-raw-client-runner.js';
-export type { CorePikkuCLIClientRender, } from './cli-raw-client-runner.js';
+export type { CorePikkuCLIClientRender } from './cli-raw-client-runner.js';
 export type { ApprovalMode } from './cli-approval.js';

package/dist/wirings/cli/cli-runner.d.ts

@@ -1,4 +1,5 @@
-import type { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js';
+import type { CoreUserSession } from '../../types/core.types.js';
+import type { CorePikkuMiddleware } from '../../middleware/middleware.types.js';
 import type { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from './cli.types.js';
 import type { CoreSingletonServices, CoreServices, CreateWireServices, CreateConfig, CreateSingletonServices } from '../../types/core.types.js';
 import type { PikkuChannel } from '../channel/channel.types.js';

package/dist/wirings/cli/cli-runner.js

@@ -303,8 +303,11 @@ export async function executeCLI({ programName, args, createConfig, createSingle
             }
         }
         const data = { ...parsed.positionals, ...parsed.options };
+        // The command path is passed through so a config factory can tell which
+        // command is about to run. Some commands are meant to work outside a
+        // project, and cannot be gated behind loading that project's config.
         const config = createConfig
-            ? await createConfig(new LocalVariablesService(), data)
+            ? await createConfig(new LocalVariablesService(), data, parsed.commandPath)
             : {};
         const singletonServices = await createSingletonServices(config);
         pikkuState(null, 'package', 'singletonServices', singletonServices);

package/dist/wirings/cli/cli.types.d.ts

@@ -1,15 +1,27 @@
-import type { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata } from '../../types/core.types.js';
+import type { CoreSingletonServices, CoreUserSession, CoreServices } from '../../types/core.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata } from '../../middleware/middleware.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import type { ChannelRemote, PikkuChannel } from '../channel/channel.types.js';
+/**
+ * The shape an option's value is parsed into. `'string[]'` splits a single
+ * value on commas; `'boolean'` is a flag that consumes the next token only
+ * when it is an explicit literal (`true`/`false`/`1`/`0`/`yes`/`no`); every
+ * other type consumes one token verbatim, so a value may start with `-`. Left
+ * unset — which is the usual case — it is read from the command function's
+ * input schema, then from `default`, and otherwise falls back to `'string'`.
+ * Declare it only where neither can say: an option belonging to no function
+ * input, such as one the config factory reads straight off the CLI data.
+ */
+export type CLIOptionType = 'string' | 'number' | 'boolean' | 'string[]';
 /**
  * CLI option definition
  */
 export interface CLIOption<T = any> {
     description: string;
     short?: string;
+    type?: CLIOptionType;
     default?: T;
     choices?: T[];
-    array?: boolean;
     required?: boolean;
 }
 /**
@@ -149,7 +161,14 @@ export type CoreCLICommandConfig<FuncConfig, PikkuMiddleware extends CorePikkuMi
         [K in keyof ExtractFunctionInput<FuncConfig>]?: {
             description?: string;
             short?: string;
+            type?: CLIOptionType;
             default?: ExtractFunctionInput<FuncConfig>[K];
+            /**
+             * The values this option accepts. Rejected by the parser and listed in
+             * `--help`, so a flag with a fixed vocabulary says so once rather than
+             * repeating itself in its description.
+             */
+            choices?: ReadonlyArray<ExtractFunctionInput<FuncConfig>[K]>;
         };
     };
     middleware?: PikkuMiddleware[];

package/dist/wirings/cli/command-parser.js

@@ -1,3 +1,4 @@
+import { pikkuState } from '../../pikku-state.js';
 /** "from-plan" → "fromPlan"; the parser accepts either spelling. */
 function toCamelCase(str) {
     return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
@@ -57,6 +58,114 @@ function warnUnknownOption(typed, availableOptions, result) {
  * one error per character.
  */
 const MAX_SHORT_FLAG_CLUSTER = 64;
+function resolveOptionType(optionDef) {
+    if (optionDef.type) {
+        return optionDef.type;
+    }
+    if (typeof optionDef.default === 'boolean') {
+        return 'boolean';
+    }
+    if (typeof optionDef.default === 'number') {
+        return 'number';
+    }
+    return 'string';
+}
+/**
+ * A command's options are keys of its function's input, so the input schema
+ * already records what each one is. Reading it here means a declaration never
+ * has to repeat — or contradict — the type the function is validated against.
+ * An explicit `type` still wins, and an option the schema says nothing about
+ * (a program-level option belonging to no function input) is left untouched.
+ */
+function applySchemaOptionTypes(options, commandMeta) {
+    const properties = commandInputProperties(commandMeta);
+    if (!properties) {
+        return options;
+    }
+    const typed = { ...options };
+    for (const [name, option] of Object.entries(typed)) {
+        if (option.type) {
+            continue;
+        }
+        const schemaType = optionTypeFromSchema(properties[name]);
+        if (schemaType) {
+            typed[name] = { ...option, type: schemaType };
+        }
+    }
+    return typed;
+}
+function commandInputProperties(commandMeta) {
+    const funcMeta = pikkuState(null, 'function', 'meta')[commandMeta.pikkuFuncId];
+    const schemaName = funcMeta?.inputSchemaName;
+    if (!schemaName) {
+        return null;
+    }
+    const schema = pikkuState(funcMeta.packageName ?? null, 'misc', 'schemas').get(schemaName);
+    const properties = schema?.properties;
+    return properties && typeof properties === 'object' ? properties : null;
+}
+function optionTypeFromSchema(property) {
+    if (!property || typeof property !== 'object') {
+        return undefined;
+    }
+    // An optional field can arrive as a union with null, which is not a shape the
+    // parser can read a value into.
+    const declared = Array.isArray(property.type)
+        ? property.type.filter((entry) => entry !== 'null')[0]
+        : property.type;
+    switch (declared) {
+        case 'array':
+            return 'string[]';
+        case 'number':
+        case 'integer':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return 'string';
+        default:
+            return undefined;
+    }
+}
+const BOOLEAN_LITERALS = new Map([
+    ['true', true],
+    ['false', false],
+    ['1', true],
+    ['0', false],
+    ['yes', true],
+    ['no', false],
+]);
+/**
+ * A boolean option is a flag, but `--watch false` is how scripts and CI turn a
+ * default-on flag off, so an explicit literal directly after the flag is taken
+ * as its value rather than left behind as a positional.
+ */
+function readBooleanLiteral(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    return BOOLEAN_LITERALS.get(raw.toLowerCase());
+}
+function readOptionValue(raw, optionDef) {
+    if (resolveOptionType(optionDef) !== 'string[]') {
+        return parseOptionValue(raw, optionDef);
+    }
+    return raw
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0)
+        .map((item) => parseOptionValue(item, optionDef));
+}
+/** A repeated array option accumulates rather than replacing. */
+function assignOptionValue(optionArgs, key, value) {
+    const existing = optionArgs[key];
+    if (Array.isArray(existing) && Array.isArray(value)) {
+        optionArgs[key] = [...existing, ...value];
+    }
+    else {
+        optionArgs[key] = value;
+    }
+}
 export function parseCLIArguments(args, programName, allMeta) {
     const result = {
         program: programName,
@@ -131,7 +240,7 @@ export function parseCLIArguments(args, programName, allMeta) {
         result.errors.push(`Missing subcommand: ${result.commandPath.join(' ')}`);
         return result;
     }
-    const availableOptions = collectAvailableOptions(meta, result.commandPath);
+    const availableOptions = applySchemaOptionTypes(collectAvailableOptions(meta, result.commandPath), commandMeta);
     const positionalArgs = [];
     const optionArgs = {};
     while (currentIndex < args.length) {
@@ -142,8 +251,9 @@ export function parseCLIArguments(args, programName, allMeta) {
                 : undefined;
             const equalIndex = arg.indexOf('=');
             if (negatedKey &&
-                typeof availableOptions[negatedKey]?.default === 'boolean') {
-                // Requiring a boolean default keeps a literal `--no-something` option
+                availableOptions[negatedKey] &&
+                resolveOptionType(availableOptions[negatedKey]) === 'boolean') {
+                // Requiring a boolean type keeps a literal `--no-something` option
                 // name parsing as itself rather than as a negation.
                 optionArgs[negatedKey] = false;
             }
@@ -154,7 +264,12 @@ export function parseCLIArguments(args, programName, allMeta) {
                     warnUnknownOption(arg.slice(2, equalIndex), availableOptions, result);
                 }
                 const value = arg.slice(equalIndex + 1);
-                optionArgs[key] = parseOptionValue(value, optionDef);
+                if (optionDef) {
+                    assignOptionValue(optionArgs, key, readOptionValue(value, optionDef));
+                }
+                else {
+                    optionArgs[key] = parseOptionValue(value, optionDef);
+                }
             }
             else {
                 const key = toCamelCase(arg.slice(2));
@@ -162,21 +277,31 @@ export function parseCLIArguments(args, programName, allMeta) {
                 if (!optionDef) {
                     warnUnknownOption(arg.slice(2), availableOptions, result);
                 }
-                if (optionDef && optionDef.array) {
-                    currentIndex++;
-                    const values = [];
-                    while (currentIndex < args.length &&
-                        !args[currentIndex].startsWith('-')) {
-                        values.push(parseOptionValue(args[currentIndex], optionDef));
+                if (!optionDef) {
+                    // With no spec there is nothing to consult, so the lookahead
+                    // heuristic is all that is left.
+                    if (currentIndex + 1 < args.length &&
+                        !args[currentIndex + 1].startsWith('-')) {
                         currentIndex++;
+                        optionArgs[key] = parseOptionValue(args[currentIndex], optionDef);
+                    }
+                    else {
+                        optionArgs[key] = true;
                     }
-                    currentIndex--; // Back up one since we'll increment at loop end
-                    optionArgs[key] = values;
                 }
-                else if (currentIndex + 1 < args.length &&
-                    !args[currentIndex + 1].startsWith('-')) {
+                else if (resolveOptionType(optionDef) === 'boolean') {
+                    const literal = readBooleanLiteral(args[currentIndex + 1]);
+                    if (literal === undefined) {
+                        optionArgs[key] = true;
+                    }
+                    else {
+                        currentIndex++;
+                        optionArgs[key] = literal;
+                    }
+                }
+                else if (currentIndex + 1 < args.length) {
                     currentIndex++;
-                    optionArgs[key] = parseOptionValue(args[currentIndex], optionDef);
+                    assignOptionValue(optionArgs, key, readOptionValue(args[currentIndex], optionDef));
                 }
                 else {
                     optionArgs[key] = true;
@@ -193,12 +318,21 @@ export function parseCLIArguments(args, programName, allMeta) {
                 const shortFlag = arg[i];
                 const longOption = findLongOption(shortFlag, availableOptions);
                 if (longOption) {
+                    const optionDef = availableOptions[longOption];
                     // Only the last flag in a cluster can take a value.
-                    if (i === arg.length - 1 &&
-                        currentIndex + 1 < args.length &&
-                        !args[currentIndex + 1].startsWith('-')) {
+                    const isLast = i === arg.length - 1;
+                    const literal = isLast && resolveOptionType(optionDef) === 'boolean'
+                        ? readBooleanLiteral(args[currentIndex + 1])
+                        : undefined;
+                    if (literal !== undefined) {
+                        currentIndex++;
+                        optionArgs[longOption] = literal;
+                    }
+                    else if (isLast &&
+                        resolveOptionType(optionDef) !== 'boolean' &&
+                        currentIndex + 1 < args.length) {
                         currentIndex++;
-                        optionArgs[longOption] = parseOptionValue(args[currentIndex], availableOptions[longOption]);
+                        assignOptionValue(optionArgs, longOption, readOptionValue(args[currentIndex], optionDef));
                     }
                     else {
                         optionArgs[longOption] = true;
@@ -272,11 +406,11 @@ function parseOptionValue(value, optionDef) {
             return parseFloat(value);
         return value;
     }
-    const defaultValue = optionDef.default;
-    if (typeof defaultValue === 'boolean') {
-        return value === 'true' || value === '1' || value === 'yes';
+    const optionType = resolveOptionType(optionDef);
+    if (optionType === 'boolean') {
+        return readBooleanLiteral(value) ?? false;
     }
-    if (typeof defaultValue === 'number') {
+    if (optionType === 'number') {
         return parseFloat(value);
     }
     if (optionDef.choices && !optionDef.choices.includes(value)) {

package/dist/wirings/gateway/gateway.types.d.ts

@@ -1,4 +1,5 @@
-import type { CommonWireMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, CoreSingletonServices } from '../../types/core.types.js';
+import type { CommonWireMeta, CoreSingletonServices } from '../../types/core.types.js';
+import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../middleware/middleware.types.js';
 import type { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 import type { PikkuHTTPRequest } from '../http/http.types.js';
 export interface GatewayAttachment {

package/dist/wirings/http/http-runner.d.ts

@@ -1,6 +1,6 @@
 import type { CoreHTTPFunctionWiring, RunHTTPWiringOptions, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
 import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
-import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
+import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../middleware/middleware.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
 export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction extends CorePikkuFunction<In, Out> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out> = CorePikkuFunctionSessionless<In, Out>, PikkuPermissionGroup extends CorePikkuPermission<In> = CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, PikkuMiddleware>) => void;

package/dist/wirings/http/http-runner.js

@@ -42,7 +42,7 @@ export const wireHTTP = (httpWiring) => {
         return;
     }
     if (httpWiring.func) {
-        addFunction(routeMeta.pikkuFuncId, httpWiring.func);
+        addFunction(routeMeta.pikkuFuncId, httpWiring.func, routeMeta.packageName ?? null);
     }
     const routes = pikkuState(null, 'http', 'routes');
     if (!routes.has(httpWiring.method)) {