neondeck 1.0.0-beta.10

package/src/modules/kilo/actions.ts

@@ -0,0 +1,229 @@
+import { defineAction, defineTool } from '@flue/runtime';
+import {
+  eventsInputSchema,
+  outputSchema,
+  reconcileInputSchema,
+  sessionReadInputSchema,
+  sessionsSearchInputSchema,
+  startInputSchema,
+  taskIdInputSchema,
+  taskStatusOutputSchema,
+  tasksListInputSchema,
+  tasksListOutputSchema,
+} from './schemas';
+import {
+  abortKiloTask,
+  listKiloTasks,
+  readKiloTaskDiff,
+  readKiloTaskEvents,
+  readKiloTaskSessions,
+  readKiloTaskStatus,
+  reconcileKiloTask,
+  startKiloTask,
+} from './service';
+import {
+  readKiloSession,
+  readKiloSessionChildren,
+  readKiloSessionDiff,
+  readKiloSessionMessages,
+  readUnavailableSessionAdapter,
+  searchKiloSessions,
+} from './sessions';
+
+export type {
+  KiloChildSessionNode,
+  KiloResultPlaceholder,
+  KiloSessionReadOptions,
+} from './schemas';
+export type {
+  KiloHandoffMode,
+  KiloTaskEventRecord,
+  KiloTaskRecord,
+  KiloTaskStatus,
+} from './store';
+export {
+  startKiloTask,
+  listKiloTasks,
+  readKiloTaskStatus,
+  readKiloTaskEvents,
+  abortKiloTask,
+  readKiloTaskSessions,
+  readKiloTaskDiff,
+  reconcileKiloTask,
+} from './service';
+export { summarizeKiloSession } from './service';
+export {
+  searchKiloSessions,
+  readKiloSession,
+  readKiloSessionMessages,
+  readKiloSessionChildren,
+  readUnavailableSessionAdapter,
+  readKiloSessionDiff,
+} from './sessions';
+
+export const kiloTaskStartAction = defineAction({
+  name: 'neondeck_kilo_task_start',
+  description:
+    'Explicitly start a background KiloCode handoff in a declared repo or Neondeck-managed worktree and persist task/event state.',
+  input: startInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return startKiloTask(input);
+  },
+});
+
+export const kiloTaskStatusAction = defineAction({
+  name: 'neondeck_kilo_task_status',
+  description: 'Read one persisted Kilo handoff task status.',
+  input: taskIdInputSchema,
+  output: taskStatusOutputSchema,
+  async run({ input }) {
+    return readKiloTaskStatus(input);
+  },
+});
+
+export const kiloTaskEventsAction = defineAction({
+  name: 'neondeck_kilo_task_events',
+  description: 'Read persisted Kilo handoff task events.',
+  input: eventsInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloTaskEvents(input);
+  },
+});
+
+export const kiloTaskAbortAction = defineAction({
+  name: 'neondeck_kilo_task_abort',
+  description: 'Cancel a running Kilo handoff task and mark it cancelled.',
+  input: taskIdInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return abortKiloTask(input);
+  },
+});
+
+export const kiloTaskSessionsAction = defineAction({
+  name: 'neondeck_kilo_task_sessions',
+  description: 'List root and child Kilo session ids linked to one task.',
+  input: taskIdInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloTaskSessions(input);
+  },
+});
+
+export const kiloTaskDiffAction = defineAction({
+  name: 'neondeck_kilo_task_diff',
+  description: 'Read a git diff summary for the workspace used by a Kilo task.',
+  input: taskIdInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloTaskDiff(input);
+  },
+});
+
+export const kiloTaskReconcileAction = defineAction({
+  name: 'neondeck_kilo_task_reconcile',
+  description:
+    'Reconcile persisted Kilo task state after restart by inspecting detached task process/session/diff state.',
+  input: reconcileInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return reconcileKiloTask(input);
+  },
+});
+
+export const kiloSessionsSearchAction = defineAction({
+  name: 'neondeck_kilo_sessions_search',
+  description:
+    'Search Kilo session metadata through linked Neondeck tasks and the Kilo CLI session list fallback.',
+  input: sessionsSearchInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return searchKiloSessions(input);
+  },
+});
+
+export const kiloSessionReadAction = defineAction({
+  name: 'neondeck_kilo_session_read',
+  description:
+    'Read normalized Kilo session metadata linked to a task or found through Kilo CLI session list. Transcript paging is deferred.',
+  input: sessionReadInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloSession(input);
+  },
+});
+
+export const kiloSessionMessagesAction = defineAction({
+  name: 'neondeck_kilo_session_messages',
+  description:
+    'Audit a request for Kilo session messages. The CLI MVP returns metadata only until a stable transcript adapter is wired.',
+  input: sessionReadInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloSessionMessages(input);
+  },
+});
+
+export const kiloSessionChildrenAction = defineAction({
+  name: 'neondeck_kilo_session_children',
+  description:
+    'Read child Kilo session ids captured from persisted task events.',
+  input: sessionReadInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloSessionChildren(input);
+  },
+});
+
+export const kiloSessionTodosAction = defineAction({
+  name: 'neondeck_kilo_session_todos',
+  description:
+    'Report that Kilo todo access is unavailable in the CLI MVP while returning linked session metadata.',
+  input: sessionReadInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readUnavailableSessionAdapter(input, 'todos');
+  },
+});
+
+export const kiloSessionDiffAction = defineAction({
+  name: 'neondeck_kilo_session_diff',
+  description:
+    'Read the Neondeck task workspace diff summary for a linked Kilo session when available.',
+  input: sessionReadInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readKiloSessionDiff(input);
+  },
+});
+
+export const kiloTasksLookupTool = defineTool({
+  name: 'neondeck_kilo_tasks_lookup',
+  description:
+    'List persisted Kilo handoff tasks without starting or cancelling work.',
+  input: tasksListInputSchema,
+  output: tasksListOutputSchema,
+  async run({ input }) {
+    return listKiloTasks(input);
+  },
+});
+
+export const neondeckKiloActions = [
+  kiloTaskStartAction,
+  kiloTaskStatusAction,
+  kiloTaskEventsAction,
+  kiloTaskAbortAction,
+  kiloTaskSessionsAction,
+  kiloTaskDiffAction,
+  kiloTaskReconcileAction,
+  kiloSessionsSearchAction,
+  kiloSessionReadAction,
+  kiloSessionMessagesAction,
+  kiloSessionChildrenAction,
+  kiloSessionTodosAction,
+  kiloSessionDiffAction,
+];
+
+export const neondeckKiloTools = [kiloTasksLookupTool];

package/src/modules/kilo/ci-fix-run-reconcile.ts

@@ -0,0 +1,299 @@
+import { asJsonValue } from '../../lib/action-result';
+import {
+  addNotification,
+  findWorkflowSummaryByKiloTaskId,
+  updateWorkflowSummary,
+} from '../app-state';
+import { ensurePreparedDiffForWorktree, mergeSummary } from '../prepared-diffs';
+import { readGitDiffSummary } from '../repos';
+import {
+  releaseWorktreeLock,
+  readWorktreeRecord,
+  type WorktreeLifecycleStatus,
+} from '../worktrees';
+import type { KiloTaskRecord, KiloTaskStatus } from './store';
+import { gitCurrentSha } from '../../repo-edit/git';
+import { runtimePaths, type RuntimePaths } from '../../runtime-home';
+import { splitRepoFullName } from './utils';
+
+type CiFixTaskDiff = {
+  ok: boolean;
+  fileCount: number;
+  error?: string;
+};
+
+type CiFixKiloCompletionInput = {
+  task: KiloTaskRecord;
+  status: KiloTaskStatus;
+  diff?: CiFixTaskDiff | null;
+  error?: string | null;
+};
+
+export async function ciFixRunWorktreeReleaseStatusForKiloTask(
+  input: CiFixKiloCompletionInput,
+  paths: RuntimePaths = runtimePaths(),
+): Promise<WorktreeLifecycleStatus | null> {
+  const summary = await findWorkflowSummaryByKiloTaskId(
+    'ci_fix_run',
+    input.task.id,
+    paths,
+  );
+  if (!summary || summary.status !== 'running') return null;
+  const facts = await ciFixCompletionFacts(input, objectField(summary.summary));
+  if (
+    isPreparedDiffStatus(input.status) &&
+    facts.hasReviewableFix &&
+    facts.worktreeId
+  ) {
+    return 'prepared-diff';
+  }
+  if (input.status === 'failed') return 'failed';
+  return 'ready';
+}
+
+export async function reconcileCiFixRunForKiloTask(
+  input: CiFixKiloCompletionInput,
+  paths: RuntimePaths = runtimePaths(),
+) {
+  const summary = await findWorkflowSummaryByKiloTaskId(
+    'ci_fix_run',
+    input.task.id,
+    paths,
+  );
+  if (!summary || summary.status !== 'running') return null;
+  const summaryData = objectField(summary.summary);
+  const summaryJson = asJsonValue(summaryData);
+  const reportId = stringField(summaryData.reportId);
+  const sourceRef =
+    stringField(summaryData.pr) ??
+    `${stringField(summaryData.repoFullName) ?? input.task.repoFullName}#${numberField(summaryData.prNumber) ?? 'worktree'}`;
+  const ciFixLockId = stringField(summaryData.ciFixLockId);
+  const completedAt = new Date().toISOString();
+
+  try {
+    const facts = await ciFixCompletionFacts(input, summaryData);
+    const { currentHeadSha, changedFiles, worktreeId } = facts;
+    if (
+      isPreparedDiffStatus(input.status) &&
+      facts.hasReviewableFix &&
+      worktreeId
+    ) {
+      const worktree = readWorktreeRecord(worktreeId, paths);
+      const preparedDiff = await ensurePreparedDiffForWorktree(
+        worktree,
+        paths,
+        {
+          title: `CI fix for ${sourceRef}`,
+          createdBy: 'ci_fix_run',
+          resetDecisionState: true,
+          summary: mergeSummary(summaryJson, {
+            outcome: 'prepared-diff',
+            completedAt,
+            completedHeadSha: currentHeadSha,
+            changedFiles,
+            kiloStatus: input.status,
+          }),
+        },
+      );
+      if (ciFixLockId) {
+        await releaseWorktreeLock(
+          {
+            lockId: ciFixLockId,
+            owner: 'ci-fix-run',
+            finalStatus: 'prepared-diff',
+          },
+          paths,
+        ).catch(() => undefined);
+      }
+      const nextSummary = mergeSummary(summaryJson, {
+        outcome: 'prepared-diff',
+        preparedDiffId: preparedDiff.id,
+        completedAt,
+        completedHeadSha: currentHeadSha,
+        changedFiles,
+        kiloStatus: input.status,
+      });
+      await updateWorkflowSummary(
+        summary.id,
+        { status: 'completed', summary: nextSummary },
+        paths,
+      );
+      await addNotification(
+        {
+          level: 'ready',
+          title: 'CI fix prepared',
+          message:
+            'Kilo finished a CI fix; a prepared diff is waiting for review.',
+          source: 'autopilot',
+          sourceId: `ci-fix:${input.task.id}:prepared-diff`,
+          data: {
+            sourceRef,
+            reportId,
+            reportUrl: reportId ? `/reports/${reportId}` : null,
+            kiloTaskId: input.task.id,
+            preparedDiffId: preparedDiff.id,
+            worktreeId,
+          },
+        },
+        paths,
+      );
+      return preparedDiff;
+    }
+
+    const outcome =
+      input.status === 'cancelled'
+        ? 'cancelled'
+        : input.status === 'succeeded'
+          ? 'no-op'
+          : 'failed';
+    const message =
+      input.error ??
+      input.task.error ??
+      input.diff?.error ??
+      (outcome === 'no-op'
+        ? 'Kilo completed without a reviewable diff.'
+        : `Kilo task ended with status ${input.status}.`);
+    if (ciFixLockId) {
+      await releaseWorktreeLock(
+        {
+          lockId: ciFixLockId,
+          owner: 'ci-fix-run',
+          finalStatus: outcome === 'no-op' ? 'ready' : 'failed',
+        },
+        paths,
+      ).catch(() => undefined);
+    }
+    await updateWorkflowSummary(
+      summary.id,
+      {
+        status: outcome === 'no-op' ? 'completed' : 'failed',
+        summary: mergeSummary(summaryJson, {
+          outcome,
+          completedAt,
+          completedHeadSha: currentHeadSha,
+          changedFiles: input.diff?.fileCount ?? 0,
+          kiloStatus: input.status,
+          error: message,
+        }),
+      },
+      paths,
+    );
+    await addNotification(
+      {
+        level: 'attention',
+        title: 'CI fix needs attention',
+        message,
+        source: 'autopilot',
+        sourceId: `ci-fix:${input.task.id}:${outcome}`,
+        data: {
+          sourceRef,
+          outcome,
+          reportId,
+          reportUrl: reportId ? `/reports/${reportId}` : null,
+          kiloTaskId: input.task.id,
+          worktreeId: facts.worktreeId,
+        },
+      },
+      paths,
+    );
+  } catch (error) {
+    if (ciFixLockId) {
+      await releaseWorktreeLock(
+        { lockId: ciFixLockId, owner: 'ci-fix-run', finalStatus: 'failed' },
+        paths,
+      ).catch(() => undefined);
+    }
+    await updateWorkflowSummary(
+      summary.id,
+      {
+        status: 'failed',
+        summary: mergeSummary(summaryJson, {
+          outcome: 'reconcile-failed',
+          completedAt,
+          error: errorMessage(error),
+        }),
+      },
+      paths,
+    ).catch(() => undefined);
+    await addNotification(
+      {
+        level: 'attention',
+        title: 'CI fix reconciliation failed',
+        message: errorMessage(error),
+        source: 'autopilot',
+        sourceId: `ci-fix:${input.task.id}:reconcile-failed`,
+        data: {
+          sourceRef,
+          reportId,
+          reportUrl: reportId ? `/reports/${reportId}` : null,
+          kiloTaskId: input.task.id,
+          worktreeId:
+            input.task.worktreeId ?? stringField(summaryData.worktreeId),
+        },
+      },
+      paths,
+    ).catch(() => undefined);
+  }
+  return null;
+}
+
+async function ciFixCompletionFacts(
+  input: CiFixKiloCompletionInput,
+  summaryData: Record<string, unknown>,
+) {
+  const worktreeId =
+    input.task.worktreeId ?? stringField(summaryData.worktreeId);
+  const startedHeadSha = stringField(summaryData.headSha);
+  const currentHeadSha = await gitCurrentSha(input.task.cwd).catch(() => null);
+  const workingTreeDiff = await readGitDiffSummary({
+    path: input.task.cwd,
+    github: splitRepoFullName(input.task.repoFullName),
+    defaultBranch: 'HEAD',
+  });
+  const hasWorkingTreeDiff =
+    workingTreeDiff.ok === true && workingTreeDiff.fileCount > 0;
+  const hasCommittedFix = Boolean(
+    currentHeadSha && startedHeadSha && currentHeadSha !== startedHeadSha,
+  );
+  const hasReviewableFix =
+    hasCommittedFix ||
+    hasWorkingTreeDiff ||
+    (!startedHeadSha && input.diff?.ok === true && input.diff.fileCount > 0);
+  const changedFiles = hasWorkingTreeDiff
+    ? workingTreeDiff.fileCount
+    : (input.diff?.fileCount ?? 0);
+  return {
+    currentHeadSha,
+    changedFiles,
+    hasReviewableFix,
+    worktreeId,
+  };
+}
+
+function isPreparedDiffStatus(status: KiloTaskStatus) {
+  return (
+    status === 'succeeded' ||
+    status === 'needs-review' ||
+    status === 'ready-to-verify' ||
+    status === 'ready-to-push' ||
+    status === 'unknown'
+  );
+}
+
+function objectField(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function stringField(value: unknown) {
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+function numberField(value: unknown) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/modules/kilo/docs-drift-boundary.ts

@@ -0,0 +1,178 @@
+import { DatabaseSync } from 'node:sqlite';
+import { asJsonValue } from '../../lib/action-result';
+import { ensureRuntimeHome, type RuntimePaths } from '../../runtime-home';
+import type { RepoDiffSummary } from '../repos';
+
+export type DocsDriftFixTaskBoundary = {
+  taskId: string;
+  reportId: string;
+  repoId: string;
+  repoFullName: string;
+  worktreeId: string;
+  allowedDocsPaths: string[];
+  createdAt: string;
+};
+
+export type DocsDriftFixDiffViolation = {
+  boundary: DocsDriftFixTaskBoundary | null;
+  changedPaths: string[];
+  disallowedPaths: string[];
+  missingBoundary: boolean;
+};
+
+const keyPrefix = 'docs-drift.fix-task.';
+
+export async function recordDocsDriftFixTaskBoundary(
+  input: Omit<DocsDriftFixTaskBoundary, 'createdAt'>,
+  paths: RuntimePaths,
+) {
+  await ensureRuntimeHome(paths);
+  const boundary: DocsDriftFixTaskBoundary = {
+    ...input,
+    allowedDocsPaths: normalizeAllowedPaths(input.allowedDocsPaths),
+    createdAt: new Date().toISOString(),
+  };
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    database
+      .prepare(
+        `
+        INSERT INTO app_metadata (key, value, updated_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at;
+      `,
+      )
+      .run(
+        boundaryKey(input.taskId),
+        JSON.stringify(asJsonValue(boundary)),
+        boundary.createdAt,
+      );
+  } finally {
+    database.close();
+  }
+}
+
+export function validateDocsDriftFixTaskDiff(
+  task: { id: string; title?: string | null },
+  diff: RepoDiffSummary,
+  paths: RuntimePaths,
+): DocsDriftFixDiffViolation | null {
+  const boundary = readDocsDriftFixTaskBoundary(task.id, paths);
+  if (!diff.ok || diff.fileCount === 0) return null;
+
+  const changedPaths = diff.files
+    .map((file) => normalizeRelativePath(file.path) ?? file.path)
+    .sort();
+  if (!boundary) {
+    if (!isDocsDriftFixTask(task.title)) return null;
+    return {
+      boundary: null,
+      changedPaths,
+      disallowedPaths: changedPaths,
+      missingBoundary: true,
+    };
+  }
+
+  const allowed = new Set(boundary.allowedDocsPaths);
+  const disallowedPaths = changedPaths.filter((path) => !allowed.has(path));
+  if (disallowedPaths.length === 0) return null;
+
+  return {
+    boundary,
+    changedPaths,
+    disallowedPaths,
+    missingBoundary: false,
+  };
+}
+
+function readDocsDriftFixTaskBoundary(
+  taskId: string,
+  paths: RuntimePaths,
+): DocsDriftFixTaskBoundary | null {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    const row = database
+      .prepare('SELECT value FROM app_metadata WHERE key = ?;')
+      .get(boundaryKey(taskId));
+    return parseBoundary(readMetadataValue(row));
+  } finally {
+    database.close();
+  }
+}
+
+function parseBoundary(value: string | undefined) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (!isRecord(parsed)) return null;
+    const allowedDocsPaths = Array.isArray(parsed.allowedDocsPaths)
+      ? normalizeAllowedPaths(parsed.allowedDocsPaths)
+      : [];
+    if (
+      typeof parsed.taskId !== 'string' ||
+      typeof parsed.reportId !== 'string' ||
+      typeof parsed.repoId !== 'string' ||
+      typeof parsed.repoFullName !== 'string' ||
+      typeof parsed.worktreeId !== 'string' ||
+      typeof parsed.createdAt !== 'string' ||
+      allowedDocsPaths.length === 0
+    ) {
+      return null;
+    }
+
+    return {
+      taskId: parsed.taskId,
+      reportId: parsed.reportId,
+      repoId: parsed.repoId,
+      repoFullName: parsed.repoFullName,
+      worktreeId: parsed.worktreeId,
+      allowedDocsPaths,
+      createdAt: parsed.createdAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function normalizeAllowedPaths(paths: unknown[]) {
+  return [
+    ...new Set(paths.flatMap((path) => normalizeRelativePath(path) ?? [])),
+  ].sort();
+}
+
+function normalizeRelativePath(value: unknown) {
+  if (typeof value !== 'string') return null;
+  const path = value
+    .replaceAll('\\', '/')
+    .replace(/^\.\/+/, '')
+    .trim();
+  if (
+    !path ||
+    path.startsWith('/') ||
+    path === '..' ||
+    path.startsWith('../')
+  ) {
+    return null;
+  }
+  return path;
+}
+
+function boundaryKey(taskId: string) {
+  return `${keyPrefix}${taskId}`;
+}
+
+function isDocsDriftFixTask(title: string | null | undefined) {
+  return typeof title === 'string' && title.startsWith('Docs drift fix:');
+}
+
+function readMetadataValue(row: unknown) {
+  if (!row || typeof row !== 'object' || !('value' in row)) return undefined;
+  const value = (row as { value: unknown }).value;
+  return typeof value === 'string' ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/src/modules/kilo/index.ts

@@ -0,0 +1,8 @@
+export * from './actions';
+export * from './ci-fix-run-reconcile';
+export * from './docs-drift-boundary';
+export * from './notifications';
+export * from './revision-reconcile';
+export * from './results';
+export * from './service';
+export * from './store';