zigmini 0.8.0-beta.2 → 0.8.0-beta.3

package/assets/agent/gateway-rules.md

@@ -17,3 +17,4 @@ zigmini 패키지 공통 에이전트 규칙입니다. 게이트웨이 브리지
 12. 로컬 파일 경로를 웹 링크처럼 보여 주지 않습니다.
 13. 사용자의 시간 표현은 사용자의 현지 시간으로 해석합니다. 보고하는 시각도 현지 시간으로 씁니다.
 14. 사용자는 게이트웨이 프로필의 닉네임으로 부릅니다.
+15. main은 오래 기다리거나 오래 실행하는 작업(배포, 전체 테스트, 뮤테이션 테스트, 다른 작업 기다리기)을 맡기면, 그 작업의 세션 기록이 30분 넘게 바뀌지 않을 때 main을 깨우는 감시를 직접 겁니다. 작업이 끝나면 감시를 끕니다. 작업의 "기다리는 중"·"진행 중" 보고만 믿지 않습니다. 사용자에게 그렇게 말하기 전에 그 작업의 마지막 기록 시각과 실행 중인 프로세스를 확인합니다. 작업이 멈췄으면 바로 그 작업에 조치를 보내고 사용자에게 알립니다. 작업은 긴 명령을 세션과 분리해 실행하고, 결과 파일을 직접 확인하며, 시간 상한을 겁니다.

package/assets/android/zigmini.apk.json

@@ -1,5 +1,5 @@
 {
-  "versionCode": 21,
-  "versionName": "0.8.0-beta.2",
-  "sha256": "b674f81288b1a6e6c6e1cfb5506dc1a69051267488c811b42648df3540c48e1d"
+  "versionCode": 22,
+  "versionName": "0.8.0-beta.3",
+  "sha256": "819f50b65105dde875324e7dde62635321ee1412ba1e975849a764f10dea3426"
 }

package/assets/build.json

@@ -1 +1 @@
-{"commit":"7853cd4f5a3c62d2a79ac8dc0b94786087e06d8a"}
+{"commit":"d6641bcbb5a3d30fe55d94c24f05113f3405518b"}

package/host/omo-bridge/task-control.ts

@@ -47,8 +47,11 @@ function commandEntry(entries: Entry[], workId: string, seq: unknown): Params {
 	throw new Error("report_command_not_received");
 }
 
-/** Main models have sent report details as a JSON string; only a string that parses to an object is unwrapped. */
-function mainReportDetails(details: unknown): unknown {
+/**
+ * Main and work models have sent report details as a JSON string (bugs 3 and 127); only a string that parses to an
+ * object is unwrapped.
+ */
+function reportDetails(details: unknown): unknown {
 	if (typeof details !== "string") return details;
 	try {
 		const parsed: unknown = JSON.parse(details);
@@ -204,7 +207,7 @@ export default function taskControl(pi: ExtensionApi): void {
 						Object.keys(params).some((key) => !["kind", "summary", "details"].includes(key)))) {
 						throw new Error("main_question_only");
 					}
-					const details = isMain ? mainReportDetails(params.details) : params.details;
+					const details = reportDetails(params.details);
 					const command = isMain
 						? mainDecisionEntry(ctx.sessionManager.getEntries(), details)
 						: commandEntry(ctx.sessionManager.getEntries(), workId as string, params.command_seq);
@@ -214,7 +217,7 @@ export default function taskControl(pi: ExtensionApi): void {
 						kind: "question", summary: params.summary, details,
 					} : {
 						report_id: requestKey, work_id: workId, command_id: command.command_id,
-						kind: params.kind, command_seq: params.command_seq, summary: params.summary, details: params.details,
+						kind: params.kind, command_seq: params.command_seq, summary: params.summary, details,
 					};
 					let entry = ctx.sessionManager.getEntries().find((e) => e.type === "custom" && e.customType === "zgw.work_report" && record(e.data) && e.data.report_id === requestKey);
 					if (entry && !isDeepStrictEqual(entry.data, data)) throw new Error("report_key_conflict");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigmini",
-  "version": "0.8.0-beta.2",
+  "version": "0.8.0-beta.3",
   "type": "module",
   "bin": {
     "zigmini": "bin/zigmini"
@@ -53,7 +53,7 @@
     "test:e2e": "bun test test/e2e",
     "test:contract": "bun test test/contract",
     "test:all": "tsc --noEmit && bun test test/unit && bun test test/contract",
-    "test:mutation": "bun test test/mutation",
+    "test:mutation": "bun scripts/mutation-run.ts",
     "heavy": "bun host/heavy-slot.ts run"
   },
   "devDependencies": {

package/src/client-topics.ts

@@ -0,0 +1,16 @@
+/**
+ * Bug 119: which chat socket gets which live event. Every chat socket joins both topics; the app (hello client "android",
+ * the same in every app version) leaves the thinking topic, since it never shows thinking and each delta costs it work on
+ * its main thread. The web page and devlog show thinking and stay on it.
+ */
+export const CHAT_TOPIC = "clients";
+export const THINKING_TOPIC = "thinking";
+export const APP_CLIENT = "android";
+
+export function topicOf(type: string): string {
+	return type === "thinking.delta" ? THINKING_TOPIC : CHAT_TOPIC;
+}
+
+export function showsThinking(client: unknown): boolean {
+	return client !== APP_CLIENT;
+}

package/src/decisions.ts

@@ -44,6 +44,16 @@ function unresolved(decision: Decision): boolean {
 	return decision.status !== "closed" && decision.status !== "delivered";
 }
 
+/**
+ * Bug 127: an unanswered ask_user_question with waitForAnswer false. Its tool call already returned, so its owner never
+ * waits on it; when its native wait ends (a generation drain, an owner release) the answer still reaches the owner as a
+ * follow-up command.
+ */
+function detachedQuestion(decision: Decision): boolean {
+	return decision.method === "question" && !decision.permission && decision.submissionId === null &&
+		record(decision.payload) && decision.payload.waitForAnswer === false;
+}
+
 /** Chat card footer for an item the user deleted from the inbox (web markResolved, Android resolvedLabel). */
 const DISMISSED_REASONS: Record<string, string> = {
 	user_cancelled: "확인함에서 삭제해 질문을 취소했습니다",
@@ -304,6 +314,8 @@ export class DecisionService {
 			...observation.payload, ...(workId === null ? { sourceEventSeq } : {}),
 			...(Array.isArray(sourceReferences) && sourceReferences.length ? { sourceReferences } : {}),
 		};
+		// A decision stored before bug 127 has no waitForAnswer mark; observing it again must not read as a changed question.
+		if (decision && record(decision.payload) && !Object.hasOwn(decision.payload, "waitForAnswer")) delete payload.waitForAnswer;
 		const bindingState = observation.permission && record(payload.nativePermission) &&
 			!this.store.hasNativePermissionAsked(owner.scope, owner.sessionPath, payload.nativePermission) ? "unknown" : "live";
 		if (!decision) {
@@ -358,7 +370,8 @@ export class DecisionService {
 		if (observation.method !== "question" || observation.permission || observation.required === false || typeof toolCallId !== "string" || !toolCallId) return null;
 		const siblings = this.store.allDecisions(owner.scope).filter((decision) => decision.sourceSessionPath === owner.sessionPath &&
 			decision.method === "question" && !decision.permission && record(decision.payload) && decision.payload.toolCallId === toolCallId && unresolved(decision));
-		const waiting = siblings.filter((decision) => decision.required && decision.bindingState === "unknown" && decision.reason === "owner_disconnected" &&
+		const waiting = siblings.filter((decision) => ((decision.required && decision.bindingState === "unknown" && decision.reason === "owner_disconnected") ||
+			decision.reason === "async_wait_closed") &&
 			decision.submissionId === null && decision.answer === null && record(decision.payload) &&
 			isDeepStrictEqual(decision.payload.questions, observation.payload.questions));
 		if (siblings.length !== 1 || waiting.length !== 1) return null;
@@ -413,15 +426,17 @@ export class DecisionService {
 			decision.submissionId !== null && record(answer) && record(answer.answers) && receiptOutcome &&
 			isDeepStrictEqual(event.answers, answer.answers) && (event.comment ?? "") === (answer.comment ?? "") &&
 			Array.isArray(event.unanswered) && event.unanswered.length === 0;
+		const detached = !received && event.outcome !== "timed_out" && detachedQuestion(decision);
 		decision = this.store.setDecisionBinding(decision.id, decision.revision, {
 			state: event.outcome === "timed_out" ? "expired" : "closed",
-			reason: event.outcome === "timed_out" ? "timeout" : "engine_wait_closed",
+			reason: event.outcome === "timed_out" ? "timeout" : detached ? "async_wait_closed" : "engine_wait_closed",
 		});
 		if (received) {
 			this.store.transitionDecision(decision.id, decision.revision, { status: "delivered", reason: "question_receipt" });
 		} else if (decision.submissionId !== null) {
 			this.review(decision.id, record(answer) && answer.cancelled === true ? "user_deferred" : "receipt_unknown");
-		} else if (event.outcome !== "timed_out") {
+		} else if (event.outcome !== "timed_out" && !detached) {
+			// A detached question stays pending: its answer goes by resume, as a follow-up command.
 			this.review(decision.id, "engine_wait_closed");
 		}
 		this.refresh();
@@ -446,7 +461,8 @@ export class DecisionService {
 		for (const decision of this.store.allDecisions(owner.scope)) {
 			if (decision.sourceSessionPath !== owner.sessionPath || decision.method !== "question" ||
 				decision.bindingState !== "live" || !unresolved(decision) || ids.has(decision.sourceRequestId)) continue;
-			this.store.setDecisionBinding(decision.id, decision.revision, { state: "unknown", reason: "request_missing" });
+			this.store.setDecisionBinding(decision.id, decision.revision, detachedQuestion(decision)
+				? { state: "closed", reason: "async_wait_closed" } : { state: "unknown", reason: "request_missing" });
 		}
 		this.refresh();
 	}
@@ -468,7 +484,8 @@ export class DecisionService {
 		if (this.stopped) return;
 		for (const decision of this.store.allDecisions(owner.scope)) {
 			if (decision.sourceSessionPath !== owner.sessionPath || decision.bindingState !== "live" || !unresolved(decision)) continue;
-			this.store.setDecisionBinding(decision.id, decision.revision, { state: "unknown", reason: "owner_disconnected" });
+			this.store.setDecisionBinding(decision.id, decision.revision, detachedQuestion(decision)
+				? { state: "closed", reason: "async_wait_closed" } : { state: "unknown", reason: "owner_disconnected" });
 		}
 		this.refresh();
 	}

package/src/hub.ts

@@ -186,6 +186,7 @@ interface QuestionItem {
 export interface ScopedQuestionFrame {
 	id: string;
 	toolCallId?: string;
+	waitForAnswer?: boolean;
 	questions: QuestionItem[];
 	askedAtMs?: number;
 	deadlineAtMs?: number;
@@ -1786,7 +1787,8 @@ export class Hub {
 		const decision = this.decisions?.observe(owner, {
 			actionId, sourceRequestId: frame.id, method: "question", permission: false,
 			payload: { title: card.title, detail: card.detail, options: [], questions: frame.questions,
-				...(frame.toolCallId ? { toolCallId: frame.toolCallId } : {}) },
+				...(frame.toolCallId ? { toolCallId: frame.toolCallId } : {}),
+				...(frame.waitForAnswer === false ? { waitForAnswer: false } : {}) },
 			deadlineAt: frame.deadlineAtMs ?? null,
 		});
 		const open = this.openQuestionCards(owner.conv, owner.scope);

package/src/main.ts

@@ -29,6 +29,7 @@ import {
 	SYSTEM_NETWORK,
 } from "./enroll.ts";
 import { ACCESS_PATH, handleAccessApi, pingAccess, systemTailscale } from "./cli/access.ts";
+import { CHAT_TOPIC, showsThinking, THINKING_TOPIC, topicOf } from "./client-topics.ts";
 import { APK_DIR, APK_PATH, APP_DOWNLOAD_LINK_PATH, APP_VERSION_PATH, ApkSource, appVersion, createDownloadLink, DownloadLinks, serveApk } from "./app-download.ts";
 import { loadConfig } from "./config.ts";
 import { memoUpdatedData, parseMemoPatch } from "./memo-images.ts";
@@ -142,7 +143,6 @@ const updateApi: UpdateApiDeps = {
 	now: () => new Date(),
 };
 
-const TOPIC = "clients";
 let publish: (envelope: Envelope) => void = () => {};
 const hub = new Hub(
 	store,
@@ -397,6 +397,7 @@ async function handleClient(ws: ServerWebSocket<Conn>, raw: string): Promise<voi
 				// question cannot race into a phone notification between those adjacent frames.
 				questionNotifications.setWebPresence(ws, true);
 			}
+			if (!showsThinking(msg.data?.client)) ws.unsubscribe(THINKING_TOPIC);
 			const state = hub.snapshot();
 			const snapshot = { ...state, approvals: omoCheckNotifications.filterApprovals(state.approvals) };
 			// While omo is reconnecting, Hub intentionally clears its in-memory question cards until
@@ -806,7 +807,10 @@ async function routeApi(req: Request, url: URL): Promise<Response> {
 
 const websocket: WebSocketHandler<Conn> = {
 	open(ws) {
-		if (!ws.data.notifyOnly) ws.subscribe(TOPIC);
+		if (!ws.data.notifyOnly) {
+			ws.subscribe(CHAT_TOPIC);
+			ws.subscribe(THINKING_TOPIC);
+		}
 		if (ws.data.trusted && !ws.data.notifyOnly) ws.subscribe(TRUSTED_TOPIC);
 		const id = ws.data.deviceId;
 		if (id) {
@@ -837,8 +841,9 @@ publish = (e) => {
 	if (!omoCheckNotifications.allow(e)) return;
 	questionNotifications.onEnvelope(e);
 	const text = JSON.stringify(e);
-	trustedServer.publish(TOPIC, text);
-	lanServer?.publish(TOPIC, text);
+	const topic = topicOf(e.type);
+	trustedServer.publish(topic, text);
+	lanServer?.publish(topic, text);
 	// A decision change can change a work's 입력 대기 state (its open decisions, or its status after a delivered answer).
 	if (e.type === "activity.updated" || e.type === "conversation.created" || e.type === "decision.updated") workStatus.schedule();
 };

package/src/store.ts

@@ -215,7 +215,7 @@ export interface WorkStartRequest extends WorkCommandRequest {
 export type WorkReport = Pick<WorkUpdate, "sourceKey" | "kind" | "commandSeq" | "summary" | "details">;
 
 export class WorkStoreError extends Error {
-	constructor(readonly code: "work_not_found" | "command_not_found" | "request_key_conflict" | "report_conflict" | "invalid_report_command" | "invalid_delivery_transition" | "invalid_publish" | "publish_conflict" | "unresolved_work_commands" | "required_decisions_pending" | "question_without_decision", readonly ids: readonly string[] = []) {
+	constructor(readonly code: "work_not_found" | "command_not_found" | "request_key_conflict" | "report_conflict" | "invalid_report_command" | "invalid_delivery_transition" | "invalid_publish" | "publish_conflict" | "unresolved_work_commands" | "required_decisions_pending" | "question_without_decision" | "invalid_replacement_details", readonly ids: readonly string[] = []) {
 		super(code);
 	}
 }
@@ -420,8 +420,12 @@ export function replacementQuestionPayload(payload: Record<string, unknown>): Re
 		options: Array.isArray(withIds.options) ? withIds.options : [] };
 }
 
-/** Closed bindings whose question still takes an answer, delivered to the owner as a follow-up command. */
-export const RESUMABLE_CLOSED: ReadonlySet<string> = new Set(["report_only", "main_released"]);
+/**
+ * Closed bindings whose question still takes an answer, delivered to the owner as a follow-up command. Bug 127:
+ * async_wait_closed (a waitForAnswer false question whose native wait ended) and recheck_incomplete (a recheck turn
+ * ended without a replacement; the question stands as asked). A permission is never resumed (submitDecision, info).
+ */
+export const RESUMABLE_CLOSED: ReadonlySet<string> = new Set(["report_only", "main_released", "async_wait_closed", "recheck_incomplete"]);
 
 /** Checks structural completeness, not the semantic appropriateness of a historical answer. */
 function completeDecisionAnswer(method: DecisionMethod, payload: unknown, response: unknown): boolean {
@@ -1374,7 +1378,14 @@ export class Store {
 			if (command && report.kind !== "observation" && (command.delivery === "pending" || command.delivery === "sending" || command.delivery === "unknown")) {
 				this.setWorkCommandDelivery(command.id, "accepted", { disposition: "work_report" });
 			}
-			if (command && report.kind === "question" && object(report.details) && typeof report.details.replaces_decision_id === "string") {
+			// Bug 127: a question report on a recheck command must carry its replacement as an object; anything else would be
+			// accepted without replacing and leave the old question recheck-only.
+			const replacing = object(report.details) && typeof report.details.replaces_decision_id === "string";
+			if (command && report.kind === "question" && !replacing && object(command.payload) &&
+				(command.payload.decision_operation === "recheck" || command.payload.decision_operation === "request_permission")) {
+				throw new WorkStoreError("invalid_replacement_details", [workId]);
+			}
+			if (command && report.kind === "question" && replacing) {
 				this.replaceDecisionFromReport({
 					scope: `work:${workId}`, sourceSessionPath: work.sessionPath,
 					reportId: report.sourceKey, commandId: command.id, details: report.details,

package/src/work.ts

@@ -85,6 +85,8 @@ const REPORT_RULE = "Report completed or failed with the highest command_seq of
 const QUESTION_WITHOUT_DECISION = "No inbox question is open for this work. Ask the user with ask_user_question first " +
 	"(waitForAnswer true for a required confirmation, which then needs no kind=question report; " +
 	"waitForAnswer false only if the work may continue without the answer and you also report), then send kind=question again. A kind=question report alone creates no inbox question.";
+const INVALID_REPLACEMENT_DETAILS = "This report answers a recheck, so details must be a JSON object, not a string: " +
+	"{replaces_decision_id, submission_id, and replacement:{method,payload,required} or replacement_decision_id}. Send the report again with details as an object.";
 function envelope(command: WorkCommand): string {
 	return PREFIX + JSON.stringify({ version: 1, work_id: command.workId, command_id: command.id, command_seq: command.seq, kind: command.kind, payload: command.payload, report_rule: REPORT_RULE });
 }
@@ -155,7 +157,9 @@ export class WorkRouter {
 		} catch (error) {
 			if (error instanceof RoutingError) return Response.json({ error: error.code }, { status: error.status });
 			if (error instanceof WorkStoreError) return Response.json({ error: error.code, ids: error.ids,
-				...(error.code === "question_without_decision" ? { detail: QUESTION_WITHOUT_DECISION } : {}) }, { status: 409 });
+				...(error.code === "question_without_decision" ? { detail: QUESTION_WITHOUT_DECISION } : {}),
+				...(error.code === "invalid_replacement_details" ? { detail: INVALID_REPLACEMENT_DETAILS } : {}) },
+			{ status: error.code === "invalid_replacement_details" ? 400 : 409 });
 			if (error instanceof DecisionStoreError) return Response.json({ error: error.code }, {
 				status: error.code === "decision_not_found" ? 404 : error.code.startsWith("invalid_") ? 400 : 409,
 			});
@@ -601,7 +605,7 @@ export class WorkRouter {
 			} catch (error) {
 				// The live report call already showed the worker this refusal; recovery skips the entry.
 				// Unresolved commands retain their receipt state; completion needs a new valid report.
-				if (error instanceof WorkStoreError && ["question_without_decision", "unresolved_work_commands"].includes(error.code)) continue;
+				if (error instanceof WorkStoreError && ["question_without_decision", "unresolved_work_commands", "invalid_replacement_details"].includes(error.code)) continue;
 				if (!(error instanceof WorkStoreError) || error.code !== "required_decisions_pending") throw error;
 				deferred = Math.min(deferred, index);
 			}