@gajae-code/coding-agent 0.2.0 → 0.2.2

package/src/skill-state/workflow-state-contract.ts

@@ -0,0 +1,121 @@
+import * as path from "node:path";
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill, SKILL_ACTIVE_STATE_FILE } from "./active-state";
+
+export type { CanonicalGjcWorkflowSkill };
+
+export const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export const WORKFLOW_STATE_RECEIPT_FRESH_MS = 30 * 60 * 1000;
+
+export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
+export type WorkflowStateReceiptStatus = "fresh" | "stale";
+
+export interface WorkflowStateReceipt {
+	version: 1;
+	skill: CanonicalGjcWorkflowSkill;
+	owner: WorkflowStateMutationOwner;
+	command: string;
+	state_path: string;
+	storage_path: string;
+	mutated_at: string;
+	fresh_until: string;
+	status: WorkflowStateReceiptStatus;
+	mutation_id: string;
+}
+
+function safeString(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+function encodePathSegment(value: string): string {
+	return encodeURIComponent(value).replaceAll(".", "%2E");
+}
+
+export function workflowModeStateFileName(skill: CanonicalGjcWorkflowSkill): string {
+	return `${skill}-state.json`;
+}
+
+export function workflowStateStoragePath(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): string {
+	const normalizedSessionId = safeString(sessionId).trim();
+	if (normalizedSessionId) {
+		return path.join(
+			cwd,
+			".gjc",
+			"state",
+			"sessions",
+			encodePathSegment(normalizedSessionId),
+			workflowModeStateFileName(skill),
+		);
+	}
+	return path.join(cwd, ".gjc", "state", workflowModeStateFileName(skill));
+}
+
+export function workflowActiveStatePath(cwd: string, sessionId?: string): string {
+	const normalizedSessionId = safeString(sessionId).trim();
+	if (normalizedSessionId) {
+		return path.join(
+			cwd,
+			".gjc",
+			"state",
+			"sessions",
+			encodePathSegment(normalizedSessionId),
+			SKILL_ACTIVE_STATE_FILE,
+		);
+	}
+	return path.join(cwd, ".gjc", "state", SKILL_ACTIVE_STATE_FILE);
+}
+
+export function buildWorkflowStateReceipt(input: {
+	cwd: string;
+	skill: CanonicalGjcWorkflowSkill;
+	owner: WorkflowStateMutationOwner;
+	command: string;
+	sessionId?: string;
+	nowIso?: string;
+	mutationId?: string;
+}): WorkflowStateReceipt {
+	const mutatedAt = input.nowIso ?? new Date().toISOString();
+	const freshUntil = new Date(Date.parse(mutatedAt) + WORKFLOW_STATE_RECEIPT_FRESH_MS).toISOString();
+	return {
+		version: WORKFLOW_STATE_RECEIPT_VERSION,
+		skill: input.skill,
+		owner: input.owner,
+		command: input.command,
+		state_path: workflowActiveStatePath(input.cwd, input.sessionId),
+		storage_path: workflowStateStoragePath(input.cwd, input.skill, input.sessionId),
+		mutated_at: mutatedAt,
+		fresh_until: freshUntil,
+		status: "fresh",
+		mutation_id: input.mutationId ?? `${input.skill}:${mutatedAt}`,
+	};
+}
+
+export function workflowReceiptStatus(
+	receipt: WorkflowStateReceipt | undefined,
+	nowMs = Date.now(),
+): WorkflowStateReceiptStatus | undefined {
+	if (!receipt) return undefined;
+	const freshUntilMs = Date.parse(receipt.fresh_until);
+	if (!Number.isFinite(freshUntilMs)) return "stale";
+	return nowMs <= freshUntilMs ? "fresh" : "stale";
+}
+
+export function canonicalWorkflowSkill(value: string): CanonicalGjcWorkflowSkill | null {
+	return (CANONICAL_GJC_WORKFLOW_SKILLS as readonly string[]).includes(value)
+		? (value as CanonicalGjcWorkflowSkill)
+		: null;
+}
+
+export function sanctionedWorkflowStateCommand(skill: CanonicalGjcWorkflowSkill): string {
+	return `gjc state ${skill} write --input '<json>'`;
+}
+
+export function describeWorkflowStateContract(skill: CanonicalGjcWorkflowSkill): string[] {
+	return [
+		`Sanctioned mutation path: gjc state ${skill} read|write --input '<json>'`,
+		`Canonical active HUD state: .gjc/state/${SKILL_ACTIVE_STATE_FILE} and .gjc/state/sessions/<session>/${SKILL_ACTIVE_STATE_FILE}`,
+		`Skill mode state: .gjc/state/${workflowModeStateFileName(skill)} or .gjc/state/sessions/<session>/${workflowModeStateFileName(skill)}`,
+		"Receipts include version, skill, owner, command, state_path, storage_path, mutated_at, fresh_until, status, and mutation_id.",
+		"Receipts are fresh for 30 minutes; older receipts are stale and render as HUD warnings.",
+		"Planning artifacts under .gjc/specs/** and .gjc/plans/** remain writable outside the state command.",
+	];
+}

package/src/slash-commands/acp-builtins.ts

@@ -1,5 +1,9 @@
 import type { AvailableCommand } from "@agentclientprotocol/sdk";
-import { BUILTIN_SLASH_COMMANDS_INTERNAL, lookupBuiltinSlashCommand } from "./builtin-registry";
+import {
+	BUILTIN_SLASH_COMMANDS_INTERNAL,
+	formatUnknownBuiltinSlashCommandDiagnostic,
+	lookupBuiltinSlashCommand,
+} from "./builtin-registry";
 import { parseSlashCommand } from "./helpers/parse";
 import type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
 
@@ -39,7 +43,12 @@ export async function executeAcpBuiltinSlashCommand(
 	const parsed = parseSlashCommand(text);
 	if (!parsed) return false;
 	const command = lookupBuiltinSlashCommand(parsed.name);
-	if (!command?.handle) return false;
+	if (!command?.handle) {
+		const diagnostic = formatUnknownBuiltinSlashCommandDiagnostic(parsed.name);
+		if (!diagnostic) return false;
+		await runtime.output(diagnostic);
+		return { consumed: true };
+	}
 	const result = await command.handle(parsed, runtime);
 	if (result === undefined) return { consumed: true };
 	return result;

package/src/slash-commands/builtin-registry.ts

@@ -202,17 +202,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
-	{
-		name: "loop",
-		description:
-			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
-		inlineHint: "[count|duration]",
-		allowArgs: true,
-		handleTui: async (command, runtime) => {
-			await runtime.ctx.handleLoopCommand(command.args);
-			runtime.ctx.editor.setText("");
-		},
-	},
 	{
 		name: "goal",
 		description: "Toggle goal mode (persistent autonomous objective for this session)",
@@ -222,7 +211,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			{ name: "pause", description: "Pause the current goal" },
 			{ name: "resume", description: "Resume a paused goal" },
 			{ name: "drop", description: "Drop the current goal" },
-			{ name: "budget", description: "Adjust the token budget", usage: "<N|off>" },
 		],
 		inlineHint: "[objective]",
 		allowArgs: true,
@@ -793,6 +781,30 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleCompactCommand(customInstructions);
 		},
 	},
+	{
+		name: "contribute-pr",
+		aliases: ["contribution-prep"],
+		description: "Dump redacted session context and spawn a fresh contribute-pr worker",
+		inlineHint: "[focus instructions]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const result = await runtime.session.prepareContributionPrep({
+				customInstructions: command.args || undefined,
+				spawnWorker: true,
+			});
+			await runtime.output(
+				[
+					"Contribution prep artifacts written.",
+					`Manifest: ${result.manifestPath}`,
+					`Worker prompt: ${result.workerPromptPath}`,
+				].join("\n"),
+			);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleContributionPrepCommand(command.args || undefined);
+		},
+	},
 	{
 		name: "resume",
 		description: "Resume a different session",
@@ -993,6 +1005,15 @@ for (const command of ACTIVE_BUILTIN_SLASH_COMMAND_REGISTRY) {
 	}
 }
 
+export function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined {
+	if (commandName !== "provicer") return undefined;
+	return [
+		"Unknown slash command: /provicer.",
+		"Did you mean /provider?",
+		"Run: /provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>",
+	].join("\n");
+}
+
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand> = ACTIVE_BUILTIN_SLASH_COMMAND_REGISTRY.map(
 	command => ({
@@ -1025,7 +1046,13 @@ export async function executeBuiltinSlashCommand(
 	if (!parsed) return false;
 
 	const command = BUILTIN_SLASH_COMMAND_LOOKUP.get(parsed.name);
-	if (!command) return false;
+	if (!command) {
+		const diagnostic = formatUnknownBuiltinSlashCommandDiagnostic(parsed.name);
+		if (!diagnostic) return false;
+		runtime.ctx.showError(diagnostic);
+		runtime.ctx.editor.setText("");
+		return true;
+	}
 	if (parsed.args.length > 0 && !command.allowArgs) {
 		return false;
 	}

package/src/task/commands.ts

@@ -9,12 +9,8 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import { loadCapability } from "../discovery";
 // Embed command markdown files at build time
 import initMd from "../prompts/agents/init.md" with { type: "text" };
-import orchestrateMd from "../prompts/commands/orchestrate.md" with { type: "text" };
 
-const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
-	{ name: "init.md", content: prompt.render(initMd) },
-	{ name: "orchestrate.md", content: prompt.render(orchestrateMd) },
-];
+const EMBEDDED_COMMANDS: { name: string; content: string }[] = [{ name: "init.md", content: prompt.render(initMd) }];
 
 export const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{ name: string; content: string }> = EMBEDDED_COMMANDS;
 

package/src/tools/gh.ts

@@ -225,6 +225,10 @@ const RUN_SUCCESS_CONCLUSIONS = new Set(["success", "neutral", "skipped"]);
 const RUN_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required", "startup_failure"]);
 const JOB_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required"]);
 
+const PR_CREATE_BASE_CONFIG_KEYS = ["github.prBase", "gh.prBase", "gjc.github.prBase"] as const;
+const ISSUE_CLOSING_REFERENCE_PATTERN =
+	/(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+(?:https:\/\/github\.com\/([^\s/]+\/[^\s/]+)\/issues\/)?#(\d+)\b/gi;
+
 const githubSchema = z
 	.object({
 		op: z
@@ -407,6 +411,23 @@ interface GhIssueViewData {
 	updatedAt?: string;
 	url?: string;
 }
+interface GhPrListData {
+	baseRefName?: string;
+	headRefName?: string;
+	isDraft?: boolean;
+	number?: number;
+	state?: string;
+	title?: string;
+	url?: string;
+}
+
+interface PrCreateDuplicateCheck {
+	base: string;
+	head: string;
+	issue?: GhIssueViewData;
+	linkedPr?: GhPrListData;
+	pr?: GhPrListData;
+}
 
 interface GhPrFile {
 	path?: string;
@@ -659,6 +680,185 @@ function resolveSearchLimit(value: number | undefined): number {
 
 	return Math.min(Math.floor(value), SEARCH_LIMIT_MAX);
 }
+async function resolvePrCreateBase(
+	cwd: string,
+	explicitBase: string | undefined,
+	repo: string | undefined,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	if (explicitBase) return explicitBase;
+	try {
+		for (const key of PR_CREATE_BASE_CONFIG_KEYS) {
+			const configured = normalizeOptionalString(await git.config.get(cwd, key, signal));
+			if (configured) return configured;
+		}
+	} catch {
+		// Repository config is optional for pr_create; prefer GitHub metadata when
+		// local git metadata is unavailable.
+	}
+	try {
+		const resolvedRepo = repo ?? (await resolveDefaultRepoMemoized(cwd, signal));
+		const repoView = await git.github.json<GhRepoViewData>(
+			cwd,
+			["repo", "view", resolvedRepo, "--json", "defaultBranchRef"],
+			signal,
+			{ repoProvided: true },
+		);
+		const defaultBranch = normalizeOptionalString(repoView.defaultBranchRef?.name);
+		if (defaultBranch) return defaultBranch;
+	} catch {
+		// Fall back to local git metadata below so pr_create can still work when gh
+		// cannot resolve repository metadata in otherwise-valid checkouts.
+	}
+	return (await git.branch.default(cwd, signal)) ?? undefined;
+}
+
+function normalizePrHead(value: string): string {
+	const separator = value.lastIndexOf(":");
+	return separator >= 0 ? value.slice(separator + 1) : value;
+}
+
+function extractClosingIssueReferences(body: string | undefined, repo: string | undefined): number[] {
+	if (!body) return [];
+	const issueNumbers: number[] = [];
+	ISSUE_CLOSING_REFERENCE_PATTERN.lastIndex = 0;
+	let match = ISSUE_CLOSING_REFERENCE_PATTERN.exec(body);
+	while (match !== null) {
+		const issueRepo = normalizeOptionalString(match[1]);
+		if (!issueRepo || !repo || issueRepo.toLowerCase() === repo.toLowerCase()) {
+			const issueNumber = Number(match[2]);
+			if (Number.isInteger(issueNumber) && issueNumber > 0) issueNumbers.push(issueNumber);
+		}
+		match = ISSUE_CLOSING_REFERENCE_PATTERN.exec(body);
+	}
+	return issueNumbers;
+}
+
+async function resolvePrCreateHead(
+	cwd: string,
+	explicitHead: string | undefined,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	if (explicitHead) return explicitHead;
+	try {
+		return (await git.branch.current(cwd, signal)) ?? undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+async function fetchPrCreateDuplicateCheck(
+	cwd: string,
+	repo: string | undefined,
+	base: string | undefined,
+	head: string | undefined,
+	body: string | undefined,
+	signal: AbortSignal | undefined,
+): Promise<PrCreateDuplicateCheck | undefined> {
+	if (!base || !head) return undefined;
+	const resolvedRepo = repo ?? (await resolveDefaultRepoMemoized(cwd, signal));
+	const normalizedHead = normalizePrHead(head);
+	const prs = await git.github.json<GhPrListData[]>(
+		cwd,
+		[
+			"pr",
+			"list",
+			"--repo",
+			resolvedRepo,
+			"--head",
+			normalizedHead,
+			"--base",
+			base,
+			"--state",
+			"all",
+			"--json",
+			"number,title,state,url,baseRefName,headRefName,isDraft",
+		],
+		signal,
+		{ repoProvided: true },
+	);
+	const existingPr = prs.find(pr => pr.headRefName === normalizedHead && pr.baseRefName === base) ?? prs[0];
+	const issueNumbers = existingPr ? [] : extractClosingIssueReferences(body, resolvedRepo);
+	let issue: GhIssueViewData | undefined;
+	let linkedPr: GhPrListData | undefined;
+	for (const issueNumber of issueNumbers) {
+		const candidateIssue = await git.github.json<GhIssueViewData>(
+			cwd,
+			[
+				"issue",
+				"view",
+				String(issueNumber),
+				"--repo",
+				resolvedRepo,
+				"--json",
+				GH_ISSUE_FIELDS_NO_COMMENTS.join(","),
+			],
+			signal,
+			{ repoProvided: true },
+		);
+		issue = candidateIssue;
+		if (candidateIssue.state && candidateIssue.state.toUpperCase() !== "OPEN") break;
+		const linkedPrs = await git.github.json<GhPrListData[]>(
+			cwd,
+			[
+				"pr",
+				"list",
+				"--repo",
+				resolvedRepo,
+				"--search",
+				`${issueNumber} linked:issue`,
+				"--state",
+				"open",
+				"--json",
+				"number,title,state,url,baseRefName,headRefName,isDraft",
+			],
+			signal,
+			{ repoProvided: true },
+		);
+		linkedPr = linkedPrs.find(pr => pr.headRefName !== normalizedHead) ?? linkedPrs[0];
+		if (linkedPr) break;
+	}
+	return { base, head: normalizedHead, issue, linkedPr, pr: existingPr };
+}
+
+function formatPrCreateExistingResult(check: PrCreateDuplicateCheck): string | undefined {
+	if (check.issue?.state && check.issue.state.toUpperCase() !== "OPEN") {
+		const lines = [
+			"# Pull Request Not Created",
+			"",
+			`Issue #${check.issue.number ?? ""} is ${check.issue.state.toLowerCase()}.`,
+		];
+		pushLine(lines, "Issue", check.issue.url);
+		if (check.pr) pushLine(lines, "Existing PR", check.pr.url);
+		pushLine(lines, "Base", check.base);
+		pushLine(lines, "Head", check.head);
+		return lines.join("\n").trim();
+	}
+	if (check.linkedPr) {
+		const number = check.linkedPr.number !== undefined ? ` #${check.linkedPr.number}` : "";
+		const title = check.linkedPr.title ? `: ${check.linkedPr.title}` : "";
+		const lines = [`# Pull Request Already Linked${number}${title}`, ""];
+		pushLine(lines, "URL", check.linkedPr.url);
+		pushLine(lines, "Issue", check.issue?.url);
+		pushLine(lines, "State", check.linkedPr.state);
+		pushLine(lines, "Draft", check.linkedPr.isDraft);
+		pushLine(lines, "Base", check.linkedPr.baseRefName ?? check.base);
+		pushLine(lines, "Head", check.linkedPr.headRefName ?? check.head);
+		return lines.join("\n").trim();
+	}
+	if (check.pr) {
+		const number = check.pr.number !== undefined ? ` #${check.pr.number}` : "";
+		const title = check.pr.title ? `: ${check.pr.title}` : "";
+		const lines = [`# Pull Request Already Exists${number}${title}`, ""];
+		pushLine(lines, "URL", check.pr.url);
+		pushLine(lines, "State", check.pr.state);
+		pushLine(lines, "Draft", check.pr.isDraft);
+		pushLine(lines, "Base", check.pr.baseRefName ?? check.base);
+		pushLine(lines, "Head", check.pr.headRefName ?? check.head);
+		return lines.join("\n").trim();
+	}
+	return undefined;
+}
 
 function resolveTailLimit(value: number | undefined): number {
 	if (value === undefined) {
@@ -3117,8 +3317,8 @@ async function executePrCreate(
 	const repo = normalizeOptionalString(params.repo);
 	const title = normalizeOptionalString(params.title);
 	const body = params.body;
-	const base = normalizeOptionalString(params.base);
-	const head = normalizeOptionalString(params.head);
+	const requestedBase = normalizeOptionalString(params.base);
+	const requestedHead = normalizeOptionalString(params.head);
 	const draft = params.draft ?? false;
 	const fill = params.fill ?? false;
 	const reviewers = normalizePrIdentifierList(params.reviewer);
@@ -3131,6 +3331,16 @@ async function executePrCreate(
 	if (fill && (title || body !== undefined)) {
 		throw new ToolError("fill is mutually exclusive with title and body");
 	}
+	const base = await resolvePrCreateBase(session.cwd, requestedBase, repo, signal);
+	const head = await resolvePrCreateHead(session.cwd, requestedHead, signal);
+	const duplicateCheck = await fetchPrCreateDuplicateCheck(session.cwd, repo, base, head, body, signal);
+	const existingText = duplicateCheck ? formatPrCreateExistingResult(duplicateCheck) : undefined;
+	if (existingText) {
+		return buildTextResult(
+			existingText,
+			duplicateCheck?.pr?.url ?? duplicateCheck?.linkedPr?.url ?? duplicateCheck?.issue?.url,
+		);
+	}
 
 	const args = ["pr", "create"];
 	appendRepoFlag(args, repo);

package/src/tools/index.ts

@@ -7,7 +7,7 @@ import { EditTool } from "../edit";
 import { checkPythonKernelAvailability } from "../eval/py/kernel";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
-import { CreateGoalTool, GetGoalTool, GoalTool, UpdateGoalTool } from "../goals/tools/goal-tool";
+import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import { LspTool } from "../lsp";
 import type { PlanModeState } from "../plan-mode/state";
@@ -309,12 +309,9 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	recall: HindsightRecallTool.createIf,
 	reflect: HindsightReflectTool.createIf,
 	goal: s => new GoalTool(s),
-	get_goal: GetGoalTool.createIf,
-	create_goal: CreateGoalTool.createIf,
-	update_goal: UpdateGoalTool.createIf,
 };
 
-const GOAL_MODE_TOOL_NAMES = ["get_goal", "create_goal", "update_goal"] as const;
+const GOAL_MODE_TOOL_NAMES = [] as const;
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	yield: s => new YieldTool(s),

package/dist/types/commands/gjc-runtime-bridge.d.ts

@@ -1,30 +0,0 @@
-import { type WorkflowHudSummary } from "../skill-state/active-state";
-export declare const WORKFLOW_HUD_PROTOCOL = "workflow-hud-summary-v1";
-export interface GjcRuntimeBridgeResult {
-    status: number;
-    error?: string;
-}
-export interface WorkflowHudBridgePayload {
-    version: 1;
-    skill: string;
-    phase?: string;
-    active?: boolean;
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    hud: WorkflowHudSummary;
-}
-export interface GjcRuntimeHudBridgeResult extends GjcRuntimeBridgeResult {
-    hudPayload?: WorkflowHudBridgePayload;
-}
-export interface GjcRuntimeHudBridgeOptions {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    sidecarSkill: string;
-    onHudPayload?: (payload: WorkflowHudBridgePayload) => Promise<void> | void;
-    pollIntervalMs?: number;
-}
-export declare function normalizeWorkflowHudBridgePayload(raw: unknown, expectedSkill: string): WorkflowHudBridgePayload | null;
-export declare function runGjcRuntimeBridge(endpoint: string, args: string[], env?: NodeJS.ProcessEnv): GjcRuntimeBridgeResult;
-export declare function runGjcRuntimeBridgeWithHudSidecar(endpoint: string, args: string[], options: GjcRuntimeHudBridgeOptions): Promise<GjcRuntimeHudBridgeResult>;
-export declare function runBridgedRuntimeEndpoint(endpoint: string, args: string[]): Promise<void>;

package/dist/types/commands/question.d.ts

@@ -1,7 +0,0 @@
-import { Command } from "@gajae-code/utils/cli";
-export default class Question extends Command {
-    static description: string;
-    static strict: boolean;
-    static examples: string[];
-    run(): Promise<void>;
-}

package/dist/types/modes/loop-limit.d.ts

@@ -1,22 +0,0 @@
-export type LoopLimitConfig = {
-    kind: "iterations";
-    iterations: number;
-} | {
-    kind: "duration";
-    durationMs: number;
-};
-export type LoopLimitRuntime = {
-    kind: "iterations";
-    initial: number;
-    remaining: number;
-} | {
-    kind: "duration";
-    durationMs: number;
-    deadlineMs: number;
-};
-export declare function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string;
-export declare function createLoopLimitRuntime(config: LoopLimitConfig | undefined, nowMs?: number): LoopLimitRuntime | undefined;
-export declare function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
-export declare function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
-export declare function describeLoopLimit(config: LoopLimitConfig): string;
-export declare function describeLoopLimitRuntime(limit: LoopLimitRuntime): string;