@pikku/core 0.12.83 → 0.12.86

package/dist/wirings/{ai-scorer/ai-scorer-registry.js → agent-scorer/agent-scorer-registry.js}

@@ -1,5 +1,5 @@
 import { pikkuState } from '../../pikku-state.js';
-export const addAIScorer = (scorerName, scorer, packageName = null) => {
+export const addAgentScorer = (scorerName, scorer, packageName = null) => {
     const scorersMeta = pikkuState(packageName, 'agent', 'scorersMeta');
     if (!scorersMeta[scorerName]) {
         console.warn(`[pikku] Skipping AI scorer '${scorerName}' — metadata not found. Scorers must be declared in a *.scorer.ts file.`);
@@ -11,13 +11,13 @@ export const addAIScorer = (scorerName, scorer, packageName = null) => {
     }
     scorers.set(scorerName, scorer);
 };
-export const getAIScorers = () => pikkuState(null, 'agent', 'scorers');
-export const getAIScorersMeta = () => pikkuState(null, 'agent', 'scorersMeta');
+export const getAgentScorers = () => pikkuState(null, 'agent', 'scorers');
+export const getAgentScorersMeta = () => pikkuState(null, 'agent', 'scorersMeta');
 /**
  * Resolve a scorer by name across every registered package, the way an agent's
  * tools are resolved: a scorer declared in an addon is nameable by an app agent.
  */
-export const resolveAIScorer = (scorerName) => {
+export const resolveAgentScorer = (scorerName) => {
     const scorer = pikkuState(null, 'agent', 'scorers').get(scorerName);
     if (!scorer) {
         throw new Error(`AI scorer not found: ${scorerName}`);

package/dist/wirings/{ai-scorer/ai-scorer-snapshots.d.ts → agent-scorer/agent-scorer-snapshots.d.ts}

@@ -1,4 +1,4 @@
-import type { ScorerInput } from './ai-scorer.types.js';
+import type { ScorerInput } from './agent-scorer.types.js';
 /**
  * Start retaining snapshots. Called where the scenario grading RPC is
  * registered, so the buffer exists in exactly the processes that can read it —

package/dist/wirings/{ai-scorer/ai-scorer-worker.d.ts → agent-scorer/agent-scorer-worker.d.ts}

@@ -1,9 +1,9 @@
-import { type ScoreJob } from './ai-scorer.types.js';
+import { type ScoreJob } from './agent-scorer.types.js';
 /**
  * The one worker behind both lanes: it resolves the scorer by name and grades.
  * The lane a job arrived on decides nothing except how long it may take.
  */
-export declare function pikkuAIScoreWorkerFunc(_services: Record<string, unknown>, job: ScoreJob): Promise<void>;
+export declare function pikkuAgentScoreWorkerFunc(_services: Record<string, unknown>, job: ScoreJob): Promise<void>;
 /**
  * Bind the two lane queues to the shared worker.
  *
@@ -12,4 +12,4 @@ export declare function pikkuAIScoreWorkerFunc(_services: Record<string, unknown
  * for, so the metadata is synthesised here alongside the registration. This
  * mirrors how workflows wire their own queues.
  */
-export declare const wireAIScorerQueueWorkers: () => void;
+export declare const wireAgentScorerQueueWorkers: () => void;

package/dist/wirings/{ai-scorer/ai-scorer-worker.js → agent-scorer/agent-scorer-worker.js}

@@ -1,20 +1,20 @@
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction } from '../../function/function-runner.js';
 import { wireQueueWorker } from '../queue/queue-runner.js';
-import { gradeRun } from './ai-scorer-grade.js';
-import { SCORER_LANE_QUEUES } from './ai-scorer.types.js';
+import { gradeRun } from './agent-scorer-grade.js';
+import { SCORER_LANE_QUEUES } from './agent-scorer.types.js';
 /**
  * The one worker behind both lanes: it resolves the scorer by name and grades.
  * The lane a job arrived on decides nothing except how long it may take.
  */
-export async function pikkuAIScoreWorkerFunc(_services, job) {
+export async function pikkuAgentScoreWorkerFunc(_services, job) {
     const services = pikkuState(null, 'package', 'singletonServices');
     if (!services) {
         throw new Error(`Singleton services not initialized: cannot run the '${job.scorerName}' grade of run ${job.runId}`);
     }
     await gradeRun(job, services, { persist: true });
 }
-const SCORE_WORKER_FUNC_ID = 'pikkuAIScoreWorker';
+const SCORE_WORKER_FUNC_ID = 'pikkuAgentScoreWorker';
 /**
  * Bind the two lane queues to the shared worker.
  *
@@ -23,7 +23,7 @@ const SCORE_WORKER_FUNC_ID = 'pikkuAIScoreWorker';
  * for, so the metadata is synthesised here alongside the registration. This
  * mirrors how workflows wire their own queues.
  */
-export const wireAIScorerQueueWorkers = () => {
+export const wireAgentScorerQueueWorkers = () => {
     // No scorers means no lanes: a deployment that grades nothing should not be
     // left holding two queues nothing ever writes to.
     if (pikkuState(null, 'agent', 'scorers').size === 0)
@@ -32,7 +32,9 @@ export const wireAIScorerQueueWorkers = () => {
     const functionsMeta = pikkuState(null, 'function', 'meta');
     const queueMeta = pikkuState(null, 'queue', 'meta');
     if (!functions.has(SCORE_WORKER_FUNC_ID)) {
-        addFunction(SCORE_WORKER_FUNC_ID, { func: pikkuAIScoreWorkerFunc });
+        addFunction(SCORE_WORKER_FUNC_ID, {
+            func: pikkuAgentScoreWorkerFunc,
+        });
     }
     if (!functionsMeta[SCORE_WORKER_FUNC_ID]) {
         functionsMeta[SCORE_WORKER_FUNC_ID] = {
@@ -52,7 +54,7 @@ export const wireAIScorerQueueWorkers = () => {
         }
         wireQueueWorker({
             name: queueName,
-            func: { func: pikkuAIScoreWorkerFunc },
+            func: { func: pikkuAgentScoreWorkerFunc },
         });
     }
 };

package/dist/wirings/{ai-scorer/ai-scorer.d.ts → agent-scorer/agent-scorer.d.ts}

@@ -1,9 +1,9 @@
-import type { PikkuAIScorer, ScorerInput, ScorerOutput } from './ai-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.
  */
-export declare const pikkuAIScorer: <Services = any>(config: {
+export declare const pikkuAgentScorer: <Services = any>(config: {
     name: string;
     description: string;
     /** 0..1 fraction of live runs to grade. Defaults to all of them. */
@@ -14,16 +14,16 @@ export declare const pikkuAIScorer: <Services = any>(config: {
      */
     requiresReference?: boolean;
     score: (input: ScorerInput, services: Services) => ScorerOutput | Promise<ScorerOutput>;
-}) => PikkuAIScorer<Services>;
+}) => PikkuAgentScorer<Services>;
 /**
  * An LLM-judge scorer: the runtime makes the model call and forces a structured
  * `{ score, reason }`, so a judge is a rubric rather than a prompt to parse.
  *
- * The rubric field is `goal`, matching `pikkuAIAgent`'s prompt vocabulary — a
+ * The rubric field is `goal`, matching `pikkuAgent`'s prompt vocabulary — a
  * judge is a degenerate agent, and should use the same word for the same thing.
  * `prompt` is the escape hatch for non-standard framing.
  */
-export declare const pikkuAIJudge: <Services = any>(config: {
+export declare const pikkuAgentJudge: <Services = any>(config: {
     name: string;
     description: string;
     /** 0..1 fraction of live runs to grade. Defaults to all of them. */
@@ -35,5 +35,11 @@ export declare const pikkuAIJudge: <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;
-}) => PikkuAIScorer<Services>;
+}) => PikkuAgentScorer<Services>;

package/dist/wirings/{ai-scorer/ai-scorer.js → agent-scorer/agent-scorer.js}

@@ -10,7 +10,7 @@ const assertSampleRate = (name, sampleRate) => {
  * A heuristic scorer: pure code over the finished run, no model call, so it
  * grades on the fast lane.
  */
-export const pikkuAIScorer = (config) => ({
+export const pikkuAgentScorer = (config) => ({
     name: config.name,
     description: config.description,
     lane: 'fast',
@@ -22,11 +22,11 @@ export const pikkuAIScorer = (config) => ({
  * An LLM-judge scorer: the runtime makes the model call and forces a structured
  * `{ score, reason }`, so a judge is a rubric rather than a prompt to parse.
  *
- * The rubric field is `goal`, matching `pikkuAIAgent`'s prompt vocabulary — a
+ * The rubric field is `goal`, matching `pikkuAgent`'s prompt vocabulary — a
  * judge is a degenerate agent, and should use the same word for the same thing.
  * `prompt` is the escape hatch for non-standard framing.
  */
-export const pikkuAIJudge = (config) => ({
+export const pikkuAgentJudge = (config) => ({
     name: config.name,
     description: config.description,
     lane: 'slow',
@@ -35,6 +35,7 @@ export const pikkuAIJudge = (config) => ({
     judge: {
         model: config.model,
         goal: config.goal,
+        toolCalls: config.toolCalls ?? 'names',
         ...(config.prompt ? { prompt: config.prompt } : {}),
     },
 });

package/dist/wirings/{ai-scorer/ai-scorer.types.d.ts → agent-scorer/agent-scorer.types.d.ts}

@@ -44,16 +44,36 @@ export interface ScorerOutput {
 export type ScorerLane = 'fast' | 'slow';
 export declare const SCORER_LANE_QUEUES: Record<ScorerLane, string>;
 /**
- * A judge's model call. Present only on a scorer built with `pikkuAIJudge`;
- * `score` is present only on one built with `pikkuAIScorer`. Exactly one of the
+ * 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
  * two is set, which is what the two constructors exist to guarantee.
  */
 export type ScorerJudgeConfig = {
     model: string;
     goal: string;
+    /** Always set: `pikkuAgentJudge` resolves the default. */
+    toolCalls: JudgeToolCallDisclosure;
     prompt?: (input: ScorerInput) => string;
 };
-export type PikkuAIScorer<Services = any> = {
+export type PikkuAgentScorer<Services = any> = {
     name: string;
     description: string;
     lane: ScorerLane;
@@ -80,7 +100,7 @@ export type ScorerMeta = Record<string, {
 export type ScoreJob = ScorerInput & {
     scorerName: string;
 };
-export type AIRunScore = {
+export type AgentRunScore = {
     runId: string;
     scorerName: string;
     score: number;

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

@@ -0,0 +1,4 @@
+export const SCORER_LANE_QUEUES = {
+    fast: 'agent-score-fast',
+    slow: 'agent-score-slow',
+};

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

@@ -0,0 +1,6 @@
+export { pikkuAgentScorer, pikkuAgentJudge } from './agent-scorer.js';
+export { addAgentScorer, getAgentScorers, getAgentScorersMeta, } from './agent-scorer-registry.js';
+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, JudgeToolCallDisclosure, PikkuAgentScorer, ScoreJob, ScorerInput, ScorerJudgeConfig, ScorerLane, ScorerMeta, ScorerOutput, } from './agent-scorer.types.js';

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

@@ -0,0 +1,5 @@
+export { pikkuAgentScorer, pikkuAgentJudge } from './agent-scorer.js';
+export { addAgentScorer, getAgentScorers, getAgentScorersMeta, } from './agent-scorer-registry.js';
+export { gradeRun } from './agent-scorer-grade.js';
+export { enableScoreSnapshots, getScoreSnapshot, } from './agent-scorer-snapshots.js';
+export { wireAgentScorerQueueWorkers } from './agent-scorer-worker.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-rpc.types.d.ts

@@ -51,7 +51,7 @@ export declare class ChannelRPCError extends Error {
  * Whether a callable exposed to a remote decider needs a human to agree before
  * it runs, and how to describe the invocation while asking.
  *
- * Shared with `AIAgentToolDef`: both are an allowlist of named callables
+ * Shared with `AgentToolDef`: both are an allowlist of named callables
  * invoked by something other than the code that wrote them. The runtime around
  * them is not shared — an agent suspends and resumes, a reverse call is a live
  * await.
@@ -62,7 +62,7 @@ export interface ApprovalPolicy {
 }
 export type CapabilityHandler = (data: any) => Promise<unknown> | unknown;
 /**
- * `needsApproval` is required here on purpose. On `AIAgentToolDef` the same
+ * `needsApproval` is required here on purpose. On `AgentToolDef` the same
  * field is optional and absence means "do not ask"; here absence means the
  * opposite, so it must not be expressible — a bare function is the
  * unclassified form.

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)) {