@gajae-code/coding-agent 0.3.2 → 0.4.0

package/src/gjc-runtime/ultragoal-runtime.ts

@@ -1,18 +1,12 @@
 import * as crypto from "node:crypto";
 import * as path from "node:path";
-import { syncSkillActiveState, type WorkflowHudSummary } from "../skill-state/active-state";
+import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildUltragoalHudSummary as buildWorkflowUltragoalHudSummary } from "../skill-state/workflow-hud";
-import { WORKFLOW_STATE_VERSION, workflowStateStoragePath } from "../skill-state/workflow-state-contract";
 import { renderCliWriteReceipt } from "./cli-write-receipt";
 import { DEFAULT_ULTRAGOAL_OBJECTIVE } from "./goal-mode-request";
 import { renderUltragoalStatusMarkdown } from "./state-renderer";
-import {
-	appendJsonl,
-	readExistingStateForMutation,
-	writeArtifact,
-	writeJsonAtomic,
-	writeWorkflowEnvelopeAtomic,
-} from "./state-writer";
+import { reconcileWorkflowSkillState } from "./state-runtime";
+import { appendJsonl, writeArtifact, writeJsonAtomic } from "./state-writer";
 
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus =
@@ -481,93 +475,6 @@ export function buildUltragoalHudSummary(
 		updatedAt: new Date().toISOString(),
 	});
 }
-function currentSessionId(): string | undefined {
-	const sessionId = process.env.GJC_SESSION_ID?.trim();
-	return sessionId || undefined;
-}
-
-function ultragoalModeStateFromSummary(
-	summary: UltragoalStatusSummary,
-	latestLedger: UltragoalLedgerEvent | undefined,
-	existing: Record<string, unknown> | undefined,
-	sessionId: string | undefined,
-): Record<string, unknown> {
-	const updatedAt = new Date().toISOString();
-	return {
-		...(existing ?? {}),
-		skill: "ultragoal",
-		version: WORKFLOW_STATE_VERSION,
-		active: summary.exists && summary.status !== "complete",
-		current_phase: summary.status,
-		status: summary.status,
-		active_goal_id: summary.currentGoal?.id,
-		counts: summary.counts,
-		brief_path: summary.paths.briefPath,
-		ledger_path: summary.paths.ledgerPath,
-		goals_path: summary.paths.goalsPath,
-		latest_ledger_event: latestLedger?.event,
-		latest_ledger_event_id: latestLedger?.eventId,
-		updated_at: updatedAt,
-		...(sessionId ? { session_id: sessionId } : {}),
-	};
-}
-
-export async function syncUltragoalWorkflowState(cwd: string): Promise<void> {
-	const summary = await getUltragoalStatus(cwd);
-	const ledger = await readUltragoalLedger(cwd);
-	const latestLedger = ledger.at(-1);
-	const sessionId = currentSessionId();
-	const modeStateActive = summary.exists && summary.status !== "complete";
-	const syncModeState = async (targetSessionId: string | undefined): Promise<void> => {
-		const statePath = workflowStateStoragePath(cwd, "ultragoal", targetSessionId);
-		const existing = await readExistingStateForMutation(statePath);
-		if (existing.kind === "corrupt" && modeStateActive)
-			throw new Error(`Cannot sync corrupt ultragoal mode-state: ${existing.error}`);
-		const existingValue = existing.kind === "valid" ? existing.value : undefined;
-		await writeWorkflowEnvelopeAtomic(
-			statePath,
-			ultragoalModeStateFromSummary(summary, latestLedger, existingValue, targetSessionId),
-			{
-				cwd,
-				receipt: {
-					cwd,
-					skill: "ultragoal",
-					owner: "gjc-runtime",
-					command: "gjc ultragoal sync",
-					sessionId: targetSessionId,
-				},
-				audit: {
-					category: "state",
-					verb: "sync",
-					owner: "gjc-runtime",
-					skill: "ultragoal",
-					fromPhase: typeof existingValue?.current_phase === "string" ? existingValue.current_phase : undefined,
-					toPhase: summary.status,
-				},
-			},
-		);
-	};
-	await syncModeState(undefined);
-	if (sessionId) await syncModeState(sessionId);
-	await syncSkillActiveState({
-		cwd,
-		skill: "ultragoal",
-		active: summary.exists && summary.status !== "complete",
-		phase: summary.status,
-		sessionId: currentSessionId(),
-		hud: buildUltragoalHudSummary(summary, latestLedger),
-		source: "gjc-ultragoal",
-	});
-}
-
-async function syncUltragoalWorkflowStateBestEffort(cwd: string): Promise<void> {
-	try {
-		await syncUltragoalWorkflowState(cwd);
-	} catch {
-		// HUD and mode-state sync are best-effort and must not change command semantics.
-	}
-}
-
 function clampTitle(title: string): string {
 	return title.length > 80 ? `${title.slice(0, 77)}...` : title;
 }
@@ -1400,22 +1307,18 @@ function renderCompleteHandoff(
 	].join("\n");
 }
 
-export async function runNativeUltragoalCommand(args: string[], cwd = process.cwd()): Promise<UltragoalCommandResult> {
+async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<UltragoalCommandResult> {
 	try {
 		const command = commandName(args);
 		const json = hasFlag(args, "--json");
-		let result: UltragoalCommandResult;
 		switch (command) {
 			case "status":
-				await syncUltragoalWorkflowStateBestEffort(cwd);
-				result = { status: 0, stdout: renderStatus(await getUltragoalStatus(cwd), json) };
-				break;
+				return { status: 0, stdout: renderStatus(await getUltragoalStatus(cwd), json) };
 			case "create":
 			case "create-goals": {
 				const mode = flagValue(args, "--gjc-goal-mode") === "per-story" ? "per-story" : "aggregate";
 				const plan = await createUltragoalPlan({ cwd, brief: await readBrief(cwd, args), gjcGoalMode: mode });
-				await syncUltragoalWorkflowStateBestEffort(cwd);
-				result = {
+				return {
 					status: 0,
 					createdPlan: true,
 					stdout: json
@@ -1427,17 +1330,16 @@ export async function runNativeUltragoalCommand(args: string[], cwd = process.cw
 							})
 						: `Created ultragoal plan with ${plan.goals.length} goal${plan.goals.length === 1 ? "" : "s"} at ${getUltragoalPaths(cwd).goalsPath}.\n`,
 				};
-				break;
 			}
-			case "complete-goals": {
-				const handoff = await startNextUltragoalGoal({ cwd, retryFailed: hasFlag(args, "--retry-failed") });
-				await syncUltragoalWorkflowStateBestEffort(cwd);
-				result = {
+			case "complete-goals":
+				return {
 					status: 0,
-					stdout: renderCompleteHandoff(handoff, json, cwd),
+					stdout: renderCompleteHandoff(
+						await startNextUltragoalGoal({ cwd, retryFailed: hasFlag(args, "--retry-failed") }),
+						json,
+						cwd,
+					),
 				};
-				break;
-			}
 			case "checkpoint": {
 				const goalId = flagValue(args, "--goal-id") ?? "";
 				const status = parseGoalStatus(flagValue(args, "--status"));
@@ -1450,9 +1352,8 @@ export async function runNativeUltragoalCommand(args: string[], cwd = process.cw
 					gjcGoalJson: flagValue(args, "--gjc-goal-json"),
 					qualityGateJson: flagValue(args, "--quality-gate-json"),
 				});
-				await syncUltragoalWorkflowStateBestEffort(cwd);
 				const goal = plan.goals.find(item => item.id === goalId);
-				result = {
+				return {
 					status: 0,
 					stdout: json
 						? renderCliWriteReceipt({
@@ -1465,7 +1366,6 @@ export async function runNativeUltragoalCommand(args: string[], cwd = process.cw
 							})
 						: `ultragoal checkpoint goal-id=${goalId} status=${status}\n`,
 				};
-				break;
 			}
 			case "steer": {
 				const kind = flagValue(args, "--kind");
@@ -1477,9 +1377,8 @@ export async function runNativeUltragoalCommand(args: string[], cwd = process.cw
 					evidence: flagValue(args, "--evidence") ?? "",
 					rationale: flagValue(args, "--rationale") ?? "",
 				});
-				await syncUltragoalWorkflowStateBestEffort(cwd);
 				const goal = plan.goals.at(-1);
-				result = {
+				return {
 					status: 0,
 					stdout: json
 						? renderCliWriteReceipt({
@@ -1490,7 +1389,6 @@ export async function runNativeUltragoalCommand(args: string[], cwd = process.cw
 							})
 						: "Accepted add_subgoal steering.\n",
 				};
-				break;
 			}
 			case "record-review-blockers": {
 				const plan = await recordUltragoalReviewBlockers({
@@ -1501,21 +1399,78 @@ export async function runNativeUltragoalCommand(args: string[], cwd = process.cw
 					evidence: flagValue(args, "--evidence") ?? "",
 					gjcGoalJson: flagValue(args, "--gjc-goal-json"),
 				});
-				await syncUltragoalWorkflowStateBestEffort(cwd);
 				const goal = plan.goals.at(-1);
-				result = {
+				return {
 					status: 0,
 					stdout: json
 						? renderCliWriteReceipt({ ok: true, goal_id: goal?.id, goals_path: getUltragoalPaths(cwd).goalsPath })
 						: "Recorded review blockers.\n",
 				};
-				break;
 			}
 			default:
 				return { status: 1, stderr: `Unknown gjc ultragoal command: ${command}\n` };
 		}
-		return result;
 	} catch (error) {
 		return { status: 1, stderr: `${error instanceof Error ? error.message : String(error)}\n` };
 	}
 }
+
+const RECONCILE_COMMANDS = new Set([
+	"status",
+	"create",
+	"create-goals",
+	"complete-goals",
+	"checkpoint",
+	"steer",
+	"record-review-blockers",
+]);
+
+/**
+ * Derive a workflow-state payload from the ultragoal plan/ledger and reconcile the
+ * ultragoal mode-state + active-state/HUD so `gjc state ultragoal read`, the
+ * skill-tool chain guard, and the HUD chip mirror the plan/ledger. Session scope
+ * follows `gjc state` (`GJC_SESSION_ID`). This is a derived repair: it never changes
+ * the triggering command's status/stdout, but a failure is surfaced (stderr + a
+ * `reconcile_failed` ledger audit event) rather than silently swallowed. `status` is
+ * therefore a read PLUS a derived repair; it never mutates goals.json/ledger.jsonl
+ * beyond that reconcile-failure audit event.
+ */
+async function reconcileUltragoalState(cwd: string): Promise<void> {
+	const sessionId = process.env.GJC_SESSION_ID?.trim() || undefined;
+	try {
+		const summary = await getUltragoalStatus(cwd);
+		const status = summary.status;
+		const active = summary.exists && status !== "complete";
+		const payload: Record<string, unknown> = {
+			skill: "ultragoal",
+			status,
+			current_phase: status,
+			active,
+			goals: summary.goals.map(goal => ({ id: goal.id, title: goal.title, status: goal.status })),
+			counts: summary.counts,
+			active_goal_id: summary.currentGoal?.id ?? null,
+			ledger_path: summary.paths.ledgerPath,
+			brief_path: summary.paths.briefPath,
+			goals_path: summary.paths.goalsPath,
+		};
+		if (summary.gjcObjective) payload.gjc_objective = summary.gjcObjective;
+		await reconcileWorkflowSkillState({ cwd, mode: "ultragoal", sessionId, active, phase: status, payload });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`ultragoal state reconciliation failed: ${message}\n`);
+		try {
+			await appendLedger(cwd, { type: "reconcile_failed", error: message });
+		} catch {
+			// Best-effort audit; never let a secondary failure change command semantics.
+		}
+	}
+}
+
+export async function runNativeUltragoalCommand(args: string[], cwd = process.cwd()): Promise<UltragoalCommandResult> {
+	const command = commandName(args);
+	const result = await dispatchUltragoalCommand(args, cwd);
+	if (result.status === 0 && RECONCILE_COMMANDS.has(command)) {
+		await reconcileUltragoalState(cwd);
+	}
+	return result;
+}

package/src/gjc-runtime/workflow-manifest.generated.json

@@ -1171,6 +1171,10 @@
     ],
     "skill": "ultragoal",
     "states": [
+      {
+        "id": "missing",
+        "terminal": true
+      },
       {
         "id": "goal-planning",
         "initial": true
@@ -1198,6 +1202,7 @@
       }
     ],
     "terminalStates": [
+      "missing",
       "failed",
       "complete",
       "handoff"

package/src/gjc-runtime/workflow-manifest.ts

@@ -212,8 +212,8 @@ export const WORKFLOW_MANIFEST: Record<CanonicalGjcWorkflowSkill, SkillManifest>
 	}),
 	ultragoal: manifest({
 		skill: "ultragoal",
-		states: ["goal-planning", "pending", "active", "blocked", "failed", "complete", "handoff"],
-		terminalStates: ["failed", "complete", "handoff"],
+		states: ["missing", "goal-planning", "pending", "active", "blocked", "failed", "complete", "handoff"],
+		terminalStates: ["missing", "failed", "complete", "handoff"],
 		transitions: [
 			{ from: "goal-planning", to: "pending", verb: "create-goals" },
 			{ from: "pending", to: "active", verb: "complete-goals" },

package/src/harness-control-plane/storage.ts

@@ -20,6 +20,85 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { EventEnvelope, ReceiptFamily, SessionState } from "./types";
 
+interface HarnessRootRegistryEntry {
+	root: string;
+	updatedAt: string;
+}
+
+interface HarnessRootRegistry {
+	sessionId: string;
+	roots: HarnessRootRegistryEntry[];
+}
+
+interface ResolveHarnessSessionRootOptions {
+	expectedWorkspace?: string;
+}
+
+export function canonicalWorkspacePath(workspace: string): string {
+	return path.resolve(workspace);
+}
+
+function samePath(left: string, right: string): boolean {
+	return canonicalWorkspacePath(left) === canonicalWorkspacePath(right);
+}
+
+async function ensurePrivateDir(dir: string): Promise<void> {
+	await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+	await fs.chmod(dir, 0o700);
+}
+
+function ensurePrivateDirSync(dir: string): void {
+	fsSync.mkdirSync(dir, { recursive: true, mode: 0o700 });
+	fsSync.chmodSync(dir, 0o700);
+}
+
+function sessionMatchesWorkspace(state: SessionState, expectedWorkspace: string): boolean {
+	return samePath(state.handle.workspace, expectedWorkspace);
+}
+
+function harnessRootRegistryDir(env: NodeJS.ProcessEnv = process.env): string {
+	const override = env.GJC_HARNESS_ROOT_REGISTRY_DIR?.trim();
+	if (override) return path.resolve(override);
+	return path.join(os.tmpdir(), `gjch${process.getuid?.() ?? "u"}`, "harness-roots");
+}
+
+function harnessRootRegistryPath(sessionId: string, env: NodeJS.ProcessEnv = process.env): string {
+	assertSafeSessionId(sessionId);
+	return path.join(harnessRootRegistryDir(env), `${sessionId}.json`);
+}
+
+async function readHarnessRootRegistry(
+	sessionId: string,
+	env: NodeJS.ProcessEnv = process.env,
+): Promise<HarnessRootRegistry> {
+	const file = harnessRootRegistryPath(sessionId, env);
+	try {
+		const raw = await fs.readFile(file, "utf8");
+		const parsed = JSON.parse(raw) as HarnessRootRegistry;
+		if (parsed.sessionId === sessionId && Array.isArray(parsed.roots)) return parsed;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	return { sessionId, roots: [] };
+}
+
+async function writeJsonAtomicPrivate(file: string, value: unknown): Promise<void> {
+	await ensurePrivateDir(path.dirname(file));
+	const tmp = `${file}.tmp-${randomBytes(4).toString("hex")}`;
+	await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+	await fs.rename(tmp, file);
+	await fs.chmod(file, 0o600);
+}
+
+async function writeHarnessRootRegistry(
+	registry: HarnessRootRegistry,
+	env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+	const dir = harnessRootRegistryDir(env);
+	await ensurePrivateDir(dir);
+	const file = harnessRootRegistryPath(registry.sessionId, env);
+	await writeJsonAtomicPrivate(file, registry);
+}
 const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 export const MAX_UNIX_SOCKET_PATH_BYTES = 100;
 
@@ -36,7 +115,7 @@ function socketBase(env: NodeJS.ProcessEnv, allowOverride: boolean): { base: str
 
 function socketPathForBase(root: string, sessionId: string, base: string): string {
 	const digest = createHash("sha256").update(`${root}\0${sessionId}`).digest("hex");
-	fsSync.mkdirSync(base, { recursive: true });
+	ensurePrivateDirSync(base);
 	for (const len of [16, 24, 32, 48, 64]) {
 		const stem = `c-${digest.slice(0, len)}`;
 		const metadataPath = path.join(base, `${stem}.json`);
@@ -46,7 +125,10 @@ function socketPathForBase(root: string, sessionId: string, base: string): strin
 			if (existing.root === root && existing.sessionId === sessionId) return path.join(base, `${stem}.sock`);
 		} catch (error) {
 			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-			fsSync.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+			fsSync.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, {
+				encoding: "utf8",
+				mode: 0o600,
+			});
 			return path.join(base, `${stem}.sock`);
 		}
 	}
@@ -149,6 +231,66 @@ async function readJson<T>(file: string): Promise<T | null> {
 export async function readSessionState(root: string, sessionId: string): Promise<SessionState | null> {
 	return readJson<SessionState>(sessionPaths(root, sessionId).state);
 }
+export async function rememberHarnessSessionRoot(
+	root: string,
+	sessionId: string,
+	env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+	assertSafeSessionId(sessionId);
+	const resolvedRoot = path.resolve(root);
+	const registry = await readHarnessRootRegistry(sessionId, env);
+	const now = new Date().toISOString();
+	registry.roots = [
+		{ root: resolvedRoot, updatedAt: now },
+		...registry.roots.filter(entry => path.resolve(entry.root) !== resolvedRoot),
+	].slice(0, 8);
+	await writeHarnessRootRegistry(registry, env);
+}
+
+export async function resolveHarnessSessionRoot(
+	root: string,
+	sessionId: string,
+	env: NodeJS.ProcessEnv = process.env,
+	options: ResolveHarnessSessionRootOptions = {},
+): Promise<string> {
+	assertSafeSessionId(sessionId);
+	const resolvedRoot = path.resolve(root);
+	const candidates: { root: string; state: SessionState }[] = [];
+	const seenRoots = new Set<string>();
+	const addCandidate = async (candidateRoot: string): Promise<void> => {
+		const candidate = path.resolve(candidateRoot);
+		if (seenRoots.has(candidate)) return;
+		seenRoots.add(candidate);
+		const state = await readSessionState(candidate, sessionId);
+		if (state !== null) candidates.push({ root: candidate, state });
+	};
+
+	await addCandidate(resolvedRoot);
+	const registry = await readHarnessRootRegistry(sessionId, env);
+	for (const entry of registry.roots) await addCandidate(entry.root);
+
+	if (!options.expectedWorkspace) {
+		if (candidates.some(candidate => candidate.root === resolvedRoot)) return resolvedRoot;
+		if (candidates.length === 1) return candidates[0].root;
+		if (candidates.length > 1) {
+			throw new StorageError(`ambiguous_harness_session_root:${sessionId}`, "ambiguous_harness_session_root");
+		}
+		return resolvedRoot;
+	}
+
+	const expectedWorkspace = canonicalWorkspacePath(options.expectedWorkspace);
+	const matchingCandidates = candidates.filter(candidate =>
+		sessionMatchesWorkspace(candidate.state, expectedWorkspace),
+	);
+	if (matchingCandidates.length === 1) return matchingCandidates[0].root;
+	if (matchingCandidates.length > 1) {
+		throw new StorageError(`ambiguous_harness_session_root:${sessionId}`, "ambiguous_harness_session_root");
+	}
+	if (candidates.length > 0) {
+		throw new StorageError(`session_workspace_mismatch:${sessionId}`, "session_workspace_mismatch");
+	}
+	return resolvedRoot;
+}
 
 export async function writeSessionState(root: string, state: SessionState): Promise<void> {
 	const paths = sessionPaths(root, state.sessionId);

package/src/hashline/hash.ts

@@ -5,6 +5,20 @@
 
 import bigrams from "./bigrams.json" with { type: "json" };
 
+// Optional native acceleration for formatHashLines. Loaded WITHOUT throwing at
+// module evaluation so this core module (and its re-exported helpers) stays
+// usable and falls back to the TS loop if the native addon is unavailable.
+let formatHashLinesNative: ((text: string, startLine?: number) => string) | undefined;
+void import("../../../natives/native/index.js")
+	.then(mod => {
+		if (typeof mod.h06FormatHashLines === "function") {
+			formatHashLinesNative = mod.h06FormatHashLines;
+		}
+	})
+	.catch(() => {
+		// Native unavailable; formatHashLines uses the TS loop.
+	});
+
 /**
  * 647 single-token BPE bigrams for hashline anchors. Every entry tokenizes as
  * exactly one token in modern BPE vocabularies (cl100k / o200k / Anthropic model family),
@@ -168,6 +182,15 @@ export function formatHashLine(lineNumber: number, line: string): string {
  * ```
  */
 export function formatHashLines(text: string, startLine = 1): string {
+	// Native path only for the supported startLine domain (non-negative integer);
+	// other values fall through to JS numeric semantics in the TS loop.
+	if (formatHashLinesNative && Number.isInteger(startLine) && startLine >= 0) {
+		try {
+			return formatHashLinesNative(text, startLine);
+		} catch {
+			// Native hashline formatting is an optimization only; preserve the TS contract.
+		}
+	}
 	const lines = text.split("\n");
 	return lines.map((line, i) => formatHashLine(startLine + i, line)).join("\n");
 }

package/src/hooks/skill-state.ts

@@ -382,6 +382,8 @@ async function seedSkillActivationState(
 	return state;
 }
 
+// Fallback for native-hook prompts when SkillPromptDetails.subskillActivation is absent;
+// real /skill dispatch paths resolve sub-skill activation before prompt construction.
 export async function recordSkillActivation(input: RecordSkillActivationInput): Promise<SkillActiveState | null> {
 	const match = detectPrimarySkillKeyword(input.text);
 	if (!match) return null;