@ikie-dev/cli 9.9.0 → 9.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikie-dev/cli",
-  "version": "9.9.0",
+  "version": "9.9.1",
   "description": "ikie — a coding agent CLI powered by ikie AI",
   "type": "module",
   "license": "Apache-2.0",

package/src/extensions/ferment/index.ts

@@ -38,6 +38,7 @@ import { getActive, getActiveId, getContinuationPolicy } from "./state.js"
 import { createFermentTipProvider } from "./tips.js"
 import { registerFermentTodoSync } from "./todo-sync.js"
 import { applyFermentRuntimeToolProfile } from "./tool-scope.js"
+import { registerEscalateTool } from "./tools/escalate.js"
 import { registerKnowledgeTools } from "./tools/knowledge.js"
 import { buildFreeformScopingFeedbackMessage, registerLifecycleTools } from "./tools/lifecycle.js"
 import { registerPhaseTools } from "./tools/phases.js"
@@ -333,5 +334,6 @@ export default function fermentExtension(pi: ExtensionAPI, runtime: FermentRunti
 	registerPhaseTools(pi, runtime)
 	registerStepTools(pi, runtime)
 	registerKnowledgeTools(pi, runtime)
+	registerEscalateTool(pi, runtime)
 	registerAgentSpawnGuard(pi, runtime)
 }

package/src/extensions/ferment/tools/escalate.ts

@@ -0,0 +1,70 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { findFirstPlannedPhase } from "../../../ferment/engine.js"
+import { captureGitHead } from "../phase-evidence.js"
+import type { FermentRuntime } from "../runtime.js"
+import { createApplyAndPersist, toolOk } from "../tool-helpers.js"
+import { applyFermentToolProfile, profileForFerment } from "../tool-scope.js"
+
+export function registerEscalateTool(pi: ExtensionAPI, runtime: FermentRuntime): void {
+	pi.registerTool({
+		name: "escalate_tools",
+		label: "Escalate Tools",
+		description:
+			"Upgrade your tool access when you need write/execute tools (bash, edit, write, start_ferment_step, etc.) that aren't currently available. " +
+			"If a ferment exists and is in planning phase, this activates the first planned phase and unlocks the full implementation toolset. " +
+			"If no ferment is active, it tells you how to start one.",
+		parameters: {
+			type: "object",
+			properties: {},
+			additionalProperties: false,
+		},
+		async execute() {
+			const ferment = runtime.getActive()
+
+			if (!ferment) {
+				return toolOk(
+					"No active ferment found. Use `/ferment new <your task>` to start one, then call escalate_tools again after scoping to begin implementation.",
+				)
+			}
+
+			const currentProfile = profileForFerment(ferment)
+			if (currentProfile === "implementation") {
+				return toolOk(
+					`Already in implementation phase (ferment: ${ferment.id}). All tools should be available. If something is still missing, check your permissions config.`,
+				)
+			}
+
+			const planned = findFirstPlannedPhase(ferment)
+			if (!planned) {
+				return toolOk(
+					`Ferment "${ferment.id}" has no planned phases to activate. Use scope_ferment to define phases, then call escalate_tools again.`,
+				)
+			}
+
+			const storage = runtime.getStorage()
+			const f = storage.get(ferment.id)
+			if (!f) {
+				return toolOk(`Ferment "${ferment.id}" not found in storage. Try /ferment list to see available ferments.`)
+			}
+
+			const applyAndPersist = createApplyAndPersist(runtime)
+			const outcome = applyAndPersist(ferment.id, { type: "activate_phase", phaseId: planned.id })
+			if (!outcome.ok) {
+				return toolOk(`Could not activate phase: ${outcome.error.message}`)
+			}
+
+			try {
+				applyFermentToolProfile(pi, profileForFerment(outcome.ferment))
+			} catch (err) {
+				console.error("[ferment] escalate_tools: applyFermentToolProfile failed", err)
+			}
+
+			const headRef = captureGitHead()
+			if (headRef) runtime.setPhaseStartRef(ferment.id, planned.id, headRef)
+
+			return toolOk(
+				`Phase "${planned.name}" activated. Tool access upgraded to implementation — you now have bash, edit, write, start_ferment_step, and all other execution tools.`,
+			)
+		},
+	})
+}

package/src/extensions/orchestration/continuation-nudge.test.ts

@@ -30,6 +30,9 @@ function makeAssistant(content: AssistantMessage["content"]): AssistantMessage {
 }
 
 const textOnlyMessage = makeAssistant([{ type: "text", text: "I will delegate this to Nemotron." }])
+const greetingMessage = makeAssistant([
+	{ type: "text", text: "Hi there! I'm ready to help. What would you like to work on?" },
+])
 
 const toolCallMessage = makeAssistant([
 	{
@@ -193,6 +196,12 @@ describe("ContinuationNudge.evaluateTurn", () => {
 		simulateSessionWithPriorToolCall(guard)
 		expect(guard.evaluateTurn(textOnlyMessage)).toBe(true)
 	})
+
+	it("does not nudge normal conversational replies after prior tool use", () => {
+		const guard = new ContinuationNudge()
+		simulateSessionWithPriorToolCall(guard)
+		expect(guard.evaluateTurn(greetingMessage)).toBe(false)
+	})
 })
 
 describe("ContinuationNudge session-level tool tracking", () => {

package/src/extensions/orchestration/continuation-nudge.ts

@@ -44,6 +44,13 @@ export const SECOND_NUDGE_TEXT =
 export const EMPTY_TURN_NUDGE_TEXT =
 	"If you have finished, please summarize the result for the user. Otherwise, continue with the next tool call."
 
+const TOOL_INTENT_RE =
+	/\b(?:i(?:'|’)ll|i\s+will|let\s+me|i(?:'|’)m\s+going\s+to|i\s+am\s+going\s+to|going\s+to)\s+(?:delegate|hand\s+off|ask\s+(?:an?\s+)?(?:agent|subagent)|use|call|run|execute|inspect|read|search|grep|find|edit|write|modify|update|create|open|check|test|verify|review|analy[sz]e|investigate)\b|\b(?:delegating|handing\s+off|calling|running|executing|reading|searching|editing|writing|checking|testing|verifying|reviewing|investigating)\b|\b(?:use|call)\s+(?:the\s+)?(?:agent|task|bash|read|grep|glob|webfetch|apply_patch|tool)\b/i
+
+function hasPendingToolIntent(message: AssistantMessage): boolean {
+	return message.content.some((c) => c.type === "text" && TOOL_INTENT_RE.test(c.text))
+}
+
 /** Post-turn state machine for the "text-only drift" nudge.
  *
  * Fires at most twice per user-input cycle, and only when no tool has been
@@ -140,6 +147,7 @@ export class ContinuationNudge {
 		const hasToolCalls = message.content.some((c) => c.type === "toolCall")
 		const hasText = message.content.some((c) => c.type === "text" && c.text.trim().length > 0)
 		if (hasToolCalls || !hasText) return false
+		if (!hasPendingToolIntent(message)) return false
 		this.nudgeCountThisCycle++
 		this.nudgeResponsePending = true
 		return true

package/src/extensions/orchestration/model-roles.test.ts

@@ -346,8 +346,13 @@ describe("validateModelRoles", () => {
 		expect(result.unavailable).toHaveLength(0)
 	})
 
-	it("handles empty available set", () => {
+	it("does not warn for unavailable defaults unless requested", () => {
 		const result = validateModelRoles(DEFAULT_MODEL_ROLES, new Set())
+		expect(result.unavailable).toHaveLength(0)
+	})
+
+	it("can include unavailable defaults for diagnostics", () => {
+		const result = validateModelRoles(DEFAULT_MODEL_ROLES, new Set(), { warnForDefaults: true })
 		expect(result.unavailable.length).toBeGreaterThanOrEqual(5)
 		const flaggedRoles = new Set(result.unavailable.map((u) => u.role))
 		expect(flaggedRoles).toEqual(

package/src/extensions/orchestration/model-roles.ts

@@ -237,15 +237,21 @@ export interface ModelRoleValidationResult {
 	unavailable: { role: keyof ModelRoles; configuredModel: string }[]
 }
 
+function roleValuesEqual(a: RoleModelAssignment, b: RoleModelAssignment): boolean {
+	return JSON.stringify(normalizeRoleModels(a)) === JSON.stringify(normalizeRoleModels(b))
+}
+
 /**
  * Validate that each role's model(s) exist in the set of available model IDs.
  */
 export function validateModelRoles(
 	roles: ModelRoles,
 	availableModelIds: ReadonlySet<string>,
+	options: { warnForDefaults?: boolean } = {},
 ): ModelRoleValidationResult {
 	const unavailable: ModelRoleValidationResult["unavailable"] = []
 	for (const key of ROLE_KEYS) {
+		if (!options.warnForDefaults && roleValuesEqual(roles[key], DEFAULT_MODEL_ROLES[key])) continue
 		const refs = normalizeRoleModels(roles[key])
 		for (const ref of refs) {
 			const id = modelIdFromRef(ref)

package/src/extensions/prompt-construction/prompt-enrichment.test.ts

@@ -12,6 +12,7 @@ import * as startupContext from "../../startup-context.js"
 import * as agentWorkerContext from "../agent-worker-context.js"
 import { CLAUDE_CODE_SKILLS_RESOURCE_ID } from "../claude-code-skills/definition.js"
 import type { OrchestratorMessages } from "../orchestration/continuation-nudge.js"
+import * as modelRoles from "../orchestration/model-roles.js"
 import promptEnrichmentExtension, {
 	stripEmptyToolCalls,
 	_resetDeprecatedNotificationTracking,
@@ -687,9 +688,13 @@ describe("model role startup warnings", () => {
 		expect(warn).not.toHaveBeenCalledWith(expect.stringContaining("[model-roles] Warning:"))
 	})
 
-	it("keeps unavailable role warnings when Ikie auth is already configured", () => {
+	it("keeps unavailable role warnings for explicit user role overrides when Ikie auth is already configured", () => {
 		vi.spyOn(config, "loadConfig").mockReturnValue({ apiKey: "test-key" } as ReturnType<typeof config.loadConfig>)
 		vi.spyOn(startupContext, "getAvailableModels").mockReturnValue([modelMetadata("different-model")])
+		vi.spyOn(modelRoles, "getModelRoles").mockReturnValue({
+			...modelRoles.DEFAULT_MODEL_ROLES,
+			builder: "anthropic/claude-sonnet-4-5",
+		})
 		const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
 		const pi = {
 			registerFlag: () => {},
@@ -702,7 +707,7 @@ describe("model role startup warnings", () => {
 
 		promptEnrichmentExtension([])(pi)
 
-		expect(warn).toHaveBeenCalledWith(expect.stringContaining("[model-roles] Warning: orchestrator"))
+		expect(warn).toHaveBeenCalledWith(expect.stringContaining("[model-roles] Warning: builder"))
 	})
 })
 
@@ -1095,7 +1100,7 @@ describe("continuation nudge turn_end handler", () => {
 		// The handler should allow a second nudge since the model did not
 		// intentionally stop.
 		await fire("turn_end", {
-			message: makeAssistantWithStop([{ type: "text", text: "I was going to say..." }], "length"),
+			message: makeAssistantWithStop([{ type: "text", text: "I was going to call the Agent tool." }], "length"),
 		})
 		expect(sendMessageCalls.length).toBe(2)
 	})

package/src/shared/planning/tool-catalog.test.ts

@@ -14,10 +14,20 @@ const namesOf = (entries: ToolEntry[]): string[] => entries.map((t) => t.name)
 const TODO_TOOL_NAMES = ["create_todos", "update_todos", "add_todo", "mark_todo", "clear_todos"]
 
 const TOOL_NAMES = {
-	sharedCore: ["read", "grep", "find", "ls", "web_fetch", "web_search", "mcp", ...TODO_TOOL_NAMES],
+	sharedCore: [
+		"read",
+		"grep",
+		"find",
+		"ls",
+		"web_fetch",
+		"web_search",
+		"mcp",
+		...TODO_TOOL_NAMES,
+		"set_phase",
+		"escalate_tools",
+	],
 	adhocOnly: ["questionnaire"],
 	fermentPlanningTools: [
-		"set_phase",
 		"propose_ferment_scoping",
 		"scope_ferment",
 		"update_ferment_scope_field",
@@ -44,7 +54,7 @@ const TOOL_NAMES = {
 
 describe("SHARED_CORE_TOOLS", () => {
 	it("contains the 6 read-only discovery tools, the mcp gateway, plus 5 todo lifecycle tools", () => {
-		expect(SHARED_CORE_TOOLS).toHaveLength(12)
+		expect(SHARED_CORE_TOOLS).toHaveLength(14)
 		for (const name of TOOL_NAMES.sharedCore) {
 			expect(SHARED_CORE_TOOLS).toContainEqual(expect.objectContaining({ name }))
 		}
@@ -60,7 +70,7 @@ describe("ADHOC_MODE_TOOLS", () => {
 	})
 
 	it("does not contain ferment-mode tools", () => {
-		const fermentTools = ["ask_user", "confirm_ferment_completion_criteria", "set_phase", "activate_ferment_phase"]
+		const fermentTools = ["ask_user", "confirm_ferment_completion_criteria", "activate_ferment_phase"]
 		for (const name of fermentTools) {
 			expect(namesOf(ADHOC_MODE_TOOLS)).not.toContain(name)
 		}
@@ -71,7 +81,6 @@ describe("FERMENT_MODE_TOOLS", () => {
 	const allNames = namesOf(FERMENT_MODE_TOOLS)
 
 	const expectedPlanningTools = [
-		"set_phase",
 		"propose_ferment_scoping",
 		"scope_ferment",
 		"update_ferment_scope_field",
@@ -116,7 +125,6 @@ describe("FERMENT_MODE_TOOLS", () => {
 		}
 
 		// planning-only
-		expect(byName("set_phase").phases).toEqual(["planning"])
 		expect(byName("propose_ferment_scoping").phases).toEqual(["planning"])
 		expect(byName("confirm_ferment_completion_criteria").phases).toEqual(["planning"])
 		expect(byName("activate_ferment_phase").phases).toEqual(["planning"])
@@ -156,7 +164,7 @@ describe("getToolsForProfile", () => {
 	describe("idle", () => {
 		it("returns only shared core tools", () => {
 			const result = getToolsForProfile("idle")
-			expect(result).toHaveLength(12)
+			expect(result).toHaveLength(14)
 			expect(namesOf(result)).toEqual(TOOL_NAMES.sharedCore)
 		})
 
@@ -205,7 +213,6 @@ describe("getToolsForProfile", () => {
 			const fermentOnly = [
 				"ask_user",
 				"confirm_ferment_completion_criteria",
-				"set_phase",
 				"propose_ferment_scoping",
 				"scope_ferment",
 				"activate_ferment_phase",

package/src/shared/planning/tool-catalog.ts

@@ -112,6 +112,10 @@ export const SHARED_CORE_TOOLS: ToolEntry[] = [
 	{ name: "add_todo", modes: ["shared"] },
 	{ name: "mark_todo", modes: ["shared"] },
 	{ name: "clear_todos", modes: ["shared"] },
+	// Phase tracker — always available so the agent can declare intent
+	{ name: "set_phase", modes: ["shared"] },
+	// Self-escalation — agent calls this when it needs write tools
+	{ name: "escalate_tools", modes: ["shared"] },
 ]
 
 /** Tools gated behind `--plan` (adhoc planning mode). */
@@ -134,9 +138,6 @@ export const ADHOC_MODE_TOOLS: ToolEntry[] = [
 export const FERMENT_MODE_TOOLS: ToolEntry[] = [
 	// -- planning phase (before any phase is activated) --
 
-	// Phase tracker injected by the ferment planner supplement
-	{ name: "set_phase", modes: ["ferment"], phases: ["planning"] },
-
 	// Draft scoping surface
 	{ name: "propose_ferment_scoping", modes: ["ferment"], phases: ["planning"] },
 	{ name: "scope_ferment", modes: ["ferment"], phases: ["planning"] },