@gajae-code/coding-agent 0.3.0 → 0.3.2

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

@@ -78,7 +78,8 @@
           "write",
           "clear",
           "contract",
-          "handoff"
+          "handoff",
+          "doctor"
         ],
         "enumValues": [
           "deep-interview",
@@ -96,6 +97,7 @@
           "clear",
           "contract",
           "handoff",
+          "doctor",
           "kickoff",
           "write-spec",
           "write-artifact"
@@ -151,6 +153,26 @@
         "name": "force",
         "type": "boolean"
       },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "enumValues": [
+          "deep-interview",
+          "ralplan",
+          "ultragoal",
+          "team"
+        ],
+        "name": "skill",
+        "type": "enum"
+      },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "name": "json",
+        "type": "boolean"
+      },
       {
         "appliesToVerbs": [
           "kickoff"
@@ -267,6 +289,10 @@
         "name": "handoff",
         "surface": "state-action"
       },
+      {
+        "name": "doctor",
+        "surface": "state-action"
+      },
       {
         "name": "kickoff",
         "surface": "command-flag"
@@ -426,7 +452,8 @@
           "write",
           "clear",
           "contract",
-          "handoff"
+          "handoff",
+          "doctor"
         ],
         "enumValues": [
           "deep-interview",
@@ -444,6 +471,7 @@
           "clear",
           "contract",
           "handoff",
+          "doctor",
           "kickoff",
           "write-spec",
           "write-artifact"
@@ -499,6 +527,26 @@
         "name": "force",
         "type": "boolean"
       },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "enumValues": [
+          "deep-interview",
+          "ralplan",
+          "ultragoal",
+          "team"
+        ],
+        "name": "skill",
+        "type": "enum"
+      },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "name": "json",
+        "type": "boolean"
+      },
       {
         "appliesToVerbs": [
           "kickoff"
@@ -604,6 +652,10 @@
         "name": "handoff",
         "surface": "state-action"
       },
+      {
+        "name": "doctor",
+        "surface": "state-action"
+      },
       {
         "name": "kickoff",
         "surface": "command-flag"
@@ -783,7 +835,8 @@
           "write",
           "clear",
           "contract",
-          "handoff"
+          "handoff",
+          "doctor"
         ],
         "enumValues": [
           "deep-interview",
@@ -801,6 +854,7 @@
           "clear",
           "contract",
           "handoff",
+          "doctor",
           "kickoff",
           "write-spec",
           "write-artifact"
@@ -856,6 +910,26 @@
         "name": "force",
         "type": "boolean"
       },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "enumValues": [
+          "deep-interview",
+          "ralplan",
+          "ultragoal",
+          "team"
+        ],
+        "name": "skill",
+        "type": "enum"
+      },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "name": "json",
+        "type": "boolean"
+      },
       {
         "appliesToVerbs": [
           "start"
@@ -1010,6 +1084,10 @@
         "name": "handoff",
         "surface": "state-action"
       },
+      {
+        "name": "doctor",
+        "surface": "state-action"
+      },
       {
         "name": "start",
         "surface": "command-positional"
@@ -1196,7 +1274,8 @@
           "write",
           "clear",
           "contract",
-          "handoff"
+          "handoff",
+          "doctor"
         ],
         "enumValues": [
           "deep-interview",
@@ -1214,6 +1293,7 @@
           "clear",
           "contract",
           "handoff",
+          "doctor",
           "kickoff",
           "write-spec",
           "write-artifact"
@@ -1269,6 +1349,26 @@
         "name": "force",
         "type": "boolean"
       },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "enumValues": [
+          "deep-interview",
+          "ralplan",
+          "ultragoal",
+          "team"
+        ],
+        "name": "skill",
+        "type": "enum"
+      },
+      {
+        "appliesToVerbs": [
+          "doctor"
+        ],
+        "name": "json",
+        "type": "boolean"
+      },
       {
         "appliesToVerbs": [
           "create-goals"
@@ -1444,6 +1544,10 @@
         "name": "handoff",
         "surface": "state-action"
       },
+      {
+        "name": "doctor",
+        "surface": "state-action"
+      },
       {
         "name": "status",
         "surface": "command-positional"

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

@@ -64,7 +64,7 @@ const AGENTS_RETENTION: RetentionPolicy = { category: "agents" };
 const PRUNE_RETENTION: RetentionPolicy = { category: "prune/delete", maxAgeDays: 30 };
 const FORCE_RETENTION: RetentionPolicy = { category: "force", maxAgeDays: 90 };
 
-const STATE_VERBS = ["read", "write", "clear", "contract", "handoff"] as const;
+const STATE_VERBS = ["read", "write", "clear", "contract", "handoff", "doctor"] as const;
 const PLANNED_ADMIN_VERBS = ["graph", "prune", "migrate", "force-overwrite"] as const;
 
 const COMMON_TYPED_ARGS: TypedArgSpec[] = [
@@ -82,6 +82,8 @@ const COMMON_TYPED_ARGS: TypedArgSpec[] = [
 	},
 	{ name: "replace", type: "boolean", appliesToVerbs: ["write"] },
 	{ name: "force", type: "boolean", appliesToVerbs: ["write", "clear", "handoff"] },
+	{ name: "skill", type: "enum", enumValues: [...CANONICAL_GJC_WORKFLOW_SKILLS], appliesToVerbs: ["doctor"] },
+	{ name: "json", type: "boolean", appliesToVerbs: ["doctor"] },
 ];
 
 function verb(name: string, surface: WorkflowVerb["surface"]): WorkflowVerb {

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

@@ -88,13 +88,16 @@ export class ControlServer {
 }
 
 export class EndpointUnreachableError extends Error {
-	constructor(readonly socketPath: string) {
-		super(`endpoint_unreachable:${socketPath}`);
+	constructor(
+		readonly socketPath: string,
+		readonly reason = "unreachable",
+	) {
+		super(`endpoint_${reason}:${socketPath}`);
 		this.name = "EndpointUnreachableError";
 	}
 }
 
-/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens. */
+/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens or responds. */
 export function callEndpoint(socketPath: string, req: EndpointRequest, timeoutMs = 5_000): Promise<unknown> {
 	return new Promise((resolve, reject) => {
 		const socket = net.connect(socketPath);
@@ -107,7 +110,10 @@ export function callEndpoint(socketPath: string, req: EndpointRequest, timeoutMs
 			socket.destroy();
 			fn();
 		};
-		const timer = setTimeout(() => done(() => reject(new Error(`endpoint_timeout:${socketPath}`))), timeoutMs);
+		const timer = setTimeout(
+			() => done(() => reject(new EndpointUnreachableError(socketPath, "timeout"))),
+			timeoutMs,
+		);
 		socket.setEncoding("utf8");
 		socket.on("connect", () => socket.write(frame(req)));
 		socket.on("data", (chunk: string) => {
@@ -118,16 +124,21 @@ export function callEndpoint(socketPath: string, req: EndpointRequest, timeoutMs
 				done(() => {
 					try {
 						resolve(JSON.parse(line));
-					} catch (error) {
-						reject(error instanceof Error ? error : new Error(String(error)));
+					} catch {
+						reject(new EndpointUnreachableError(socketPath, "bad_frame"));
 					}
 				});
 			}
 		});
 		socket.on("error", (error: NodeJS.ErrnoException) => {
 			done(() => {
-				if (error.code === "ENOENT" || error.code === "ECONNREFUSED") {
-					reject(new EndpointUnreachableError(socketPath));
+				if (
+					error.code === "ENOENT" ||
+					error.code === "ECONNREFUSED" ||
+					error.code === "ECONNRESET" ||
+					error.code === "EPIPE"
+				) {
+					reject(new EndpointUnreachableError(socketPath, error.code.toLowerCase()));
 				} else {
 					reject(error);
 				}

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

@@ -52,6 +52,31 @@ import {
 import type { EventEnvelope, GitDelta, Observation, PrimitiveResponse, SessionState, Severity } from "./types";
 import { DEFAULT_RETRY_BUDGET, OBSERVED_SIGNALS } from "./types";
 
+function isStartupLivenessBlocker(blocker: string): boolean {
+	return blocker === "detached-owner-not-live";
+}
+
+function isOwnerVanishedBlocker(blocker: string): boolean {
+	return blocker.startsWith("owner-vanished:");
+}
+
+function reconcileLiveOwnerState(state: SessionState): { state: SessionState; reconciled: boolean } {
+	const blockers = state.blockers.filter(blocker => !isStartupLivenessBlocker(blocker));
+	const hadLivenessBlocker = blockers.length !== state.blockers.length;
+	const lifecycle =
+		hadLivenessBlocker && state.lifecycle === "blocked" && blockers.length === 0 ? "observing" : state.lifecycle;
+	if (!hadLivenessBlocker && lifecycle === state.lifecycle) return { state, reconciled: false };
+	return {
+		state: {
+			...state,
+			lifecycle,
+			blockers,
+			updatedAt: new Date().toISOString(),
+		},
+		reconciled: true,
+	};
+}
+
 export interface OwnerOptions {
 	root: string;
 	sessionId: string;
@@ -139,6 +164,11 @@ export class RuntimeOwner {
 	async #loadState(): Promise<SessionState> {
 		const state = await readSessionState(this.#opts.root, this.#opts.sessionId);
 		if (!state) throw new Error(`session_not_found:${this.#opts.sessionId}`);
+		const reconciled = reconcileLiveOwnerState(state);
+		if (reconciled.reconciled) {
+			await writeSessionState(this.#opts.root, reconciled.state);
+			return reconciled.state;
+		}
 		return state;
 	}
 
@@ -369,17 +399,22 @@ export class RuntimeOwner {
 
 	async #recover(): Promise<PrimitiveResponse> {
 		const obs = await this.#observeGit();
-		const decision = classifyRecovery({ observation: obs, retryBudget: { ...DEFAULT_RETRY_BUDGET } });
+		const state = await this.#loadState();
+		const recoveringPriorVanish = state.blockers.some(isOwnerVanishedBlocker);
+		const recoveryObservation: Observation = recoveringPriorVanish
+			? { ...obs, ownerLive: false, risk: obs.gitDelta === "dirty" ? "vanished-dirty" : obs.risk }
+			: obs;
+		const decision = classifyRecovery({ observation: recoveryObservation, retryBudget: { ...DEFAULT_RETRY_BUDGET } });
 		let vanishReceiptId: string | null = null;
 		if (requiresVanishBeforeAction(decision.classification)) {
-			const dirty = obs.gitDelta === "dirty" || obs.gitDelta === "unknown";
-			const p = dirty ? preserveDirtyWorktree(obs.cwd) : null;
+			const dirty = recoveryObservation.gitDelta === "dirty" || recoveryObservation.gitDelta === "unknown";
+			const p = dirty ? preserveDirtyWorktree(recoveryObservation.cwd) : null;
 			const evidence: VanishEvidence = {
 				classification: decision.classification,
-				gitDelta: obs.gitDelta,
+				gitDelta: recoveryObservation.gitDelta,
 				gitStatusPorcelain: p
 					? `tracked:${p.trackedDiffSha256};untracked:${p.untrackedManifest.length}`
-					: obs.observedSignals.join(","),
+					: recoveryObservation.observedSignals.join(","),
 				untrackedManifest: p?.untrackedManifest ?? [],
 				preservation: p?.stashRef ? "stash" : "snapshot",
 				stashRef: p?.stashRef ?? null,
@@ -391,15 +426,25 @@ export class RuntimeOwner {
 				sessionId: this.#opts.sessionId,
 				family: "vanish",
 				source: "owner",
-				subject: { workspace: obs.cwd, branch: obs.branch, head: null, commit: null },
+				subject: {
+					workspace: recoveryObservation.cwd,
+					branch: recoveryObservation.branch,
+					head: null,
+					commit: null,
+				},
 				evidence,
 			});
 			await writeReceiptImmutable(this.#opts.root, this.#opts.sessionId, "vanish", receipt.receiptId, receipt);
 			vanishReceiptId = receipt.receiptId;
 		}
-		const state = await this.#loadState();
+		if (vanishReceiptId) {
+			state.blockers = state.blockers.filter(blocker => !isOwnerVanishedBlocker(blocker));
+			state.lifecycle = state.blockers.length === 0 ? "observing" : state.lifecycle;
+			state.updatedAt = new Date(this.#opts.clock ? this.#opts.clock() : Date.now()).toISOString();
+			await writeSessionState(this.#opts.root, state);
+		}
 		await this.#emit(decision.severity, "recover_classified", { classification: decision.classification });
-		return this.#response(state, { decision, observation: obs, vanishReceiptId });
+		return this.#response(state, { decision, observation: recoveryObservation, vanishReceiptId });
 	}
 
 	async #operate(input: Record<string, unknown>): Promise<PrimitiveResponse> {
@@ -475,12 +520,14 @@ export class RuntimeOwner {
 
 	async #submit(input: Record<string, unknown>): Promise<PrimitiveResponse> {
 		const prompt = typeof input.prompt === "string" ? input.prompt : "";
+		const state = await this.#loadState();
 		if (!prompt) {
-			const state = await this.#loadState();
 			return this.#response(state, { accepted: false, reason: "empty-prompt" }, false);
 		}
+		if (state.lifecycle === "blocked") {
+			return this.#response(state, { accepted: false, reason: "lifecycle-blocked" }, false);
+		}
 		const result = await singleFlightAccept(this.#opts.rpc, prompt, this.#opts.acceptanceTimeoutMs);
-		const state = await this.#loadState();
 		if (result.accepted) {
 			state.lifecycle = "observing";
 			state.updatedAt = new Date(this.#opts.clock ? this.#opts.clock() : Date.now()).toISOString();

package/src/harness-control-plane/state-machine.ts

@@ -57,8 +57,9 @@ export function nextAllowedActions(lifecycle: HarnessLifecycle, ownerLive: boole
 	// `start` creates a new session; never re-applicable to an existing record.
 	add("start", false, "session-already-exists");
 
-	// `submit` is owner-routed: it requires a live owner and a non-terminal lifecycle.
+	// `submit` is owner-routed: it requires a live owner and a non-blocked, non-terminal lifecycle.
 	if (terminal) add("submit", false, `lifecycle-terminal:${lifecycle}`);
+	else if (lifecycle === "blocked") add("submit", false, "lifecycle-blocked");
 	else if (!ownerLive) add("submit", false, "owner-not-live");
 	else add("submit", true);