chore(deps): bump the all group across 1 directory with 3 updates

.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"5c1e7a42-7e7d-4fe4-90e9-604dd995eb94","pid":5187,"acquiredAt":1775271415148}

.gitignore

@@ -51,3 +51,10 @@ manpages/
 completions/crush.*sh
 .prettierignore
 .task
+.worktrees
+tests/node_modules/
+tests/smithers-tui
+tests/.tui-test/
+jjhub-tui
+/poc/jjhub-tui/jjhub-tui
+smithers.db*

.smithers/.gitignore

@@ -0,0 +1,8 @@
+node_modules/
+executions/
+*.db
+*.db-shm
+*.db-wal
+*.sqlite
+dist/
+.DS_Store

.smithers/agents.ts

@@ -0,0 +1,26 @@
+// smithers-source: generated
+import { ClaudeCodeAgent, CodexAgent, GeminiAgent, PiAgent, KimiAgent, AmpAgent, type AgentLike } from "smithers-orchestrator";
+
+export const providers = {
+  claude: new ClaudeCodeAgent({ model: "claude-opus-4-6" }),
+  codex: new CodexAgent({ model: "gpt-5.3-codex", skipGitRepoCheck: true }),
+  gemini: new GeminiAgent({ model: "gemini-3.1-pro-preview" }),
+  pi: new PiAgent({ provider: "openai", model: "gpt-5.3-codex" }),
+  kimi: new KimiAgent({ model: "kimi-latest" }),
+  amp: new AmpAgent(),
+} as const;
+
+export const roleChains = {
+  spec: [providers.claude, providers.codex],
+  research: [providers.codex, providers.kimi, providers.gemini, providers.claude],
+  plan: [providers.codex, providers.gemini, providers.claude, providers.kimi],
+  implement: [providers.codex, providers.amp, providers.gemini, providers.claude, providers.kimi],
+  validate: [providers.codex, providers.amp, providers.gemini],
+  review: [providers.claude, providers.amp, providers.codex],
+} as const satisfies Record<string, AgentLike[]>;
+
+export function pickAgent(role: keyof typeof roleChains): AgentLike {
+  const agent = roleChains[role][0];
+  if (!agent) throw new Error(`No agent configured for role: ${role}`);
+  return agent;
+}

.smithers/bunfig.toml

@@ -0,0 +1 @@
+preload = ["./preload.ts"]

.smithers/components/CommandProbe.tsx

@@ -0,0 +1,17 @@
+// smithers-source: seeded
+/** @jsxImportSource smithers-orchestrator */
+import { Task } from "smithers-orchestrator";
+import { z } from "zod";
+
+export const commandProbeOutputSchema = z.object({
+  command: z.string(),
+  available: z.boolean(),
+}).passthrough();
+
+export function CommandProbe({ id, command }: { id: string; command: string }) {
+  return (
+    <Task id={id} output={commandProbeOutputSchema}>
+      {{ command, available: true }}
+    </Task>
+  );
+}

.smithers/components/FeatureEnum.tsx

@@ -0,0 +1,132 @@
+// smithers-source: seeded
+/** @jsxImportSource smithers-orchestrator */
+import { Sequence, Task, type AgentLike } from "smithers-orchestrator";
+import { z } from "zod";
+import FeatureEnumScanPrompt from "../prompts/feature-enum-scan.mdx";
+import FeatureEnumRefinePrompt from "../prompts/feature-enum-refine.mdx";
+
+export const featureEnumOutputSchema = z.object({
+  featureGroups: z.record(z.string(), z.array(z.string())).default({}),
+  totalFeatures: z.number().int().default(0),
+  lastCommitHash: z.string().nullable().optional(),
+  markdownBody: z.string(),
+}).passthrough();
+
+type FeatureEnumProps = {
+  idPrefix: string;
+  agent: AgentLike | AgentLike[];
+  refineIterations?: number;
+  existingFeatures?: Record<string, string[]> | null;
+  lastCommitHash?: string | null;
+  additionalContext?: string;
+};
+
+const memoryNamespace = { kind: "workflow", id: "feature-enum" } as const;
+
+export function FeatureEnum({
+  idPrefix,
+  agent,
+  refineIterations,
+  existingFeatures = null,
+  lastCommitHash = null,
+  additionalContext = "",
+}: FeatureEnumProps) {
+  const isFirstRun = !existingFeatures;
+  const totalRefineIterations = Math.max(1, refineIterations ?? (isFirstRun ? 5 : 1));
+  const scanTaskId = `${idPrefix}:scan`;
+  const refineTaskIds = Array.from({ length: totalRefineIterations }, (_, index) => `${idPrefix}:refine:${index + 1}`);
+  const finalTaskId = `${idPrefix}:result`;
+
+  return (
+    <Sequence>
+      {isFirstRun && (
+        <Task
+          id={scanTaskId}
+          output={featureEnumOutputSchema}
+          agent={agent}
+          memory={{
+            remember: {
+              namespace: memoryNamespace,
+              key: scanTaskId,
+            },
+          }}
+        >
+          <FeatureEnumScanPrompt additionalContext={additionalContext} />
+        </Task>
+      )}
+
+      {refineTaskIds.map((taskId, index) => {
+        const previousTaskId = index === 0
+          ? (isFirstRun ? scanTaskId : null)
+          : refineTaskIds[index - 1];
+
+        if (previousTaskId) {
+          return (
+            <Task
+              key={taskId}
+              id={taskId}
+              output={featureEnumOutputSchema}
+              agent={agent}
+              needs={{ previous: previousTaskId }}
+              deps={{ previous: featureEnumOutputSchema }}
+              memory={{
+                recall: {
+                  namespace: memoryNamespace,
+                  query: "feature inventory feature enum grouped features",
+                  topK: 5,
+                },
+                remember: {
+                  namespace: memoryNamespace,
+                  key: taskId,
+                },
+              }}
+            >
+              {(deps) => (
+                <FeatureEnumRefinePrompt
+                  existingFeatures={deps.previous.featureGroups}
+                  lastCommitHash={deps.previous.lastCommitHash ?? lastCommitHash}
+                  iteration={index + 1}
+                />
+              )}
+            </Task>
+          );
+        }
+
+        return (
+          <Task
+            key={taskId}
+            id={taskId}
+            output={featureEnumOutputSchema}
+            agent={agent}
+            memory={{
+              recall: {
+                namespace: memoryNamespace,
+                query: "feature inventory feature enum grouped features",
+                topK: 5,
+              },
+              remember: {
+                namespace: memoryNamespace,
+                key: taskId,
+              },
+            }}
+          >
+            <FeatureEnumRefinePrompt
+              existingFeatures={existingFeatures ?? {}}
+              lastCommitHash={lastCommitHash}
+              iteration={index + 1}
+            />
+          </Task>
+        );
+      })}
+
+      <Task
+        id={finalTaskId}
+        output={featureEnumOutputSchema}
+        needs={{ final: refineTaskIds[refineTaskIds.length - 1] ?? scanTaskId }}
+        deps={{ final: featureEnumOutputSchema }}
+      >
+        {(deps) => deps.final}
+      </Task>
+    </Sequence>
+  );
+}

.smithers/components/ForEachFeature.tsx

@@ -0,0 +1,152 @@
+// smithers-source: seeded
+/** @jsxImportSource smithers-orchestrator */
+import { Parallel, Sequence, Task, type AgentLike } from "smithers-orchestrator";
+import { z } from "zod";
+
+export const forEachFeatureResultSchema = z.object({
+  groupName: z.string(),
+  result: z.string(),
+  featuresCovered: z.array(z.string()).default([]),
+  score: z.number().min(0).max(100).optional(),
+}).passthrough();
+
+export const forEachFeatureMergeSchema = z.object({
+  totalGroups: z.number().int(),
+  summary: z.string(),
+  mergedResult: z.string(),
+  markdownBody: z.string(),
+}).passthrough();
+
+type ForEachFeatureProps = {
+  idPrefix: string;
+  agent: AgentLike | AgentLike[];
+  features: Record<string, string[]>;
+  prompt: string;
+  maxConcurrency?: number;
+  mergeAgent?: AgentLike | AgentLike[];
+  granularity?: "group" | "feature";
+};
+
+type FeatureWorkItem = {
+  id: string;
+  groupName: string;
+  features: string[];
+};
+
+function slugifyFeatureToken(value: string) {
+  const normalized = value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return normalized.length > 0 ? normalized : "item";
+}
+
+export function ForEachFeature({
+  idPrefix,
+  agent,
+  features,
+  prompt,
+  maxConcurrency = 5,
+  mergeAgent,
+  granularity = "group",
+}: ForEachFeatureProps) {
+  const featureEntries = Object.entries(features ?? {}).filter(([, groupFeatures]) => Array.isArray(groupFeatures) && groupFeatures.length > 0);
+  const workItems: FeatureWorkItem[] = granularity === "feature"
+    ? featureEntries.flatMap(([groupName, groupFeatures]) =>
+        groupFeatures.map((feature, index) => ({
+          id: `${slugifyFeatureToken(groupName)}:${slugifyFeatureToken(feature)}:${index}`,
+          groupName,
+          features: [feature],
+        })),
+      )
+    : featureEntries.map(([groupName, groupFeatures], index) => ({
+        id: `${slugifyFeatureToken(groupName)}:${index}`,
+        groupName,
+        features: groupFeatures,
+      }));
+
+  const mergeNeeds: Record<string, string> = Object.fromEntries(
+    workItems.map((item, index) => [`item${index}`, `${idPrefix}:group:${item.id}`]),
+  );
+  const mergeDeps = Object.fromEntries(
+    workItems.map((_, index) => [`item${index}`, forEachFeatureResultSchema]),
+  ) as Record<string, typeof forEachFeatureResultSchema>;
+
+  if (workItems.length === 0) {
+    return (
+      <Sequence>
+        <Task id={`${idPrefix}:merge`} output={forEachFeatureMergeSchema}>
+          {{
+            totalGroups: 0,
+            summary: "No feature groups were provided.",
+            mergedResult: "",
+            markdownBody: "# Feature Audit\n\nNo feature groups were provided.",
+          }}
+        </Task>
+      </Sequence>
+    );
+  }
+
+  return (
+    <Sequence>
+      <Parallel maxConcurrency={maxConcurrency}>
+        {workItems.map((item) => (
+          <Task
+            key={`${idPrefix}:${item.id}`}
+            id={`${idPrefix}:group:${item.id}`}
+            output={forEachFeatureResultSchema}
+            agent={agent}
+            continueOnFail
+          >
+            {[
+              `# ${granularity === "feature" ? "Feature" : "Feature Group"} Task`,
+              "",
+              `Group: ${item.groupName}`,
+              `Granularity: ${granularity}`,
+              "",
+              "Features:",
+              ...item.features.map((feature) => `- ${feature}`),
+              "",
+              "REQUEST:",
+              prompt,
+            ].join("\n")}
+          </Task>
+        ))}
+      </Parallel>
+      <Task
+        id={`${idPrefix}:merge`}
+        output={forEachFeatureMergeSchema}
+        agent={mergeAgent ?? agent}
+        needs={mergeNeeds}
+        deps={mergeDeps}
+      >
+        {(deps) => {
+          const results = workItems.map((_, index) => deps[`item${index}`]);
+          const totalGroups = new Set(workItems.map((item) => item.groupName)).size;
+          return [
+            "# Merge Feature Results",
+            "",
+            `Granularity: ${granularity}`,
+            `Distinct groups: ${totalGroups}`,
+            `Work items: ${workItems.length}`,
+            `Set totalGroups to ${totalGroups}.`,
+            "",
+            "Combine the per-group results below into a single coherent output.",
+            "Preserve group boundaries, highlight the most important gaps, and produce a markdownBody suitable for a report.",
+            "",
+            ...results.flatMap((result, index) => {
+              const groupLabel = workItems[index]?.groupName ?? `Group ${index + 1}`;
+              return [
+                `## ${groupLabel}`,
+                `Features covered: ${(result?.featuresCovered ?? []).join(", ") || "none"}`,
+                result?.score != null ? `Score: ${result.score}` : null,
+                result?.result ?? "",
+                "",
+              ].filter(Boolean);
+            }),
+          ].join("\n");
+        }}
+      </Task>
+    </Sequence>
+  );
+}