@h-rig/cli 0.0.6-alpha.77 → 0.0.6-alpha.79

package/dist/src/commands/task-run-driver.d.ts

@@ -0,0 +1,132 @@
+import { type RunnerContext } from "../runner";
+import { updateConfiguredTaskSourceTask } from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import { runPrAutomation, type GitCommandRunner, type GitHubCommandRunner, type PrAutomationResult, type RigAutomationConfig } from "@rig/runtime/control-plane/native/pr-automation";
+import { type SourceTaskContract } from "./_run-driver-helpers";
+export type TaskRunReviewState = {
+    approved?: boolean;
+    provider?: string;
+    mode?: string;
+    verdict?: string;
+    local_reasons?: string[];
+    ai_reasons?: string[];
+    ai_warnings?: string[];
+};
+declare const PI_CANONICAL_RUN_STAGES: readonly ["Connect", "GitHub/task sync", "Prepare workspace", "Launch Pi", "Plan", "Implement", "Validate", "Commit", "Open PR", "Review/CI", "Merge", "Complete"];
+export declare function canonicalPiRunStages(): string[];
+export declare function buildPiRigBridgeEnv(input: {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly taskId: string;
+    readonly serverUrl?: string | null;
+    readonly authToken?: string | null;
+    readonly githubToken?: string | null;
+}): Record<string, string>;
+export declare function applyDirtyBaselineSnapshot(input: {
+    readonly sourceRoot: string;
+    readonly targetRoot: string;
+}): {
+    applied: boolean;
+    copiedUntracked: number;
+    detail: string;
+};
+export declare function buildTaskRunReviewEnv(config?: TaskRunAutomationConfig | null): Record<string, string>;
+export declare function buildDirtyBaselineHandshakeEnv(input: {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly baselineMode?: "head" | "dirty-snapshot";
+}): Record<string, string>;
+type TaskRunAutomationConfig = RigAutomationConfig & {
+    readonly github?: {
+        readonly issueUpdates?: "lifecycle" | "minimal" | "off";
+    };
+    readonly planning?: {
+        readonly mode?: "auto" | "always" | "off";
+        readonly requireForLabels?: readonly string[];
+        readonly skipForLabels?: readonly string[];
+    };
+};
+export declare function resolveTaskRunAutomationLimits(config?: TaskRunAutomationConfig | null, env?: Record<string, string | undefined>): {
+    maxValidationAttempts: number;
+    maxPrFixIterations: number;
+};
+export type PlanningClassification = {
+    readonly planningRequired: boolean;
+    readonly size: "small" | "medium" | "large";
+    readonly risk: "low" | "medium" | "high";
+    readonly reason: string;
+    readonly policy: "always" | "off" | "auto";
+};
+export declare function classifyPlanningNeed(input: {
+    readonly config?: TaskRunAutomationConfig | null;
+    readonly sourceTask?: SourceTaskContract | null;
+}): PlanningClassification;
+export declare function buildPiValidationRetrySteeringPrompt(input: {
+    taskId: string;
+    attempt: number;
+    maxAttempts: number;
+    failureDetail: string;
+    validationOutput?: string | null;
+}): string;
+export declare function classifyValidationRetryOutcome(input: {
+    attempt: number;
+    maxAttempts: number;
+    failureDetail: string;
+}): {
+    stage: "Validate failed";
+    status: "retry" | "needs_attention";
+    failureDetail: string;
+};
+export type TaskRunStageName = typeof PI_CANONICAL_RUN_STAGES[number] | "Needs attention" | "Failed";
+export declare function taskRunStageLogId(runId: string, stage: TaskRunStageName): string;
+export type TaskRunPostValidationLifecycleResult = {
+    readonly status: "completed" | "skipped" | "needs_attention";
+    readonly pr?: PrAutomationResult;
+};
+export declare function runTaskRunPostValidationLifecycle(input: {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly taskId?: string;
+    readonly runtimeTaskId: string;
+    readonly runtimeWorkspace?: string | null;
+    readonly branch?: string | null;
+    readonly config?: TaskRunAutomationConfig | null;
+    readonly sourceTask: SourceTaskContract | null;
+    readonly uploadedSnapshot?: boolean;
+    readonly appendStage?: (stage: TaskRunStageName, detail?: string | null, status?: string, tone?: "info" | "tool" | "error") => void;
+    readonly ghCommand?: GitHubCommandRunner;
+    readonly gitCommand?: GitCommandRunner;
+    readonly prAutomation?: typeof runPrAutomation;
+    readonly steerPi?: (message: string) => Promise<void>;
+    readonly updateTaskSource?: typeof updateConfiguredTaskSourceTask;
+}): Promise<TaskRunPostValidationLifecycleResult>;
+export declare function classifyCompletionVerificationLine(line: string): {
+    isCompletionLine: boolean;
+    isVerifierReview: boolean;
+};
+export declare function createRunLogIdFactory(runId: string): () => string;
+export declare function summarizeTaskRunProcessFailure(input: {
+    exitCode: number | null;
+    signal: string | null;
+    stderrLines?: readonly string[];
+}): string;
+export declare function readTaskRunAcceptedArtifactState(input: {
+    taskId: string | null;
+    workspaceDir: string | null;
+    artifactNotBeforeMs?: number;
+}): {
+    accepted: boolean;
+    reason: string | null;
+};
+export declare function executeRigOwnedTaskRun(context: RunnerContext, input: {
+    runId: string;
+    taskId?: string;
+    title?: string;
+    runtimeAdapter: "claude-code" | "codex" | "pi";
+    model?: string;
+    runtimeMode: string;
+    interactionMode: string;
+    initialPrompt?: string;
+    baselineMode?: "head" | "dirty-snapshot";
+    prMode?: "auto" | "ask" | "off";
+}): Promise<void>;
+export {};

package/dist/src/commands/task-run-driver.js

@@ -728,7 +728,9 @@ ${failure.contextLine}`, 1, { hint: failure.hint });
   })() : null;
   if (!response.ok) {
     const diagnostics = diagnosticMessage(payload);
-    const detail = diagnostics ?? (text || response.statusText);
+    const rawDetail = diagnostics ?? (text || response.statusText);
+    const detail = diagnostics ? rawDetail : rawDetail.split(`
+`).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 200) ?? response.statusText;
     const failure = await buildServerFailureContext(context.projectRoot, server);
     throw new CliError(`Rig server request failed (${response.status}): ${detail}
 ${failure.contextLine}`, 1, { hint: failure.hint });
@@ -779,6 +781,19 @@ function looksLikeGitHubToken(value) {
     return false;
   return /^(gh[opusr]_|github_pat_)/.test(token);
 }
+function isSensitivePayloadKey(key) {
+  return /token|secret|password|authorization|credential/i.test(key);
+}
+function redactSensitivePayload(value) {
+  if (Array.isArray(value))
+    return value.map(redactSensitivePayload);
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+    key,
+    isSensitivePayloadKey(key) && typeof child === "string" && child.trim() ? "[redacted]" : redactSensitivePayload(child)
+  ]));
+}
 function githubBridgeEnv(token) {
   const clean = token?.trim();
   if (!clean)
@@ -1476,7 +1491,7 @@ function appendPiToolTimelineFromRecord(input) {
 }
 function isNonRenderablePiProtocolRecord(record) {
   const type = typeof record.type === "string" ? record.type : "";
-  return type === "agent_start" || type === "agent_end" || type === "message_start" || type === "message_end" || type === "turn_start" || type === "turn_end" || type === "tool_result" || type === "message_update" && (!record.assistantMessageEvent || typeof record.assistantMessageEvent !== "object" || Array.isArray(record.assistantMessageEvent) || record.assistantMessageEvent.type !== "text_delta");
+  return type === "pi.event" || type === "status.update" || type === "activity.update" || type === "ready" || type === "agent_start" || type === "agent_end" || type === "message_start" || type === "message_end" || type === "turn_start" || type === "turn_end" || type === "tool_result" || type === "message_update" && (!record.assistantMessageEvent || typeof record.assistantMessageEvent !== "object" || Array.isArray(record.assistantMessageEvent) || record.assistantMessageEvent.type !== "text_delta");
 }
 function appendToolTimelineFromLog(input) {
   const title = typeof input.log.title === "string" ? input.log.title : "";
@@ -2036,7 +2051,15 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       emitServerRunEvent({ type: "log", runId: input.runId, title });
       return true;
     }
-    return false;
+    appendRunTimeline(context.projectRoot, input.runId, {
+      id: `timeline:${input.runId}:${Date.now()}:wrapper:${event.type}`,
+      type: "wrapper-event",
+      eventType: event.type,
+      payload: redactSensitivePayload(payload),
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "timeline", runId: input.runId });
+    return true;
   };
   const handleAgentStdoutLine = (line) => {
     const trimmed = line.trim();

package/dist/src/commands/task.d.ts

@@ -0,0 +1,14 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+/** Project-config dispatch defaults — exported so the board's `n` (new run)
+ * flow dispatches with exactly the same defaults as `rig task run`. */
+export declare function loadTaskRunProjectDefaults(projectRoot: string): Promise<{
+    runtimeAdapter?: "claude-code" | "codex" | "pi";
+    model?: string;
+    runtimeMode?: string;
+    prMode?: "auto" | "ask" | "off";
+}>;
+export type ReportBugFn = (context: RunnerContext, args: string[]) => Promise<CommandOutcome>;
+export declare function executeTask(context: RunnerContext, args: string[], options: {
+    executeTaskReportBug: ReportBugFn;
+}): Promise<CommandOutcome>;