@lobehub/cli 0.0.43 → 0.0.44

package/dist/index.js

@@ -15606,6 +15606,10 @@ const UserLabSchema = object$2({
 	*/
 	enableMessageTextSelectionActions: boolean().optional(),
 	/**
+	* show OAuth app management in personal and workspace settings
+	*/
+	enableOAuthApps: boolean().optional(),
+	/**
 	* show the "Add Platform Agent" entry in the create menu
 	*/
 	enablePlatformAgent: boolean().optional(),
@@ -253663,7 +253667,7 @@ const ASK_USER_MCP_TOOL_NAME = "mcp__lobe_cc__ask_user_question";
 */
 const ASK_USER_API_NAME = "askUserQuestion";
 const CLAUDE_CODE_CLI_INSTALL_DOCS_URL = "https://docs.anthropic.com/en/docs/claude-code/setup";
-const CLI_AUTH_REQUIRED_PATTERNS = [
+const CLI_AUTH_REQUIRED_PATTERNS$1 = [
 	/failed to authenticate/i,
 	/invalid authentication credentials/i,
 	/authentication[_ ]error/i,
@@ -253879,7 +253883,7 @@ const getApiRetryData = (rawValue) => {
 };
 const getAuthRequiredTerminalError = (result) => {
 	const rawMessage = getCliResultMessage(result);
-	if (!rawMessage || !CLI_AUTH_REQUIRED_PATTERNS.some((pattern) => pattern.test(rawMessage))) return;
+	if (!rawMessage || !CLI_AUTH_REQUIRED_PATTERNS$1.some((pattern) => pattern.test(rawMessage))) return;
 	return {
 		agentType: "claude-code",
 		clearEchoedContent: true,
@@ -255645,18 +255649,10 @@ const computeFileChangeDiff = async (change, cwd, snapshot) => {
 		};
 		return buildFileChangeDiff(filePath, previousContent, "");
 	}
-	if (!snapshot) return {
+	if (!snapshot?.exists || snapshot.content === void 0) return {
 		linesAdded: change.linesAdded ?? 0,
 		linesDeleted: change.linesDeleted ?? 0
 	};
-	if (!snapshot?.exists && !current.exists) return {
-		linesAdded: 0,
-		linesDeleted: 0
-	};
-	if (snapshot?.exists && snapshot.content === void 0) return {
-		linesAdded: 0,
-		linesDeleted: 0
-	};
 	if (current.exists && current.content === void 0) return {
 		linesAdded: 0,
 		linesDeleted: 0
@@ -255913,6 +255909,103 @@ var AgentStreamPipeline = class {
 	}
 };
 
+//#endregion
+//#region ../../packages/heterogeneous-agents/src/spawn/classifyProcessFailure.ts
+/**
+* Process-level failure classification for `lh hetero exec` runs.
+*
+* The stream adapters (`adapters/claudeCode.ts`, `adapters/codex.ts`) classify
+* failures the CLI reports in-stream (overloaded / rate-limit / auth relayed
+* via a `result` event), but a run that dies BEFORE the agent CLI produces any
+* stream — `spawn claude ENOENT`, an auth failure printed straight to stderr —
+* never reaches an adapter. Without classification those runs land on the
+* server as a bare `{ message }` error, so the client renders the generic JSON
+* error card instead of the heterogeneous status guide (install CLI / sign in).
+*
+* This helper mirrors the desktop in-process classifier
+* (`HeterogeneousAgentCtr.getSessionErrorPayload`) for the two guide codes a
+* process-level failure can produce: `cli_not_found` and `auth_required`.
+* The returned shape is persisted verbatim as the `ChatMessageError.body`, so
+* it must carry `agentType` + `code` — that pair is what
+* `isHeterogeneousAgentStatusGuideError` gates the dedicated UI on.
+*/
+/**
+* Node reports a missing executable as an `ErrnoException` with
+* `code: 'ENOENT'` and message `spawn <command> ENOENT`. When only stderr text
+* is available (the raw error object was already flattened into the stderr
+* tail), match the message shape instead. Note ENOENT is also raised for a
+* missing `cwd` — same behavior as the desktop classifier; both mean "this
+* machine can't start the CLI as configured".
+*/
+const SPAWN_ENOENT_PATTERN = /\bspawn .+ ENOENT\b/;
+/** Mirrors `CLI_AUTH_REQUIRED_PATTERNS` in the desktop `HeterogeneousAgentCtr`. */
+const CLI_AUTH_REQUIRED_PATTERNS = [
+	/failed to authenticate/i,
+	/invalid authentication credentials/i,
+	/authentication[_ ]error/i,
+	/not authenticated/i,
+	/\bunauthorized\b/i,
+	/\b401\b/
+];
+const CLI_NOT_FOUND_MESSAGES = {
+	"claude-code": "Claude Code CLI was not found on the machine running this agent. Install it and make sure `claude` can be executed.",
+	"codex": "Codex CLI was not found on the machine running this agent. Install it and make sure `codex` can be executed."
+};
+const AUTH_REQUIRED_MESSAGES = {
+	"claude-code": "Claude Code could not authenticate on the machine running this agent. Sign in again or refresh its credentials, then retry.",
+	"codex": "Codex could not authenticate on the machine running this agent. Sign in again or refresh its credentials, then retry."
+};
+/**
+* Codes/agent types the client renders the dedicated status-guide card for.
+* Must stay in sync with `HETEROGENEOUS_AGENT_STATUS_GUIDE_ERROR_CODES` in
+* `src/features/Conversation/Error/heterogeneous.ts` — that predicate gates the
+* guide UI on the same `agentType` + `code` pair.
+*/
+const STATUS_GUIDE_ERROR_CODES = new Set([
+	"auth_required",
+	"cli_not_found",
+	"overloaded",
+	"rate_limit"
+]);
+const STATUS_GUIDE_AGENT_TYPES = new Set([
+	"amp",
+	"claude-code",
+	"codex"
+]);
+/**
+* Whether a terminal error payload (an adapter's in-stream `error` event data,
+* or a persisted `ChatMessageError.body`) is a structured status-guide error —
+* i.e. carries the `agentType` + `code` pair the client's guide UI gates on.
+*/
+const isHeteroStatusGuideErrorData = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const { agentType, code } = value;
+	return typeof agentType === "string" && STATUS_GUIDE_AGENT_TYPES.has(agentType) && typeof code === "string" && STATUS_GUIDE_ERROR_CODES.has(code);
+};
+/**
+* Classify a process-level run failure into a structured status-guide error,
+* or `undefined` when the failure isn't one the guide UI can act on (the
+* caller should then keep its flat `{ message }` error).
+*/
+const classifyHeteroProcessFailure = (params) => {
+	const { agentType, errnoCode } = params;
+	const detail = params.detail?.trim();
+	const cliNotFoundMessage = CLI_NOT_FOUND_MESSAGES[agentType];
+	if (!cliNotFoundMessage) return;
+	if (errnoCode === "ENOENT" || detail && SPAWN_ENOENT_PATTERN.test(detail)) return {
+		agentType,
+		code: "cli_not_found",
+		message: cliNotFoundMessage,
+		...detail ? { stderr: detail } : {}
+	};
+	if (detail && CLI_AUTH_REQUIRED_PATTERNS.some((pattern) => pattern.test(detail))) return {
+		agentType,
+		code: "auth_required",
+		message: AUTH_REQUIRED_MESSAGES[agentType],
+		stderr: detail
+	};
+};
+
 //#endregion
 //#region ../../packages/heterogeneous-agents/src/spawn/cliSpawn.ts
 const WINDOWS_EXE_EXT_PATTERN = /\.exe$/i;
@@ -257242,6 +257335,37 @@ const exec$1 = async (options) => {
 		})();
 	}
 	/**
+	* Build the `finish` error payload. Process-level failures the agent CLI
+	* never got to report in-stream (spawn ENOENT because the CLI isn't
+	* installed, an auth failure printed straight to stderr) are classified into
+	* the structured status-guide shape and attached as `body`, so the client
+	* renders the dedicated install/sign-in guide instead of the generic error
+	* card. Unclassifiable failures keep the flat `{ message, type }` everything
+	* downstream already handles.
+	*
+	* A classified error is always typed `AgentRuntimeError` — matching how the
+	* adapters' in-stream classified errors (overloaded / rate_limit) persist —
+	* instead of leaking the transport-internal `type` the failure happened to
+	* surface through (`stream_error` for a spawn ENOENT reads wrong on a
+	* "CLI not installed" error).
+	*/
+	const buildFinishError = (message, type, errnoCode) => {
+		const classified = classifyHeteroProcessFailure({
+			agentType,
+			detail: message,
+			errnoCode
+		});
+		if (!classified) return {
+			message,
+			type
+		};
+		return {
+			body: { ...classified },
+			message: classified.message,
+			type: "AgentRuntimeError"
+		};
+	};
+	/**
 	* Spawn one agent process and stream all its events into the server ingester.
 	*
 	* When `interceptResumeErrors` is true, any `error`-type event whose
@@ -257261,6 +257385,12 @@ const exec$1 = async (options) => {
 	*                      and still exit 0, so the exit code alone is not enough)
 	*   terminalErrorMessage — the message from that terminal `error` event, used
 	*                      as the task-level error detail in the finish payload
+	*   terminalErrorData — the full structured payload of that terminal `error`
+	*                      event when the adapter already classified it into a
+	*                      status-guide error (overloaded / rate_limit / …); the
+	*                      finish leg forwards it verbatim as the error `body` so
+	*                      the client renders the dedicated guide instead of the
+	*                      generic error card
 	*   stderrContent  — accumulated stderr (only when interceptResumeErrors=true)
 	*/
 	const runOneAgent = async (spawnOpts, interceptResumeErrors, runLabel) => {
@@ -257278,10 +257408,7 @@ const exec$1 = async (options) => {
 			if (serverIngester && sink) try {
 				await serverIngester.drain();
 				await sink.finish({
-					error: {
-						message,
-						type: "AgentRuntimeError"
-					},
+					error: buildFinishError(message, "AgentRuntimeError"),
 					result: "error"
 				});
 			} catch {}
@@ -257328,6 +257455,7 @@ const exec$1 = async (options) => {
 		let resumeNotFound = false;
 		let sawTerminalError = false;
 		let terminalErrorMessage;
+		let terminalErrorData;
 		const ingestError = false;
 		try {
 			for await (const event of handle.events) {
@@ -257343,6 +257471,7 @@ const exec$1 = async (options) => {
 					sawTerminalError = true;
 					const data = event.data;
 					terminalErrorMessage = String(data?.message ?? data?.error ?? "") || void 0;
+					terminalErrorData = isHeteroStatusGuideErrorData(data) ? data : void 0;
 				}
 				if (emitJsonl) process.stdout.write(`${JSON.stringify(event)}\n`);
 				serverIngester?.push(event);
@@ -257352,10 +257481,7 @@ const exec$1 = async (options) => {
 			if (serverIngester && sink) try {
 				await serverIngester.drain();
 				await sink.finish({
-					error: {
-						message: String(err),
-						type: "stream_error"
-					},
+					error: buildFinishError(String(err), "stream_error", err?.code),
 					result: "error"
 				});
 			} catch {}
@@ -257377,6 +257503,7 @@ const exec$1 = async (options) => {
 			sessionId: handle.sessionId,
 			signal,
 			stderrContent,
+			terminalErrorData,
 			terminalErrorMessage
 		};
 	};
@@ -257423,10 +257550,11 @@ const exec$1 = async (options) => {
 		const exitedClean = !result.ingestError && !result.sawTerminalError && (code === 0 || signal === "SIGTERM");
 		const stderrTail = result.stderrContent.trim();
 		const errorDetail = result.terminalErrorMessage || stderrTail;
-		const finishError = !exitedClean && errorDetail ? {
-			message: errorDetail.slice(-1024),
+		const finishError = exitedClean ? void 0 : result.terminalErrorData ? {
+			body: { ...result.terminalErrorData },
+			message: String(result.terminalErrorData.message ?? errorDetail ?? ""),
 			type: "AgentRuntimeError"
-		} : void 0;
+		} : errorDetail ? buildFinishError(errorDetail.slice(-1024), "AgentRuntimeError") : void 0;
 		try {
 			await sink.finish({
 				error: finishError,
@@ -263078,6 +263206,22 @@ function registerUserCommand(program) {
 //#endregion
 //#region ../../packages/const/src/verify.ts
 /**
+* The kind of thing a verification session checks. Orthogonal to `source` (which
+* records what *produced* the run): `scenario` drives how the report renders its
+* scope header and scenario-specific detail. Open-ended — new scenarios add a
+* value here plus their own `VerifyRunContext` shape.
+* - coding:   verifying a software change (branch / commit / surfaces under test).
+* - writing:  verifying a written deliverable (manuscript / chapters / documents).
+* - research: verifying a research deliverable (question / sources / claims).
+* - generic:  any other delivery — no modeled scope; context is an open bag.
+*/
+const verifyRunScenarios = [
+	"coding",
+	"writing",
+	"research",
+	"generic"
+];
+/**
 * The product surface a check was exercised on — *where* it ran, never *what
 * kind* of test it was. `unit` / `backend` / `type-check` are test kinds and do
 * not belong here; a backend change verified through the CLI has surface `cli`.
@@ -263163,6 +263307,12 @@ const statusColor$1 = (status) => {
 	if (status === "delivered") return import_picocolors.default.yellow(status);
 	return import_picocolors.default.dim(status);
 };
+/** The user's standing verdict on one union check, for the USER column. */
+const userGlyph = (userReview) => {
+	if (!userReview) return import_picocolors.default.dim("· pending");
+	if (userReview.action === "accept") return import_picocolors.default.green("✓ accepted");
+	return userReview.stale ? import_picocolors.default.dim("· pending") : import_picocolors.default.red("✗ rejected");
+};
 function registerAcceptanceCommands(verify) {
 	const acceptance = verify.command("acceptance").description("Manage subject-level delivery acceptances (the cross-round union of verify sessions)");
 	acceptance.command("list").description("List acceptances, newest first").option("--json [fields]", "Output JSON").action(async (options) => {
@@ -263203,20 +263353,36 @@ function registerAcceptanceCommands(verify) {
 		if (latestReport?.summary) console.log(`${import_picocolors.default.bold("summary")}: ${latestReport.summary}`);
 		console.log();
 		printTable(checks.map((c) => [
+			`C${c.seq}`,
 			truncate(c.title, 46),
 			stateGlyph(c.state),
+			userGlyph(c.userReview),
 			c.required ? "gate" : "soft",
 			c.surface ?? "",
 			c.fixed ? "fixed" : c.carriedFromRound !== void 0 ? `carried r${c.carriedFromRound}` : "",
 			c.history.map((h) => `r${h.roundIndex}:${h.state}`).join(" → ")
 		]), [
+			"C#",
 			"CHECK",
 			"FINAL",
+			"USER",
 			"BLOCK",
 			"SURFACE",
 			"NOTE",
 			"HISTORY"
 		]);
+		const withFeedback = checks.filter((c) => c.reviews.some((r) => r.action === "reject"));
+		if (withFeedback.length > 0) {
+			console.log();
+			console.log(import_picocolors.default.bold("user feedback"));
+			for (const c of withFeedback) for (const review of c.reviews) {
+				if (review.action !== "reject") continue;
+				const marker = (c.userReview && !c.userReview.stale ? c.reviews.at(-1) === review : false) ? import_picocolors.default.red("▶ actionable") : import_picocolors.default.dim("· addressed");
+				console.log(`  ${marker} C${c.seq} ${truncate(c.title, 60)} ${import_picocolors.default.dim(`[${c.id}] (r${review.roundIndex})`)}`);
+				if (review.comment) console.log(`      ${review.comment}`);
+				for (const annotation of review.annotations ?? []) if (annotation.comment) console.log(`      ${import_picocolors.default.dim("region:")} ${annotation.comment}`);
+			}
+		}
 		console.log();
 		printTable(rounds.map((r) => [
 			`r${r.run.roundIndex}`,
@@ -263312,6 +263478,18 @@ function toVerdict(raw) {
 	].includes(s)) return "failed";
 	return "uncertain";
 }
+/**
+* The report's headline verdict when the author didn't set `summary.verdict`:
+* derived from the ingested cases, so a report can never ship verdict-less and
+* render as a permanent "?" in every list surface.
+*/
+function deriveReportVerdict(cases) {
+	const verdicts = cases.map((c) => toVerdict(c?.result ?? c?.verdict));
+	if (verdicts.length === 0) return void 0;
+	if (verdicts.includes("failed")) return "failed";
+	if (verdicts.includes("uncertain")) return "uncertain";
+	return "passed";
+}
 /** Pick an evidence medium from a file extension. */
 function evidenceTypeForFile(file) {
 	const ext = path.extname(file).toLowerCase().slice(1);
@@ -263466,6 +263644,35 @@ function surfacesFromResult(result) {
 	}
 	return canonical.length > 0 ? canonical : void 0;
 }
+/**
+* What kind of delivery the report verified. Defaults to `coding` — the
+* agent-testing harness's home turf — and rejects an unknown value rather than
+* storing a scenario nothing renders (mirrors the strict surface policy: the
+* author still has the context to fix it).
+*/
+function scenarioFromResult(result) {
+	const raw = result.scenario;
+	if (raw === void 0) return "coding";
+	if (typeof raw === "string" && verifyRunScenarios.includes(raw)) return raw;
+	log$10.error(`result.json "scenario" must be one of: ${verifyRunScenarios.join(", ")} — rejected: ${JSON.stringify(raw)}`);
+	process.exit(1);
+}
+/**
+* A non-coding scenario's scope, passed through from result.json `context` as
+* the scenario's own bag (the server stores it as-is; known shapes live in
+* `@lobechat/types`). Top-level `entry` / `createdAt` are lifted as defaults so
+* every scenario gets the shared provenance fields for free; explicit `context`
+* keys win.
+*/
+function genericContextFromResult(result) {
+	const bag = objectValue(result.context) ?? {};
+	const entries = Object.entries({
+		entry: firstString(result.entry),
+		testedAt: firstString(result.createdAt),
+		...bag
+	}).filter(([, v]) => v !== void 0);
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
 /** Reject an out-of-vocabulary plan value rather than storing a word nothing reads. */
 function assertPlanEnum(value, allowed, field, itemId) {
 	if (allowed.includes(value)) return value;
@@ -263492,12 +263699,9 @@ function assertPlanEnum(value, allowed, field, itemId) {
 * no enum can carry. Everything else the frozen {@link VerifyCheckItem} needs is
 * filled in here, so an author writes only `{ id, title }` plus what they mean.
 *
-* Returns `undefined` only when the report declares no `plan` field at all —
-* "leave whatever is stored alone". A `plan` that IS present but empty returns
-* `[]`, which CLEARS the stored one. The distinction matters on a re-ingest of a
-* reused report dir: a previous round's plan would otherwise stay attached, and
-* every one of its items would render as "not run" against a report that never
-* planned them.
+* Returns `undefined` when the report declares no `plan` field. A `plan` that is
+* present but empty returns `[]`, recording an explicitly empty plan in this
+* immutable snapshot.
 */
 function planFromResult(result) {
 	if (!Array.isArray(result.plan)) return void 0;
@@ -263611,28 +263815,13 @@ function subjectFromResult(result) {
 		requirement: firstString(value.requirement)
 	} : null;
 }
-/**
-* The report dir remembers which verification session it created, so
-* re-verifying the same case updates one evolving `/verify/<id>` in place
-* instead of spawning a fresh list entry every round. Kept in a sidecar (not
-* result.json, which the harness regenerates each round) so it survives a
-* rewrite of the report body.
-*/
-const RUN_SIDECAR = ".verify-run.json";
-function readSidecarRunId(dir) {
-	const p = path.join(dir, RUN_SIDECAR);
-	if (!existsSync(p)) return void 0;
-	try {
-		const parsed = JSON.parse(readFileSync$1(p, "utf8"));
-		return typeof parsed?.verifyRunId === "string" ? parsed.verifyRunId : void 0;
-	} catch {
-		return;
-	}
-}
-function writeSidecarRunId(dir, verifyRunId) {
-	try {
-		writeFileSync(path.join(dir, RUN_SIDECAR), `${JSON.stringify({ verifyRunId }, null, 2)}\n`);
-	} catch {}
+/** Default acceptance subject for a report authored inside a LobeHub topic. */
+function subjectFromEnv() {
+	const topicId = firstString(process.env.LOBEHUB_TOPIC_ID);
+	return topicId ? {
+		subjectId: topicId,
+		subjectType: "topic"
+	} : null;
 }
 function registerVerifyCommand(program) {
 	const verify = program.command("verify").description("Manage the Agent Run delivery checker (criteria, rubrics, plans, results)");
@@ -264111,7 +264300,7 @@ function registerVerifyCommand(program) {
 		});
 		console.log(`${import_picocolors.default.green("✓")} Recorded ${import_picocolors.default.bold(decision)} on result ${import_picocolors.default.bold(resultId)}`);
 	});
-	verify.command("ingest-report <reportDir>").description("Ingest a local agent-testing report (result.json + report.md + assets) as a verify session").option("--source <source>", "agent | agent-testing", "agent-testing").option("--operation <id>", "Link the session to an existing Agent Run").option("--title <title>", "Override the session title").option("--goal <goal>", "The goal/task being verified").option("--run <verifyRunId>", "Update an existing session in place instead of creating one").option("--new", "Force a fresh session even if this report dir already created one").option("--subject <type:id>", "Chain this session onto the subject's acceptance as its next round (task:<id> | topic:<id> | document:<id>)").option("--requirement <text>", "Acceptance requirement recorded when the aggregate is first created").option("--open", "Print the in-app URL to open the report").option("--json [fields]", "Output JSON").action(async (reportDir, options) => {
+	verify.command("ingest-report <reportDir>").description("Ingest a local agent-testing report (result.json + report.md + assets) as a verify session").option("--source <source>", "agent | agent-testing", "agent-testing").option("--operation <id>", "Link the session to an existing Agent Run").option("--title <title>", "Override the session title").option("--goal <goal>", "The goal/task being verified").option("--subject <type:id>", "Override the required acceptance subject (defaults to the current LOBEHUB_TOPIC_ID)").option("--requirement <text>", "Acceptance requirement recorded when the aggregate is first created").option("--open", "Print the in-app URL to open the report").option("--json [fields]", "Output JSON").action(async (reportDir, options) => {
 		const dir = path.resolve(reportDir);
 		const resultPath = path.join(dir, "result.json");
 		if (!existsSync(resultPath)) {
@@ -264129,20 +264318,24 @@ function registerVerifyCommand(program) {
 		const summary = result.summary ?? {};
 		const reportMdPath = path.join(dir, "report.md");
 		const content = existsSync(reportMdPath) ? readFileSync$1(reportMdPath, "utf8") : void 0;
-		const branch = typeof result.branch === "string" ? result.branch : void 0;
-		const surfaces = surfacesFromResult(result);
-		const pullRequest = pullRequestFromResult(result) ?? pullRequestFromBranch(branch);
-		const contextEntries = Object.entries({
-			branch,
-			commit: typeof result.commit === "string" ? result.commit : void 0,
-			entry: typeof result.entry === "string" ? result.entry : void 0,
-			pullRequest,
-			surfaces,
-			testedAt: typeof result.createdAt === "string" ? result.createdAt : void 0
-		}).filter(([, v]) => v !== void 0);
-		const context = contextEntries.length > 0 ? Object.fromEntries(contextEntries) : void 0;
+		const scenario = scenarioFromResult(result);
+		let context;
+		let pullRequest;
+		if (scenario === "coding") {
+			const branch = typeof result.branch === "string" ? result.branch : void 0;
+			const surfaces = surfacesFromResult(result);
+			pullRequest = pullRequestFromResult(result) ?? pullRequestFromBranch(branch);
+			const contextEntries = Object.entries({
+				branch,
+				commit: typeof result.commit === "string" ? result.commit : void 0,
+				entry: typeof result.entry === "string" ? result.entry : void 0,
+				pullRequest,
+				surfaces,
+				testedAt: typeof result.createdAt === "string" ? result.createdAt : void 0
+			}).filter(([, v]) => v !== void 0);
+			context = contextEntries.length > 0 ? Object.fromEntries(contextEntries) : void 0;
+		} else context = genericContextFromResult(result);
 		const plan = planFromResult(result);
-		const scenario = result.scenario === "coding" ? "coding" : "coding";
 		let subject = subjectFromResult(result);
 		if (options.subject) {
 			const ref = parseSubjectRef(options.subject);
@@ -264154,45 +264347,25 @@ function registerVerifyCommand(program) {
 				ref,
 				requirement: subject?.requirement
 			};
-		} else if (result.subject && !subject) log$10.warn("result.json `subject` is malformed — ignoring it (expected \"type:id\" or {type,id})");
+		} else if (result.subject && !subject) {
+			log$10.error("result.json `subject` is malformed (expected \"type:id\" or {type,id})");
+			process.exit(1);
+		} else if (!subject) {
+			const ref = subjectFromEnv();
+			if (ref) subject = { ref };
+		}
+		if (!subject) {
+			log$10.error("Acceptance subject is required: run inside a LobeHub topic or pass --subject task:<id> | topic:<id> | document:<id>");
+			process.exit(1);
+		}
 		const requirement = options.requirement ?? subject?.requirement;
 		const client = await getTrpcClient();
 		const goal = options.goal ?? (typeof result.focus === "string" ? result.focus : void 0);
 		const title = options.title ?? result.title;
+		if (!title) log$10.warn("result.json has no \"title\" — the run will list as untitled; set result.title (or pass --title)");
 		const origin = originFromEnv();
 		const newRunMetadata = metadataForReport(result, void 0, origin);
-		const rememberedRunId = options.new ? void 0 : options.run ?? readSidecarRunId(dir);
-		let runId;
-		let reused = false;
-		if (rememberedRunId) {
-			const existing = await client.verify.getRun.query({ verifyRunId: rememberedRunId });
-			if (existing && existing.userDecision) {
-				if (options.run) {
-					log$10.error(`Session ${options.run} already carries a user decision (${existing.userDecision}) — drop --run so a new round is created`);
-					process.exit(1);
-				}
-				log$10.info(`Recorded session was already decided (${existing.userDecision}) — starting a new round`);
-			} else if (existing) {
-				reused = true;
-				runId = existing.id;
-				const metadata = metadataForReport(result, existing.metadata, origin);
-				await client.verify.updateRun.mutate({
-					value: {
-						context,
-						goal,
-						metadata,
-						plan,
-						scenario,
-						title
-					},
-					verifyRunId: runId
-				});
-			} else if (options.run) {
-				log$10.error(`Verification session not found: ${options.run}`);
-				process.exit(1);
-			} else log$10.warn(`Recorded session ${rememberedRunId} no longer exists — creating a new one`);
-		}
-		if (!reused) runId = (await client.verify.createRun.mutate({
+		const runId = (await client.verify.createRun.mutate({
 			context,
 			goal,
 			metadata: newRunMetadata,
@@ -264202,19 +264375,15 @@ function registerVerifyCommand(program) {
 			source: options.source,
 			title
 		})).id;
-		let acceptanceId;
-		if (subject) {
-			const acceptance = await client.acceptance.ensure.mutate({
-				requirement,
-				subjectId: subject.ref.subjectId,
-				subjectType: subject.ref.subjectType
-			});
-			acceptanceId = acceptance.id;
-			await client.acceptance.attachRun.mutate({
-				acceptanceId: acceptance.id,
-				verifyRunId: runId
-			});
-		}
+		const acceptanceId = (await client.acceptance.ensure.mutate({
+			requirement,
+			subjectId: subject.ref.subjectId,
+			subjectType: subject.ref.subjectType
+		})).id;
+		await client.acceptance.attachRun.mutate({
+			acceptanceId,
+			verifyRunId: runId
+		});
 		const seenCheckItemIds = /* @__PURE__ */ new Set();
 		let evidenceCount = 0;
 		let inlined = 0;
@@ -264234,10 +264403,6 @@ function registerVerifyCommand(program) {
 				verifierType: "agent",
 				verifyRunId: runId
 			});
-			if (reused) {
-				const prior = await client.verify.listEvidence.query({ checkResultId: checkResult.id });
-				for (const ev of prior) await client.verify.deleteEvidence.mutate({ id: ev.id });
-			}
 			for (const evidenceInput of reportEvidence(c.evidence)) {
 				const rel = evidenceInput.path;
 				const abs = path.isAbsolute(rel) ? rel : path.join(dir, rel);
@@ -264275,18 +264440,9 @@ function registerVerifyCommand(program) {
 			summary: conclusion,
 			totalChecks: summary.total ?? cases.length,
 			uncertainChecks: (summary.blocked ?? 0) + (summary.uncertain ?? 0) || void 0,
-			verdict: summary.verdict ? toVerdict(summary.verdict) : void 0,
+			verdict: summary.verdict ? toVerdict(summary.verdict) : deriveReportVerdict(cases),
 			verifyRunId: runId
 		});
-		let pruned = 0;
-		if (reused) {
-			const existingResults = await client.verify.listResultsByRun.query({ verifyRunId: runId });
-			for (const r of existingResults) if (!seenCheckItemIds.has(r.checkItemId)) {
-				await client.verify.deleteResult.mutate({ id: r.id });
-				pruned += 1;
-			}
-		}
-		writeSidecarRunId(dir, runId);
 		const unplanned = plan?.length ? [...seenCheckItemIds].filter((id) => !plan.some((item) => item.id === id)) : [];
 		if (options.json !== void 0) {
 			outputJson({
@@ -264296,28 +264452,26 @@ function registerVerifyCommand(program) {
 				inlined,
 				origin,
 				planItems: plan?.length ?? 0,
-				pruned,
 				pullRequest,
-				reused,
-				subject: subject?.ref,
+				scenario,
+				subject: subject.ref,
 				unplanned,
 				verifyRunId: runId
 			}, typeof options.json === "string" ? options.json : void 0);
 			return;
 		}
-		const verb = reused ? "Updated" : "Ingested";
-		console.log(`${import_picocolors.default.green("✓")} ${verb} ${import_picocolors.default.bold(String(cases.length))} case(s), ${import_picocolors.default.bold(String(evidenceCount))} evidence artifact(s)${inlined > 0 ? `, ${import_picocolors.default.bold(String(inlined))} inline` : ""}${pruned > 0 ? `, pruned ${import_picocolors.default.bold(String(pruned))} stale case(s)` : ""}`);
+		console.log(`${import_picocolors.default.green("✓")} Ingested ${import_picocolors.default.bold(String(cases.length))} case(s), ${import_picocolors.default.bold(String(evidenceCount))} evidence artifact(s)${inlined > 0 ? `, ${import_picocolors.default.bold(String(inlined))} inline` : ""}`);
 		if (plan?.length) {
 			const unexecuted = plan.filter((item) => !seenCheckItemIds.has(item.id));
 			console.log(`${import_picocolors.default.bold("plan")}: ${plan.length} item(s)${unexecuted.length > 0 ? import_picocolors.default.yellow(` — ${unexecuted.length} planned but not executed`) : ""}${unplanned.length > 0 ? import_picocolors.default.dim(` — ${unplanned.length} unplanned case(s)`) : ""}`);
-		} else if (plan && reused) console.log(`${import_picocolors.default.bold("plan")}: ${import_picocolors.default.dim("none — cleared the previously stored plan")}`);
+		}
 		if (pullRequest?.url) console.log(`${import_picocolors.default.bold("pr")}: ${pullRequest.url}`);
 		if (origin?.topicId) console.log(`${import_picocolors.default.bold("origin topic")}: ${origin.topicId}`);
-		console.log(`${import_picocolors.default.bold("verifyRunId")}: ${runId}${reused ? import_picocolors.default.dim(" (updated in place)") : ""}`);
-		if (acceptanceId) console.log(`${import_picocolors.default.bold("acceptance")}: ${acceptanceId} ${import_picocolors.default.dim(`(${subject.ref.subjectType}:${subject.ref.subjectId})`)}`);
+		console.log(`${import_picocolors.default.bold("verifyRunId")}: ${runId} ${import_picocolors.default.dim("(immutable snapshot)")}`);
+		console.log(`${import_picocolors.default.bold("acceptance")}: ${acceptanceId} ${import_picocolors.default.dim(`(${subject.ref.subjectType}:${subject.ref.subjectId})`)}`);
 		if (options.open) {
 			console.log(`${import_picocolors.default.bold("open")}: /verify/${runId}`);
-			if (acceptanceId) console.log(`${import_picocolors.default.bold("open acceptance")}: /acceptance/${acceptanceId}`);
+			console.log(`${import_picocolors.default.bold("open acceptance")}: /acceptance/${acceptanceId}`);
 		}
 	});
 }

package/man/man1/lh.1

@@ -1,6 +1,6 @@
 .\" Code generated by `npm run man:generate`; DO NOT EDIT.
 .\" Manual command details come from the Commander command tree.
-.TH LH 1 "" "@lobehub/cli 0.0.43" "User Commands"
+.TH LH 1 "" "@lobehub/cli 0.0.44" "User Commands"
 .SH NAME
 lh \- LobeHub CLI \- manage and connect to LobeHub services
 .SH SYNOPSIS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/cli",
-  "version": "0.0.43",
+  "version": "0.0.44",
   "type": "module",
   "bin": {
     "lh": "./dist/index.js",
@@ -35,14 +35,14 @@
     "typescript": "^6.0.3",
     "ws": "^8.21.0",
     "@lobechat/agent-gateway-client": "1.0.0",
-    "@lobechat/device-gateway-client": "1.0.0",
     "@lobechat/device-control": "1.0.0",
+    "@lobechat/heterogeneous-agents": "1.0.0",
+    "@lobechat/device-gateway-client": "1.0.0",
+    "@lobechat/device-identity": "1.0.0",
     "@lobechat/const": "1.0.0",
     "@lobechat/local-file-shell": "1.0.0",
     "@lobechat/tool-runtime": "1.0.0",
-    "@lobechat/types": "1.0.0",
-    "@lobechat/heterogeneous-agents": "1.0.0",
-    "@lobechat/device-identity": "1.0.0"
+    "@lobechat/types": "1.0.0"
   },
   "publishConfig": {
     "access": "public",