@gajae-code/coding-agent 0.2.1 → 0.2.2

package/src/skill-state/deep-interview-mutation-guard.ts

@@ -5,14 +5,20 @@ import { LocalProtocolHandler, resolveLocalUrlToPath } from "../internal-urls/lo
 import { resolveToCwd } from "../tools/path-utils";
 import { ToolError } from "../tools/tool-errors";
 import { listActiveSkills, readVisibleSkillActiveState, type SkillActiveEntry } from "./active-state";
+import {
+	type CanonicalGjcWorkflowSkill,
+	sanctionedWorkflowStateCommand,
+	workflowModeStateFileName,
+} from "./workflow-state-contract";
 
 export const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE =
-	"Deep-interview is active; either continue interviewing with `ask`, or write/finalize the pending spec under `.gjc/specs/` / update state under `.gjc/state/`. Do not edit product code until explicit execution approval.";
+	"Deep-interview is active; continue interviewing with `ask`, write/finalize pending specs through the required GJC workflow CLI, or use an explicit force override. Direct `.gjc/` and product-code edits are blocked until explicit execution approval.";
+export const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE =
+	"Workflow state JSON is runtime-owned. Use `gjc state <skill> read|write --input '<json>'` for deep-interview, ralplan, ultragoal, and team. Planning artifacts under `.gjc/specs/` and `.gjc/plans/` remain allowed.";
 
 const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit"]);
 const ARCHIVE_OR_SQLITE_BASE_RE = /^(.+?\.(?:tar\.gz|sqlite3|sqlite|db3|zip|tgz|tar|db))(?:$|:)/i;
 const INTERNAL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
-const GLOB_META_RE = /[*?[\]{}]/;
 const VIM_FILE_SWITCH_RE = /^\s*:(?:e|e!|edit|edit!)(?:\s+([^<\r\n]+))?(?:<CR>|\r|\n|$)/i;
 
 type ToolWithEditMode = AgentTool & {
@@ -26,6 +32,8 @@ export interface DeepInterviewMutationGuardInput {
 	threadId?: string;
 	tool: ToolWithEditMode;
 	args: unknown;
+	forceOverride?: boolean;
+	enforceWorkflowState?: boolean;
 }
 
 interface ExtractedTargets {
@@ -38,6 +46,7 @@ export interface DeepInterviewMutationDecision {
 	message?: string;
 	targets: string[];
 	reason?: string;
+	command?: string;
 }
 
 interface ModeState {
@@ -246,34 +255,67 @@ function resolveRawPath(cwd: string, rawPath: string): { absolutePath?: string;
 	}
 }
 
-function isAllowlistedPath(cwd: string, rawPath: string): boolean {
+function relativeGjcSegments(cwd: string, rawPath: string): string[] | null {
 	const { absolutePath, unknown } = resolveRawPath(cwd, rawPath);
-	if (unknown || !absolutePath) return false;
+	if (unknown || !absolutePath) return null;
 	const relative = path.relative(path.resolve(cwd), path.resolve(absolutePath));
-	if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) return false;
-	const segments = normalizePosix(relative).split("/").filter(Boolean);
-	return segments[0] === ".gjc" && (segments[1] === "specs" || segments[1] === "state");
+	if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) return null;
+	return normalizePosix(relative).split("/").filter(Boolean);
 }
 
-function allTargetsAllowlisted(cwd: string, targets: ExtractedTargets): boolean {
+function blockedWorkflowStateSkill(cwd: string, rawPath: string): CanonicalGjcWorkflowSkill | null {
+	const segments = relativeGjcSegments(cwd, rawPath);
+	if (!segments || segments[0] !== ".gjc") return null;
+	if (segments[1] === "specs" || segments[1] === "plans") return null;
+	if (segments[1] !== "state") return null;
+	const fileName = segments.at(-1) ?? "";
+	for (const skillName of ["deep-interview", "ralplan", "ultragoal", "team"] as const) {
+		if (fileName === workflowModeStateFileName(skillName)) return skillName;
+	}
+	if (fileName === "skill-active-state.json") return "deep-interview";
+	return null;
+}
+
+function firstBlockedWorkflowStateSkill(cwd: string, targets: ExtractedTargets): CanonicalGjcWorkflowSkill | null {
+	for (const rawPath of targets.paths) {
+		const skill = blockedWorkflowStateSkill(cwd, rawPath);
+		if (skill) return skill;
+	}
+	return null;
+}
+
+function isGjcManagedPath(cwd: string, rawPath: string): boolean {
+	const segments = relativeGjcSegments(cwd, rawPath);
+	return segments?.[0] === ".gjc";
+}
+
+function isAllowlistedPath(cwd: string, rawPath: string): boolean {
+	const segments = relativeGjcSegments(cwd, rawPath);
+	if (!segments || segments[0] !== ".gjc") return false;
+	return segments[1] === "specs" || segments[1] === "plans";
+}
+
+function hasGjcManagedTarget(cwd: string, targets: ExtractedTargets): boolean {
 	if (targets.unknown || targets.paths.length === 0) return false;
-	return targets.paths.every(rawPath => {
-		if (GLOB_META_RE.test(rawPath)) {
-			return isAllowlistedPath(cwd, rawPath);
-		}
-		return isAllowlistedPath(cwd, rawPath);
-	});
+	return targets.paths.some(rawPath => isGjcManagedPath(cwd, rawPath));
 }
 
+function allTargetsAllowlisted(cwd: string, targets: ExtractedTargets): boolean {
+	return (
+		!targets.unknown && targets.paths.length > 0 && targets.paths.every(rawPath => isAllowlistedPath(cwd, rawPath))
+	);
+}
 export async function assertDeepInterviewMutationRawPathsAllowed(input: {
 	cwd: string;
 	sessionId?: string;
 	threadId?: string;
 	rawPaths: string[];
+	forceOverride?: boolean;
 }): Promise<void> {
+	if (input.forceOverride) return;
 	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) return;
 	const targets: ExtractedTargets = { paths: input.rawPaths, unknown: input.rawPaths.length === 0 };
-	if (!allTargetsAllowlisted(input.cwd, targets)) {
+	if (hasGjcManagedTarget(input.cwd, targets)) {
 		throw new ToolError(DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE);
 	}
 }
@@ -282,19 +324,41 @@ export async function getDeepInterviewMutationDecision(
 	input: DeepInterviewMutationGuardInput,
 ): Promise<DeepInterviewMutationDecision> {
 	if (!BLOCKED_TOOL_NAMES.has(input.tool.name)) return { blocked: false, targets: [] };
+	const targets = extractTargets(input.tool, input.args);
+	if (input.enforceWorkflowState !== false) {
+		const stateSkill = firstBlockedWorkflowStateSkill(input.cwd, targets);
+		if (stateSkill) {
+			const command = sanctionedWorkflowStateCommand(stateSkill);
+			return {
+				blocked: true,
+				message: `${WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE}\nUse: ${command}`,
+				targets: targets.paths,
+				reason: "workflow-state-target",
+				command,
+			};
+		}
+	}
 	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) {
 		return { blocked: false, targets: [] };
 	}
-	const targets = extractTargets(input.tool, input.args);
-	if (allTargetsAllowlisted(input.cwd, targets)) {
-		return { blocked: false, targets: targets.paths };
+	if (input.forceOverride) return { blocked: false, targets: [] };
+	if (targets.unknown) {
+		return {
+			blocked: true,
+			message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,
+			targets: targets.paths,
+			reason: "unknown-target",
+		};
+	}
+	if (hasGjcManagedTarget(input.cwd, targets) && !allTargetsAllowlisted(input.cwd, targets)) {
+		return {
+			blocked: true,
+			message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,
+			targets: targets.paths,
+			reason: "gjc-managed-target",
+		};
 	}
-	return {
-		blocked: true,
-		message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,
-		targets: targets.paths,
-		reason: targets.unknown ? "unknown-target" : "product-target",
-	};
+	return { blocked: false, targets: targets.paths };
 }
 
 export async function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void> {

package/src/skill-state/workflow-hud.ts

@@ -1,6 +1,12 @@
 import type { WorkflowHudChip, WorkflowHudSummary } from "./active-state";
 
-interface DeepInterviewHudState {
+interface WorkflowGateHudState {
+	approvalStatus?: string;
+	blockedReason?: string;
+	nextAction?: string;
+}
+
+interface DeepInterviewHudState extends WorkflowGateHudState {
 	phase?: string;
 	ambiguity?: number;
 	threshold?: number;
@@ -11,7 +17,7 @@ interface DeepInterviewHudState {
 	updatedAt?: string;
 }
 
-interface RalplanHudState {
+interface RalplanHudState extends WorkflowGateHudState {
 	stage?: string;
 	waiting?: string;
 	iteration?: number;
@@ -27,7 +33,7 @@ interface UltragoalLikeGoal {
 	status: string;
 }
 
-interface UltragoalHudState {
+interface UltragoalHudState extends WorkflowGateHudState {
 	status: string;
 	currentGoal?: UltragoalLikeGoal;
 	counts: Record<string, number>;
@@ -41,7 +47,7 @@ interface TeamHudWorker {
 	status?: string;
 }
 
-interface TeamHudState {
+interface TeamHudState extends WorkflowGateHudState {
 	phase: string;
 	task_total: number;
 	task_counts: Record<string, number>;
@@ -66,6 +72,14 @@ function chip(
 	return { label, value, priority, ...(severity ? { severity } : {}) };
 }
 
+function gateChips(state: WorkflowGateHudState, gatePriority: number): Array<WorkflowHudChip | null> {
+	return [
+		chip("gate", state.approvalStatus, gatePriority, state.approvalStatus === "approved" ? "success" : "warning"),
+		chip("blocked", state.blockedReason, gatePriority + 10, "blocked"),
+		chip("next", state.nextAction, gatePriority + 20),
+	];
+}
+
 function compactChips(chips: Array<WorkflowHudChip | null>): WorkflowHudChip[] {
 	return chips.filter((item): item is WorkflowHudChip => item !== null);
 }
@@ -74,6 +88,7 @@ export function buildDeepInterviewHudSummary(state: DeepInterviewHudState): Work
 	return {
 		version: 1,
 		chips: compactChips([
+			...gateChips(state, 5),
 			chip("phase", state.phase, 10),
 			chip("ambiguity", [percent(state.ambiguity), percent(state.threshold)].filter(Boolean).join("/"), 20),
 			chip("round", state.roundCount === undefined ? undefined : String(state.roundCount), 30),
@@ -100,6 +115,7 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 		summary: state.latestSummary,
 		chips: compactChips([
 			state.pendingApproval ? { label: "pending", value: "approval", priority: 5, severity: "warning" } : null,
+			...gateChips(state, 6),
 			chip("stage", state.stage, 10),
 			chip("waiting", state.waiting, 20),
 			chip("iter", state.iteration === undefined ? undefined : String(state.iteration), 30),
@@ -120,6 +136,7 @@ export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudS
 			chip("goals", `${complete}/${total}`, 10),
 			chip("current", state.currentGoal ? `${state.currentGoal.id}:${state.currentGoal.title}` : state.status, 20),
 			chip("status", state.status, 30, state.status === "complete" ? "success" : undefined),
+			...gateChips(state, 40),
 		]),
 		details: state.latestLedgerEvent
 			? compactChips([
@@ -153,7 +170,8 @@ export function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary {
 			chip("phase", state.phase, 10),
 			chip("workers", `${state.workers.length - failedWorkers}/${state.workers.length}`, 20),
 			chip("tasks", `${completed}/${state.task_total}`, 30),
-			chip("latest", latest, 50),
+			...gateChips(state, 40),
+			chip("latest", latest, 70),
 		]),
 		...(state.updated_at ? { updated_at: state.updated_at } : {}),
 	};

package/src/skill-state/workflow-state-contract.ts

@@ -0,0 +1,121 @@
+import * as path from "node:path";
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill, SKILL_ACTIVE_STATE_FILE } from "./active-state";
+
+export type { CanonicalGjcWorkflowSkill };
+
+export const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export const WORKFLOW_STATE_RECEIPT_FRESH_MS = 30 * 60 * 1000;
+
+export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
+export type WorkflowStateReceiptStatus = "fresh" | "stale";
+
+export interface WorkflowStateReceipt {
+	version: 1;
+	skill: CanonicalGjcWorkflowSkill;
+	owner: WorkflowStateMutationOwner;
+	command: string;
+	state_path: string;
+	storage_path: string;
+	mutated_at: string;
+	fresh_until: string;
+	status: WorkflowStateReceiptStatus;
+	mutation_id: string;
+}
+
+function safeString(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+function encodePathSegment(value: string): string {
+	return encodeURIComponent(value).replaceAll(".", "%2E");
+}
+
+export function workflowModeStateFileName(skill: CanonicalGjcWorkflowSkill): string {
+	return `${skill}-state.json`;
+}
+
+export function workflowStateStoragePath(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): string {
+	const normalizedSessionId = safeString(sessionId).trim();
+	if (normalizedSessionId) {
+		return path.join(
+			cwd,
+			".gjc",
+			"state",
+			"sessions",
+			encodePathSegment(normalizedSessionId),
+			workflowModeStateFileName(skill),
+		);
+	}
+	return path.join(cwd, ".gjc", "state", workflowModeStateFileName(skill));
+}
+
+export function workflowActiveStatePath(cwd: string, sessionId?: string): string {
+	const normalizedSessionId = safeString(sessionId).trim();
+	if (normalizedSessionId) {
+		return path.join(
+			cwd,
+			".gjc",
+			"state",
+			"sessions",
+			encodePathSegment(normalizedSessionId),
+			SKILL_ACTIVE_STATE_FILE,
+		);
+	}
+	return path.join(cwd, ".gjc", "state", SKILL_ACTIVE_STATE_FILE);
+}
+
+export function buildWorkflowStateReceipt(input: {
+	cwd: string;
+	skill: CanonicalGjcWorkflowSkill;
+	owner: WorkflowStateMutationOwner;
+	command: string;
+	sessionId?: string;
+	nowIso?: string;
+	mutationId?: string;
+}): WorkflowStateReceipt {
+	const mutatedAt = input.nowIso ?? new Date().toISOString();
+	const freshUntil = new Date(Date.parse(mutatedAt) + WORKFLOW_STATE_RECEIPT_FRESH_MS).toISOString();
+	return {
+		version: WORKFLOW_STATE_RECEIPT_VERSION,
+		skill: input.skill,
+		owner: input.owner,
+		command: input.command,
+		state_path: workflowActiveStatePath(input.cwd, input.sessionId),
+		storage_path: workflowStateStoragePath(input.cwd, input.skill, input.sessionId),
+		mutated_at: mutatedAt,
+		fresh_until: freshUntil,
+		status: "fresh",
+		mutation_id: input.mutationId ?? `${input.skill}:${mutatedAt}`,
+	};
+}
+
+export function workflowReceiptStatus(
+	receipt: WorkflowStateReceipt | undefined,
+	nowMs = Date.now(),
+): WorkflowStateReceiptStatus | undefined {
+	if (!receipt) return undefined;
+	const freshUntilMs = Date.parse(receipt.fresh_until);
+	if (!Number.isFinite(freshUntilMs)) return "stale";
+	return nowMs <= freshUntilMs ? "fresh" : "stale";
+}
+
+export function canonicalWorkflowSkill(value: string): CanonicalGjcWorkflowSkill | null {
+	return (CANONICAL_GJC_WORKFLOW_SKILLS as readonly string[]).includes(value)
+		? (value as CanonicalGjcWorkflowSkill)
+		: null;
+}
+
+export function sanctionedWorkflowStateCommand(skill: CanonicalGjcWorkflowSkill): string {
+	return `gjc state ${skill} write --input '<json>'`;
+}
+
+export function describeWorkflowStateContract(skill: CanonicalGjcWorkflowSkill): string[] {
+	return [
+		`Sanctioned mutation path: gjc state ${skill} read|write --input '<json>'`,
+		`Canonical active HUD state: .gjc/state/${SKILL_ACTIVE_STATE_FILE} and .gjc/state/sessions/<session>/${SKILL_ACTIVE_STATE_FILE}`,
+		`Skill mode state: .gjc/state/${workflowModeStateFileName(skill)} or .gjc/state/sessions/<session>/${workflowModeStateFileName(skill)}`,
+		"Receipts include version, skill, owner, command, state_path, storage_path, mutated_at, fresh_until, status, and mutation_id.",
+		"Receipts are fresh for 30 minutes; older receipts are stale and render as HUD warnings.",
+		"Planning artifacts under .gjc/specs/** and .gjc/plans/** remain writable outside the state command.",
+	];
+}

package/src/slash-commands/builtin-registry.ts

@@ -202,17 +202,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
-	{
-		name: "loop",
-		description:
-			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
-		inlineHint: "[count|duration]",
-		allowArgs: true,
-		handleTui: async (command, runtime) => {
-			await runtime.ctx.handleLoopCommand(command.args);
-			runtime.ctx.editor.setText("");
-		},
-	},
 	{
 		name: "goal",
 		description: "Toggle goal mode (persistent autonomous objective for this session)",
@@ -222,7 +211,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			{ name: "pause", description: "Pause the current goal" },
 			{ name: "resume", description: "Resume a paused goal" },
 			{ name: "drop", description: "Drop the current goal" },
-			{ name: "budget", description: "Adjust the token budget", usage: "<N|off>" },
 		],
 		inlineHint: "[objective]",
 		allowArgs: true,
@@ -793,6 +781,30 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleCompactCommand(customInstructions);
 		},
 	},
+	{
+		name: "contribute-pr",
+		aliases: ["contribution-prep"],
+		description: "Dump redacted session context and spawn a fresh contribute-pr worker",
+		inlineHint: "[focus instructions]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const result = await runtime.session.prepareContributionPrep({
+				customInstructions: command.args || undefined,
+				spawnWorker: true,
+			});
+			await runtime.output(
+				[
+					"Contribution prep artifacts written.",
+					`Manifest: ${result.manifestPath}`,
+					`Worker prompt: ${result.workerPromptPath}`,
+				].join("\n"),
+			);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleContributionPrepCommand(command.args || undefined);
+		},
+	},
 	{
 		name: "resume",
 		description: "Resume a different session",

package/src/task/commands.ts

@@ -9,12 +9,8 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import { loadCapability } from "../discovery";
 // Embed command markdown files at build time
 import initMd from "../prompts/agents/init.md" with { type: "text" };
-import orchestrateMd from "../prompts/commands/orchestrate.md" with { type: "text" };
 
-const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
-	{ name: "init.md", content: prompt.render(initMd) },
-	{ name: "orchestrate.md", content: prompt.render(orchestrateMd) },
-];
+const EMBEDDED_COMMANDS: { name: string; content: string }[] = [{ name: "init.md", content: prompt.render(initMd) }];
 
 export const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{ name: string; content: string }> = EMBEDDED_COMMANDS;