@moxxy/cli 0.8.0 → 0.8.2

package/dist/bin.js

@@ -194,6 +194,14 @@ var init_log = __esm({
       listeners = /* @__PURE__ */ new Set();
       clearListeners = /* @__PURE__ */ new Set();
       now;
+      /**
+       * Seq of the FIRST event this log holds. 0 for an authoring log; a mirror
+       * primed by a partial attach replay (runner protocol v6 `replay.start`)
+       * rebases to the first replayed seq so `ingest`'s contiguity gate lines up
+       * with the runner's stream instead of expecting history we never received.
+       * `seq === base + index` for every held event.
+       */
+      base = 0;
       constructor(seed = [], opts = {}) {
         this.now = opts.now ?? Date.now;
         for (const e3 of seed)
@@ -202,13 +210,18 @@ var init_log = __esm({
       get length() {
         return this.events.length;
       }
+      /** Seq of the first held event (see {@link rebase}). */
+      get baseSeq() {
+        return this.base;
+      }
       at(seq) {
-        if (seq < 0 || seq >= this.events.length)
+        const index = seq - this.base;
+        if (index < 0 || index >= this.events.length)
           return void 0;
-        return this.events[seq];
+        return this.events[index];
       }
-      slice(from = 0, to = this.events.length) {
-        return this.events.slice(from, to);
+      slice(from = 0, to = this.base + this.events.length) {
+        return this.events.slice(Math.max(0, from - this.base), Math.max(0, to - this.base));
       }
       ofType(type) {
         return this.events.filter((e3) => e3.type === type);
@@ -220,7 +233,7 @@ var init_log = __esm({
         return [...this.events];
       }
       async append(partial) {
-        const event = materializeEvent(partial, this.events.length, this.now);
+        const event = materializeEvent(partial, this.base + this.events.length, this.now);
         this.events.push(event);
         const snapshot = [...this.listeners];
         for (const fn of snapshot) {
@@ -245,7 +258,7 @@ var init_log = __esm({
        * Not for normal authoring; use {@link append} for that.
        */
       ingest(event) {
-        if (event.seq !== this.events.length)
+        if (event.seq !== this.base + this.events.length)
           return;
         this.events.push(event);
         const snapshot = [...this.listeners];
@@ -271,8 +284,25 @@ var init_log = __esm({
        * Safe to call only when no turn is in flight — callers should abort
        * their AbortController and await any pending runTurn() first.
        */
+      /**
+       * Start this (empty) log at `seq` instead of 0. A mirror primed by a
+       * PARTIAL attach replay (`replay: 'none'` / `{ tail }`) calls this with the
+       * runner's announced first seq so {@link ingest}'s contiguity gate accepts
+       * the stream. Only valid while empty — rebasing held events would detach
+       * their seqs from their indices.
+       */
+      rebase(seq) {
+        if (this.events.length > 0) {
+          throw new Error(`EventLog.rebase(${seq}): log already holds ${this.events.length} events`);
+        }
+        if (!Number.isInteger(seq) || seq < 0) {
+          throw new Error(`EventLog.rebase(${seq}): seq must be a non-negative integer`);
+        }
+        this.base = seq;
+      }
       clear() {
         this.events.length = 0;
+        this.base = 0;
         const snapshot = [...this.clearListeners];
         for (const fn of snapshot) {
           try {
@@ -466,9 +496,10 @@ async function runChildTurn(args) {
     return resolved.failure;
   const { strategy, strategyName } = resolved;
   const toolRegistry = spec.allowedTools && spec.allowedTools.length > 0 ? buildFilteredToolRegistry(parentSession.tools, new Set(spec.allowedTools)) : parentSession.tools;
+  const childModel = await resolveChildModel(rt3, spec, label3, childSessionId);
   const childLog = new EventLog();
-  const spawner = createSubagentSpawner(rt3);
-  const childCtx = buildChildContext(rt3, spec, childSessionId, childTurnId, toolRegistry, childLog, spawner);
+  const spawner = createSubagentSpawner({ ...rt3, parentModel: childModel });
+  const childCtx = buildChildContext(rt3, spec, childModel, childSessionId, childTurnId, toolRegistry, childLog, spawner);
   const capture = await executeChildLoop({
     rt: rt3,
     spec,
@@ -600,12 +631,24 @@ async function resolveStrategy(parentSession, parentTurnId, label3, childSession
     }
   };
 }
-function buildChildContext(rt3, spec, childSessionId, childTurnId, toolRegistry, childLog, spawner) {
-  const { parentSession, parentSignal, parentModel } = rt3;
+async function resolveChildModel(rt3, spec, label3, childSessionId) {
+  const { parentSession, parentTurnId, parentModel } = rt3;
+  const requested = spec.model;
+  if (requested === void 0 || requested === parentModel)
+    return parentModel;
+  const models = parentSession.providers.getActive().models;
+  if (models.length > 0 && !models.some((m3) => m3.id === requested)) {
+    await emitSubagentWarning(parentSession, parentTurnId, label3, childSessionId, `unknown model "${requested}" \u2014 falling back to parent model "${parentModel}"`);
+    return parentModel;
+  }
+  return requested;
+}
+function buildChildContext(rt3, spec, model, childSessionId, childTurnId, toolRegistry, childLog, spawner) {
+  const { parentSession, parentSignal } = rt3;
   return {
     sessionId: childSessionId,
     turnId: childTurnId,
-    model: spec.model ?? parentModel,
+    model,
     ...spec.systemPrompt !== void 0 ? { systemPrompt: spec.systemPrompt } : {},
     provider: parentSession.providers.getActive(),
     tools: toolRegistry,
@@ -674,6 +717,7 @@ async function* runTurn(session, prompt, opts = {}) {
   const turnId = opts.turnId ?? session.startTurn().turnId;
   const provider = session.providers.getActive();
   const model = opts.model ?? provider.models[0]?.id ?? "default";
+  session.lastResolvedModel = model;
   const queue = [];
   const waiters = [];
   let done = false;
@@ -3023,6 +3067,11 @@ var init_session = __esm({
       elisionSettings = null;
       /** Lazy tool loading toggle, from `config.context.lazyTools`. Default off. */
       lazyTools = false;
+      /**
+       * Model id resolved by the most recent `runTurn()` (see SessionRuntime).
+       * Last-writer-wins for concurrent turns; null until the first turn runs.
+       */
+      lastResolvedModel = null;
       /**
        * Live runtime capabilities the host installs on a local Session (see
        * SessionLike). A RemoteSession leaves them undefined. Declared here — rather
@@ -3638,7 +3687,7 @@ The body is the instructions for future invocations. Keep it under 30 lines. Num
 });
 async function synthesizeSkill(session, intent, scope, opts = {}) {
   const provider = session.providers.getActive();
-  const model = opts.model ?? provider.models[0]?.id ?? "claude-sonnet-4-6";
+  const model = opts.model ?? session.lastResolvedModel ?? provider.models[0]?.id ?? "default";
   const draft = await draftSkill(provider, model, intent, session.signal);
   const baseDir = scope === "project" ? opts.projectDir ?? defaultProjectSkillsDir(session.cwd) : opts.userDir ?? defaultUserSkillsDir();
   await promises.mkdir(baseDir, { recursive: true });
@@ -134704,7 +134753,7 @@ function isRunnerUp(socketPath = runnerSocketPath()) {
 
 // ../runner/dist/server.js
 init_dist();
-var RUNNER_PROTOCOL_VERSION = 5;
+var RUNNER_PROTOCOL_VERSION = 6;
 var MIN_COMPATIBLE_PROTOCOL_VERSION = 1;
 var RunnerMethod = {
   /** client->server: handshake; returns the initial info snapshot. */
@@ -134779,7 +134828,14 @@ var RunnerNotification = {
    * clear: post-reset events restart at seq 0, which a seq-contiguous
    * mirror only accepts from an empty log.
    */
-  SessionReset: "session.reset"
+  SessionReset: "session.reset",
+  /**
+   * Sent once, immediately before the attach-time replay loop (v6): the
+   * first seq this connection will replay/stream. The client rebases its
+   * (empty) mirror to `fromSeq` so a partial replay (`replay: 'none'` /
+   * `{ tail }`) ingests contiguously instead of dropping every event.
+   */
+  ReplayStart: "replay.start"
 };
 var attachmentSchema = z.object({
   kind: z.string(),
@@ -134790,14 +134846,22 @@ var attachmentSchema = z.object({
 var attachParamsSchema = z.object({
   protocolVersion: z.number(),
   role: z.string(),
-  sinceSeq: z.number().int().nonnegative().optional()
+  sinceSeq: z.number().int().nonnegative().optional(),
+  replay: z.union([
+    z.literal("full"),
+    z.literal("none"),
+    z.object({ tail: z.number().int().positive() })
+  ]).optional()
 });
 var runTurnParamsSchema = z.object({
   prompt: z.string(),
   model: z.string().optional(),
   systemPrompt: z.string().optional(),
   maxIterations: z.number().int().positive().optional(),
-  attachments: z.array(attachmentSchema).optional()
+  attachments: z.array(attachmentSchema).optional(),
+  // Bounded like the other id-bearing params so a hostile client can't stuff
+  // an arbitrary blob into every event of the turn.
+  turnId: z.string().min(1).max(120).optional()
 });
 var abortParamsSchema = z.object({ turnId: z.string() });
 var setResolverParamsSchema = z.object({
@@ -134945,7 +135009,11 @@ var RunnerServer = class {
     }
     client.role = params.role;
     client.attached = true;
-    for (const event of this.session.log.slice(0)) {
+    const replay = params.replay ?? "full";
+    const total = this.session.log.length;
+    const start = replay === "full" ? 0 : replay === "none" ? total : Math.max(0, total - replay.tail);
+    client.peer.notify(RunnerNotification.ReplayStart, { fromSeq: start });
+    for (const event of this.session.log.slice(start)) {
       client.peer.notify(RunnerNotification.Event, { event });
     }
     return {
@@ -134956,7 +135024,10 @@ var RunnerServer = class {
   }
   handleRunTurn(client, raw) {
     const params = runTurnParamsSchema.parse(raw);
-    const turnId = newTurnId();
+    const turnId = params.turnId ? asTurnId(params.turnId) : newTurnId();
+    if (this.turnControllers.has(turnId)) {
+      throw new Error(`turn id ${turnId} is already in flight \u2014 client-supplied turn ids must be unique`);
+    }
     const controller = new AbortController();
     this.turnControllers.set(turnId, { controller, owner: client });
     client.turns.add(turnId);
@@ -135361,6 +135432,10 @@ var RemoteSession = class {
     this.peer.on(RunnerNotification.InfoChanged, (params) => {
       this.info = params.info;
     });
+    this.peer.on(RunnerNotification.ReplayStart, (params) => {
+      const { fromSeq } = params;
+      this.mirror.rebase(fromSeq);
+    });
     this.peer.on(RunnerNotification.SessionReset, () => {
       this.mirror.clear();
     });
@@ -135404,11 +135479,12 @@ var RemoteSession = class {
     return new Set(this.info?.readyProviders ?? []);
   }
   /** Handshake. Resolves once history has been replayed into the mirror. */
-  async attach(role, sinceSeq) {
+  async attach(role, sinceSeq, replay) {
     const result = await this.peer.request(RunnerMethod.Attach, {
       protocolVersion: RUNNER_PROTOCOL_VERSION,
       role,
-      sinceSeq
+      sinceSeq,
+      ...replay ? { replay } : {}
     });
     this.info = result.info;
     this.serverProtocolVersion = typeof result.protocolVersion === "number" ? result.protocolVersion : RUNNER_PROTOCOL_VERSION;
@@ -135463,7 +135539,11 @@ var RemoteSession = class {
       ...opts.model ? { model: opts.model } : {},
       ...opts.systemPrompt ? { systemPrompt: opts.systemPrompt } : {},
       ...opts.maxIterations ? { maxIterations: opts.maxIterations } : {},
-      ...opts.attachments && opts.attachments.length > 0 ? { attachments: opts.attachments } : {}
+      ...opts.attachments && opts.attachments.length > 0 ? { attachments: opts.attachments } : {},
+      // Pre-minted client turn id (v6) so per-turn event filters match. The
+      // reply's turnId stays authoritative: an older server ignores ours and
+      // mints its own.
+      ...opts.turnId ? { turnId: opts.turnId } : {}
     });
     const turnId = result.turnId;
     const stream = new TurnStream();
@@ -135758,7 +135838,7 @@ async function connectRemoteSession(opts = {}) {
   const transport = opts.transport ?? await connectWithRetry(socketPath, opts.connectRetries ?? 5);
   const session = new RemoteSession(transport);
   try {
-    await session.attach(opts.role ?? "client", opts.sinceSeq ?? 0);
+    await session.attach(opts.role ?? "client", opts.sinceSeq ?? 0, opts.replay);
     return session;
   } catch (err) {
     await maybeRecoverFromMismatch(err, socketPath, opts);
@@ -137300,7 +137380,7 @@ var agentSpecSchema = z$1.object({
   agentType: z$1.string().optional().describe('Named agent kind to spawn (e.g. "researcher", "code-reviewer"). Looked up in the agent registry contributed by installed plugins. Omit, or pass "default", for a generic tool-use agent. Unknown types fall back to default \u2014 the request never fails over a missing kind. List of currently-registered kinds is visible via the /agents command.'),
   label: z$1.string().max(60).optional().describe('Short label shown in progress events (e.g. "research-deps", "lint-fix-A").'),
   systemPrompt: z$1.string().optional().describe("Override the kind's system prompt. Use to set persona, constraints, or hand off upstream artifacts the child needs as context."),
-  model: z$1.string().optional().describe("Model id override; defaults to the kind's model, then the parent's."),
+  model: z$1.string().optional().describe("Model id override; defaults to the kind's model, then the parent's. Omit unless the user explicitly requested a specific model \u2014 do NOT invent model ids. Unknown ids fall back to the parent's model with a warning."),
   mode: z$1.string().optional().describe(`Loop strategy override. Valid values: "default", "goal", "research". OMIT for the kind's default \u2014 do NOT invent names.`),
   allowedTools: z$1.array(z$1.string()).optional().describe("Restrict the child to these tool names. Overrides the kind's allowlist if set.")
 });
@@ -142603,16 +142683,54 @@ function findCycle(steps) {
   }
   return null;
 }
-function formatIssues(error2) {
+function humanizeIssue(iss) {
+  switch (iss.code) {
+    case "too_small": {
+      const min = Number(iss.minimum);
+      if (iss.type === "string")
+        return min === 1 ? "must not be empty" : `must be at least ${min} characters`;
+      if (iss.type === "array")
+        return min === 1 ? "needs at least one entry" : `needs at least ${min} entries`;
+      return `must be at least ${min}`;
+    }
+    case "too_big": {
+      const max = Number(iss.maximum);
+      if (iss.type === "string")
+        return `must be at most ${max} characters`;
+      if (iss.type === "array")
+        return `can have at most ${max} entries`;
+      return `must be at most ${max}`;
+    }
+    case "invalid_type":
+      return iss.received === "undefined" ? "is required" : `should be a ${iss.expected} (got ${iss.received})`;
+    case "invalid_enum_value":
+      return `must be one of: ${iss.options.map((o2) => `"${String(o2)}"`).join(", ")}`;
+    default:
+      return iss.message;
+  }
+}
+function formatIssues(error2, raw) {
+  const steps = raw !== null && typeof raw === "object" && Array.isArray(raw.steps) ? raw.steps : [];
   return error2.issues.map((iss) => {
-    const path61 = iss.path.join(".") || "(root)";
-    return `${path61}: ${iss.message}`;
+    if (iss.code === "custom")
+      return iss.message;
+    const msg = humanizeIssue(iss);
+    const [head, idx, ...rest] = iss.path;
+    if (head === "steps" && typeof idx === "number") {
+      const step = steps[idx];
+      const id = step !== null && typeof step === "object" && typeof step.id === "string" ? step.id : "";
+      const where = id ? `step "${id}"` : `step ${idx + 1}`;
+      const field = rest.join(".");
+      return field ? `${where}: ${field} ${msg}` : `${where} ${msg}`;
+    }
+    const path61 = iss.path.join(".");
+    return path61 ? `${path61} ${msg}` : `workflow ${msg}`;
   });
 }
 function validateWorkflow(raw) {
   const parsed = workflowSchema.safeParse(raw);
   if (!parsed.success)
-    return { ok: false, errors: formatIssues(parsed.error) };
+    return { ok: false, errors: formatIssues(parsed.error, raw) };
   return { ok: true, workflow: parsed.data, errors: [] };
 }
 function parseWorkflowYaml(text) {
@@ -143918,7 +144036,7 @@ function createTool(deps) {
       if (!provider) {
         throw new MoxxyError({ code: "PROVIDER_NOT_CONFIGURED", message: "workflow_create: no active provider to draft with." });
       }
-      const model = deps.draftModel ?? provider.models[0]?.id ?? "claude-sonnet-4-6";
+      const model = deps.draftModel ?? provider.models[0]?.id ?? "default";
       const drafted = await draftWorkflow(provider, model, intent, ctx.signal, {
         ...deps.listSkills ? { availableSkills: deps.listSkills() } : {},
         ...deps.listTools ? { availableTools: deps.listTools() } : {},
@@ -144809,7 +144927,7 @@ async function fireAfterWorkflowDependents(args) {
   }
 }
 function activeModel(session) {
-  return safeActiveProvider(session)?.models[0]?.id ?? "claude-sonnet-4-6";
+  return session.lastResolvedModel ?? safeActiveProvider(session)?.models[0]?.id ?? "default";
 }
 function safeActiveProvider(session) {
   try {
@@ -145318,6 +145436,15 @@ function scopedSessionView(session, allowedTools, triggerName) {
     get pluginHost() {
       return session.pluginHost;
     },
+    // Read-through AND write-through: runTurn records the resolved model on
+    // the session it was handed, and that must land on the real session, not
+    // this per-fire view.
+    get lastResolvedModel() {
+      return session.lastResolvedModel;
+    },
+    set lastResolvedModel(model) {
+      session.lastResolvedModel = model;
+    },
     startTurn: () => session.startTurn(),
     appContext: () => session.appContext()
   };