@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/extensibility/skc-plugins/validation.ts

@@ -1,11 +1,14 @@
 import { isKnownWorkflowState } from "../../skc-runtime/workflow-manifest";
 import type { CanonicalSkcWorkflowSkill } from "../../skill-state/active-state";
+import { assertMcpInstallPolicy } from "./mcp-policy";
 import {
 	type LoadedSubskillBinding,
+	type NormalizedSkcPluginBundle,
 	SKC_AGENT_SUBSKILL_PHASES,
 	SKC_SUBSKILL_PARENT_AGENTS,
 	SKC_SUBSKILL_PARENT_SKILLS,
 	SkcPluginLoadError,
+	type SkcPluginRegistryEntry,
 	type SkcSubskillParentAgent,
 	type SubskillFrontmatter,
 } from "./types";
@@ -74,3 +77,80 @@ export function buildParentPhaseSet(bindings: readonly LoadedSubskillBinding[]):
 	}
 	return new Set(seen.keys());
 }
+
+/**
+ * Hard install-time collision + security validation for a compiled bundle
+ * against the effective installed registry (other plugins in the target scope
+ * universe). Collisions are hard errors; the registry is the collision
+ * authority, never capability first-wins.
+ */
+export function validateInstallPlan(
+	bundle: NormalizedSkcPluginBundle,
+	effectiveEntries: readonly SkcPluginRegistryEntry[],
+): void {
+	const others = effectiveEntries.filter(e => e.name !== bundle.name);
+
+	const toolNames = new Set<string>();
+	const hookKeys = new Set<string>();
+	const mcpNames = new Set<string>();
+	const appendixIds = new Set<string>();
+	const subskillArgs = new Set<string>();
+	const parentPhases = new Set<string>();
+	for (const e of others) {
+		for (const t of e.surfaces.tools) toolNames.add(t.name);
+		for (const h of e.surfaces.hooks) hookKeys.add(h.extensionId);
+		for (const m of e.surfaces.mcps) mcpNames.add(m.name);
+		for (const a of e.surfaces.systemAppendices) appendixIds.add(a.extensionId);
+		for (const a of e.surfaces.agentAppendices) appendixIds.add(a.extensionId);
+		for (const s of e.surfaces.subskills) {
+			subskillArgs.add(`${s.parent}\u0000${s.activationArg}`);
+			parentPhases.add(`${s.parent}\u0000${s.phase}`);
+		}
+	}
+
+	// Check candidate surfaces against the effective registry AND against each
+	// other (intra-bundle duplicates are also hard errors).
+	for (const t of bundle.surfaces.tools) {
+		if (toolNames.has(t.name)) {
+			throw new SkcPluginLoadError("duplicate_tool", `SKC plugin tool name collides: ${t.name}`);
+		}
+		toolNames.add(t.name);
+	}
+	for (const h of bundle.surfaces.hooks) {
+		if (hookKeys.has(h.extensionId)) {
+			throw new SkcPluginLoadError("duplicate_hook", `SKC plugin hook collides: ${h.extensionId}`);
+		}
+		hookKeys.add(h.extensionId);
+	}
+	for (const m of bundle.surfaces.mcps) {
+		if (mcpNames.has(m.name)) {
+			throw new SkcPluginLoadError("duplicate_mcp", `SKC plugin MCP name collides: ${m.name}`);
+		}
+		mcpNames.add(m.name);
+		assertMcpInstallPolicy(m.config, { pluginRoot: bundle.root });
+	}
+	for (const a of [...bundle.surfaces.systemAppendices, ...bundle.surfaces.agentAppendices]) {
+		if (appendixIds.has(a.extensionId)) {
+			throw new SkcPluginLoadError("duplicate_appendix", `SKC plugin appendix collides: ${a.extensionId}`);
+		}
+		appendixIds.add(a.extensionId);
+	}
+	for (const s of bundle.surfaces.subskills) {
+		const argKey = `${s.parent}\u0000${s.activationArg}`;
+		const phaseKey = `${s.parent}\u0000${s.phase}`;
+		if (subskillArgs.has(argKey)) {
+			throw new SkcPluginLoadError(
+				"duplicate_arg",
+				`SKC plugin subskill activation_arg collides for ${s.parent}: ${s.activationArg}`,
+			);
+		}
+		if (parentPhases.has(phaseKey)) {
+			throw new SkcPluginLoadError(
+				"duplicate_parent_phase",
+				`SKC plugin subskill parent/phase collides: ${s.parent}/${s.phase}`,
+			);
+		}
+		subskillArgs.add(argKey);
+		parentPhases.add(phaseKey);
+	}
+}

package/src/extensibility/skills.ts

@@ -10,6 +10,7 @@ import type { SkillPromptDetails } from "../session/messages";
 import { expandTilde } from "../tools/path-utils";
 import type { LoadedSubskillActivation } from "./skc-plugins";
 import { buildSubskillInjection } from "./skc-plugins/injection";
+import { renderSkillAdvertisement } from "./skc-plugins/runtime-adapters";
 export interface Skill {
 	name: string;
 	description: string;
@@ -415,6 +416,20 @@ export async function buildSkillPromptMessage(
 		} else if (context.subskillActivation) {
 			details.subskillActivation = context.subskillActivation;
 		}
+		// Tier-1 advertisement: metadata-only list of installed sub-skills bound to
+		// this parent skill, so the agent can choose one contextually.
+		if (context.cwd) {
+			try {
+				const advert = await renderSkillAdvertisement({
+					cwd: context.cwd,
+					skillName: skill.name,
+					phase: context.currentPhase,
+				});
+				if (advert) message += `\n\n${advert}`;
+			} catch {
+				// Advertisement is best-effort; never block skill prompt construction.
+			}
+		}
 	}
 	return {
 		message,

package/src/hooks/skill-state.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { logger } from "@sayknow-cli/utils";
 import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
+import { detectDeepInterviewPlaintextAskLeak } from "../deep-interview/plaintext-gate-guard";
 import { buildSessionContext, loadEntriesFromFile, type SessionEntry } from "../session/session-manager";
 import { activeSnapshotPath, modeStatePath as sessionModeStatePath } from "../skc-runtime/session-layout";
 import { resolveSkcSessionForRead } from "../skc-runtime/session-resolution";
@@ -675,6 +676,52 @@ async function readCurrentGoalObjectiveFromSessionFile(sessionFile: string | und
 	return typeof objective === "string" && objective.trim().length > 0 ? objective.trim() : null;
 }
 
+async function readLatestAssistantTextFromSessionFile(sessionFile: string | undefined): Promise<string | null> {
+	const trimmed = sessionFile?.trim();
+	if (!trimmed) return null;
+	let entries: SessionEntry[];
+	try {
+		entries = (await loadEntriesFromFile(trimmed)).filter((entry): entry is SessionEntry => entry.type !== "session");
+	} catch {
+		return null;
+	}
+	if (entries.length === 0) return null;
+	const context = buildSessionContext(entries);
+	for (let index = context.messages.length - 1; index >= 0; index--) {
+		const message = context.messages[index];
+		if (message?.role !== "assistant") continue;
+		const text = message.content
+			.filter(block => block.type === "text")
+			.map(block => block.text)
+			.join("");
+		const trimmedText = text.trim();
+		return trimmedText.length > 0 ? trimmedText : null;
+	}
+	return null;
+}
+
+async function shouldRescueDeepInterviewPlaintextAskLeak(
+	skill: SkcWorkflowSkill,
+	state: ModeState | null,
+	cwd: string,
+	sessionFile: string | undefined,
+): Promise<boolean> {
+	if (skill !== "deep-interview") return false;
+	if (state?.active !== true) return false;
+	const phase = String(state.current_phase ?? "")
+		.trim()
+		.toLowerCase();
+	if (DEEP_INTERVIEW_ABORT_PHASES.has(phase)) return false;
+	if (await deepInterviewSpecCrystallized(state, cwd)) return false;
+	const latestAssistantText = await readLatestAssistantTextFromSessionFile(sessionFile);
+	if (!latestAssistantText) return false;
+	return detectDeepInterviewPlaintextAskLeak(latestAssistantText) !== null;
+}
+
+function buildDeepInterviewPlaintextAskLeakMessage(statePath: string): string {
+	return `SKC deep-interview emitted a Deep Interview question/options block as plain text (${statePath}). It must not wait for a prose answer. Continue immediately by calling the ask tool with the Restate gate question and options: Yes, crystallize; Adjust wording; Missing scope; plus free text/custom input.`;
+}
+
 export async function buildActiveUltragoalPromptContext(input: UserPromptSubmitStateInput): Promise<string | null> {
 	const resolvedSessionId = await resolveBoundarySessionId(input.cwd, input.sessionId);
 	const visibleModeState = await readVisibleModeState(input.cwd, "ultragoal", resolvedSessionId, input.stateDir);
@@ -756,6 +803,16 @@ export async function buildSkillStopOutput(input: StopHookInput): Promise<Record
 				systemMessage: recoveryMessage,
 			};
 		}
+		if (await shouldRescueDeepInterviewPlaintextAskLeak(entry.skill, modeState, input.cwd, input.sessionFile)) {
+			const statePath = modeStatePath(input.cwd, entry.skill, resolvedSessionId);
+			const rescueMessage = buildDeepInterviewPlaintextAskLeakMessage(statePath);
+			return {
+				decision: "block",
+				reason: rescueMessage,
+				stopReason: "skc_skill_deep_interview_plaintext_ask_leak",
+				systemMessage: rescueMessage,
+			};
+		}
 		if (modeStateReleasesStop(modeState, handoffRequired)) {
 			// A mode-state that claims it releases the Stop block must agree with
 			// authoritative durable state. If a stale/incoherent mode-state would