killeros 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [1.5.2] - 2026-08-03
+
+### Changed
+
+- Hardened always-on concise guidance around low-friction action, visible multi-turn state, evidence-backed outcomes, material ambiguity, diagnostic resets, and explicit safety and correctness precedence.
+
+### Fixed
+
+- Resolved bundled subagent role discovery from the package `agents/` directory; the module-relative path broke when subagent modules moved under `killeros/` in v1.5.0, leaving fresh installs with `Unknown subagent "<role>". Available: none`.
+
+## [1.5.1] - 2026-08-03
+
+### Changed
+
+- Added a fixed pragmatic response style, low GPT-5 Responses API verbosity, and concise reasoning summaries without changing reasoning effort.
+
+### Fixed
+
+- Replaced the `subagent` tool's top-level union with a provider-compatible object schema, fixing request rejection by Console Go and other providers that require function schemas with `type: "object"`.
+- Kept strict action-specific subagent validation at runtime, including single, parallel, chain, steering, interruption, collection, and closure requests.
+- Scoped native concise settings to supported Responses APIs while leaving completion and unrelated provider payloads unchanged.
+
 ## [1.5.0] - 2026-08-03
 
 ### Changed

package/README.md

@@ -33,7 +33,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v1.5.0
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v1.5.2
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.

package/killeros/concise.ts

@@ -1,17 +1,58 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const CONCISE_SYSTEM_PROMPT = `
-# Concise output rules
-1. Start with the answer or next action; omit conversational preambles.
-2. Use numbered steps only when order matters, with one bounded action per step.
-3. Finish the primary task before mentioning optional follow-up work.
-4. State failures directly and include the recovery action.
-5. Keep lists focused; group long inventories under clear headings.
-6. Do not invent time estimates, completion claims, or facts.
-7. Preserve exact code, commands, paths, quoted text, warnings, and user-requested formats.
-8. Omit recap sections and generic closing pleasantries.
+# Action-oriented response guidance
+
+Make each response easy to start and easy to follow. Keep the state the user needs on screen instead of expecting them to remember missing context. Concise means low friction, not minimal detail: preserve everything required for safety, correctness, and action.
+
+## Serve the immediate need
+
+The first line serves the user's immediate need: give the answer for an informational request, the next action for executable work, or the failure and recovery when blocked. Omit conversational preambles. If the agent can continue the work, continue instead of asking permission; if the task is complete, do not manufacture a next step.
+
+Finish the primary task before raising a separate concern. Mention an unrelated issue only when it materially affects safety, correctness, or the user's next decision. Ask one concrete question only when a material ambiguity remains after checking available code and context.
+
+## Reduce action and memory friction
+
+Use structure by meaning: numbered steps for sequence, bullets for parallel facts or options, and short headings when they make a longer answer easier to scan or re-enter. Keep each step bounded. When a list grows beyond about five items, rank or group it instead of omitting required detail.
+
+Use a compact state anchor only when multi-step work spans turns or resumes after interruption. During tool-driven work, report meaningful phase changes, long-running verification, failures, and required decisions rather than narrating routine actions.
+
+## Make outcomes and failures concrete
+
+When work completes, make the verified outcome prominent: state what now works and the evidence that proves it. Do not append a redundant recap. State failures matter-of-factly with the cause, impact, and recovery action. After three consecutive turns leave the same issue broken, stop speculative edits, name the likely invalid assumption from the observed evidence, and ask one diagnostic question.
+
+Never invent facts, completion claims, or timing. Give a concrete human execution estimate only when requested or supported by evidence, state its assumptions, and never predict the agent's own completion time. Preserve exact code, commands, paths, quoted text, warnings, and user-requested formats.
+
+## Resolve conflicts deliberately
+
+Safety and harness constraints come first, followed by the user's explicit depth or format request, then correctness and completeness, then these concise defaults. Explain fully when asked, confirm before destructive actions, and retain necessary uncertainty rather than manufacturing confidence.
+
+Before sending, check that the first line serves the immediate need, filler and tangents are gone, exact artifacts and necessary uncertainty remain, and the ending is either the verified outcome or one action the user must take. Use a pragmatic tone: direct, plain, and focused on the task. Omit generic praise, recap sections, and closing pleasantries.
 `.trim();
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function applyConciseModelSettings(payload: unknown, api: unknown, modelId: unknown): unknown {
+  if (!isRecord(payload) || !Array.isArray(payload.input)) return payload;
+
+  const supportsSummary = api === "openai-codex-responses" || api === "openai-responses" || api === "azure-openai-responses";
+  const supportsVerbosity = api === "openai-codex-responses"
+    || api === "openai-responses" && typeof modelId === "string" && /^gpt-5(?:[.-]|$)/u.test(modelId);
+  let updated = payload;
+  if (supportsVerbosity) {
+    updated = {
+      ...updated,
+      text: { ...(isRecord(payload.text) ? payload.text : {}), verbosity: "low" },
+    };
+  }
+  if (supportsSummary && isRecord(payload.reasoning)) {
+    updated = { ...updated, reasoning: { ...payload.reasoning, summary: "concise" } };
+  }
+  return updated;
+}
+
 export function isConcisedEnabled(): boolean {
   return true;
 }
@@ -20,4 +61,5 @@ export function registerConcisePrompt(pi: ExtensionAPI): void {
   pi.on("before_agent_start", (event) => ({
     systemPrompt: `${event.systemPrompt}\n\n${CONCISE_SYSTEM_PROMPT}`,
   }));
+  pi.on("before_provider_request", (event, ctx) => applyConciseModelSettings(event.payload, ctx.model?.api, ctx.model?.id));
 }

package/killeros/subagents.ts

@@ -357,7 +357,7 @@ export function discoverAgentRoles(
   options: Pick<SubagentRuntimeOptions, "bundledAgentsDir" | "userAgentsDir" | "limits"> = {},
 ): AgentDiscoveryResult {
   const limits = { ...SUBAGENT_LIMITS, ...options.limits };
-  const bundledDir = options.bundledAgentsDir ?? fileURLToPath(new URL("./agents/", import.meta.url));
+  const bundledDir = options.bundledAgentsDir ?? fileURLToPath(new URL("../agents/", import.meta.url));
   const userDir = options.userAgentsDir ?? path.join(getAgentDir(), "agents");
   const wantsProject = scope === "project" || scope === "both";
   if (wantsProject && !projectTrusted) throw new Error("Project agents require a trusted project");
@@ -959,45 +959,24 @@ function createSubagentParams(limits: Pick<SubagentLimits, "maxTasks" | "maxRead
     agent: Type.String({ minLength: 1, maxLength: 64, description: "Agent role name" }),
     task: Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Task with optional {previous} handoff placeholder" }),
   }, { additionalProperties: false });
-  const action = Type.Optional(Type.Literal(SUBAGENT_ACTION.spawn, { default: SUBAGENT_ACTION.spawn, description: "Spawn child threads" }));
-  const spawnOptions = {
+  const threadId = Type.String({ minLength: 1, maxLength: 128, description: "Stable child thread ID" });
+  return Type.Object({
+    action: Type.Optional(StringEnum(SUBAGENT_ACTIONS, { default: SUBAGENT_ACTION.spawn, description: "Spawn, list, inspect, steer, interrupt, collect, or close" })),
+    threadId: Type.Optional(threadId),
+    message: Type.Optional(Type.String({ minLength: 1, maxLength: 4_000, description: "Steering message; valid only with action steer" })),
+    all: Type.Optional(Type.Literal(true, { description: "Interrupt every active child thread" })),
+    agent: Type.Optional(Type.String({ minLength: 1, maxLength: 64, description: "Agent role for single mode" })),
+    task: Type.Optional(Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Task for single mode" })),
+    tasks: Type.Optional(Type.Array(taskSchema, { minItems: 1, maxItems: limits.maxTasks, description: `Parallel role tasks: read-only batches run concurrently up to ${limits.maxReadConcurrency}; batches with writers use one shared slot by default. Set writerConcurrency to opt into a larger shared pool; concurrent writers share the parent worktree, so callers must prove path ownership` })),
+    writerConcurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: limits.maxTasks, description: `Optional shared-pool cap for parallel tasks that include writers. Defaults to 1 when writers are selected; values above 1 opt into concurrent shared-worktree writes. Concurrent writers must prove path ownership` })),
+    chain: Type.Optional(Type.Array(chainTaskSchema, { minItems: 1, maxItems: limits.maxTasks, description: "Sequential role tasks; {previous} inserts the prior result" })),
     model: Type.Optional(Type.String({ minLength: 1, maxLength: 256, description: "Model for every task as provider/model; inherit uses each role setting or the active parent" })),
     thinking: Type.Optional(Type.String({ minLength: 1, maxLength: 16, description: "Thinking effort for every task: off, minimal, low, medium, high, xhigh, max, or inherit" })),
     agentScope: Type.Optional(StringEnum(["user", "project", "both"] as const, {
       default: "user",
       description: "Role sources: user includes bundled and personal; project includes bundled and trusted project; both includes all",
     })),
-  };
-  const threadId = Type.String({ minLength: 1, maxLength: 128, description: "Stable child thread ID" });
-  const exportProperties = {
-    action: Type.String({ description: "Spawn, list, inspect, steer, interrupt, collect, or close" }),
-    threadId: Type.String({ description: "Child thread ID for a lifecycle action" }),
-    message: Type.String({ description: "Steering message; valid only with action steer" }),
-    all: Type.Boolean({ description: "Interrupt every active child thread" }),
-    agent: Type.String({ description: "Agent role for a single spawn" }),
-    task: Type.String({ description: "Task for a single spawn" }),
-    tasks: Type.Array(Type.Any(), { description: "Parallel role tasks" }),
-    writerConcurrency: Type.Integer({ description: "Shared-pool cap for parallel writer tasks" }),
-    chain: Type.Array(Type.Any(), { description: "Sequential role tasks" }),
-    model: Type.String({ description: "Model for every spawned task" }),
-    thinking: Type.String({ description: "Thinking effort for every spawned task" }),
-    agentScope: Type.String({ description: "Role sources for a spawn" }),
-  };
-  const schema = Type.Union([
-    Type.Object({ action, agent: Type.String({ minLength: 1, maxLength: 64, description: "Agent role for single mode" }), task: Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Task for single mode" }), ...spawnOptions }, { additionalProperties: false }),
-    Type.Object({ action, tasks: Type.Array(taskSchema, { minItems: 1, maxItems: limits.maxTasks, description: `Parallel role tasks: read-only batches run concurrently up to ${limits.maxReadConcurrency}; batches with writers use one shared slot by default. Set writerConcurrency to opt into a larger shared pool; concurrent writers share the parent worktree, so callers must prove path ownership` }), writerConcurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: limits.maxTasks, description: `Optional shared-pool cap for parallel tasks that include writers. Defaults to 1 when writers are selected; values above 1 opt into concurrent shared-worktree writes. Concurrent writers must prove path ownership` })), ...spawnOptions }, { additionalProperties: false }),
-    Type.Object({ action, chain: Type.Array(chainTaskSchema, { minItems: 1, maxItems: limits.maxTasks, description: "Sequential role tasks; {previous} inserts the prior result" }), ...spawnOptions }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.list) }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.inspect), threadId }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.steer), threadId, message: Type.String({ minLength: 1, maxLength: 4_000, description: "Bounded steering message" }) }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.interrupt), threadId }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.interrupt), all: Type.Literal(true, { description: "Interrupt every active child thread" }) }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.collect), threadId }, { additionalProperties: false }),
-    Type.Object({ action: Type.Literal(SUBAGENT_ACTION.close), threadId }, { additionalProperties: false }),
-  ]);
-  // Pi's HTML export reads properties; providers receive only the action-specific union.
-  Object.defineProperty(schema, "properties", { value: exportProperties });
-  return schema;
+  }, { additionalProperties: false });
 }
 
 type ToolUpdate = (partial: { content: Array<{ type: "text"; text: string }>; details: SubagentDetails }) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "A production-hardened TUI and workflow extension for the Pi coding agent.",
   "type": "module",
   "keywords": [