neondeck 1.0.0-beta.10

package/src/modules/autopilot-policy/service.ts

@@ -0,0 +1,272 @@
+import {
+  ensureRuntimeHome,
+  parseAppConfig,
+  parseRepoRegistry,
+  readRuntimeJson,
+  runtimePaths,
+  type RuntimePaths,
+} from '../../runtime-home';
+import { listWorktrees } from '../worktrees';
+import {
+  globalAutopilotPolicy,
+  repoGuardrails,
+  repoAutopilotPolicy,
+  repoAutopilotPolicyForWatch,
+} from './config';
+import {
+  emptyPolicyFailure,
+  normalizeWorkflowName,
+  readActiveAutopilotRuns,
+} from './risk';
+import {
+  mutationWorkflowNames,
+  type AutopilotConcurrencyDecision,
+  type AutopilotConcurrencyPolicy,
+  type AutopilotPolicyDecision,
+} from './schemas';
+import { evaluateRepoGuardrails } from '../repo-guardrails';
+
+let activeLocalExecutions = 0;
+
+export async function checkAutopilotPolicy(
+  input: {
+    repoId?: string;
+    worktreeId?: string;
+    diffBaseRef?: string;
+    pushDestination?: string;
+    forcePush?: boolean;
+  },
+  paths: RuntimePaths = runtimePaths(),
+): Promise<AutopilotPolicyDecision> {
+  await ensureRuntimeHome(paths);
+  const [registry, appConfig, worktreeSnapshot] = await Promise.all([
+    readRuntimeJson(paths.repos, parseRepoRegistry),
+    readRuntimeJson(paths.config, parseAppConfig),
+    listWorktrees(paths),
+  ]);
+  const worktree = input.worktreeId
+    ? worktreeSnapshot.worktrees.find((item) => item.id === input.worktreeId)
+    : undefined;
+  const repoId = input.repoId ?? worktree?.repoId;
+  const repo = registry.repos.find((candidate) => candidate.id === repoId);
+  if (!repo) {
+    return emptyPolicyFailure(
+      repoId ?? 'unknown',
+      'Repository is not configured.',
+    );
+  }
+  const watchId =
+    worktree?.prNumber !== undefined && worktree.prNumber !== null
+      ? `${repo.github.owner}/${repo.github.name}#${worktree.prNumber}`
+      : undefined;
+  const policy = repoAutopilotPolicyForWatch(repo, appConfig, {
+    id: watchId,
+    prNumber: worktree?.prNumber,
+  });
+  const guardrails = repoGuardrails(repo, appConfig);
+  const repoFullName = `${repo.github.owner}/${repo.github.name}`;
+  const diffBase = input.diffBaseRef ?? worktree?.headSha ?? 'HEAD';
+  const evaluated = await evaluateRepoGuardrails(
+    { ...input, diffBaseRef: diffBase, guardrails },
+    paths,
+  );
+  const reasons = [...evaluated.denied, ...evaluated.expansions].map(
+    (violation) => violation.detail,
+  );
+  const requires = new Set(
+    [...evaluated.denied, ...evaluated.expansions].map((violation) =>
+      requirementForViolation(violation.kind),
+    ),
+  );
+  if (guardrails.requiredChecks.length > 0) {
+    reasons.push(
+      `Required checks before push: ${guardrails.requiredChecks.join(', ')}.`,
+    );
+  }
+
+  const blocked = evaluated.denied.length > 0;
+  const approvalRequired = !blocked && evaluated.expansions.length > 0;
+  const decision = blocked
+    ? ('deny' as const)
+    : approvalRequired
+      ? ('require-approval' as const)
+      : ('allow' as const);
+  return {
+    ok: true,
+    action: 'autopilot_policy_check',
+    changed: false,
+    message:
+      decision === 'deny'
+        ? 'Autopilot policy blocks this worktree diff.'
+        : decision === 'require-approval'
+          ? 'Autopilot policy requires explicit approval for this worktree diff.'
+          : 'Autopilot policy allows this worktree diff to proceed to verification.',
+    repoId: repo.id,
+    repoFullName,
+    prNumber: worktree?.prNumber ?? null,
+    mode: policy.mode,
+    limits: guardrails,
+    concurrency: policy.concurrency,
+    diff: {
+      base: diffBase,
+      filesChanged: evaluated.diffSummary.files,
+      linesChanged: evaluated.diffSummary.lines,
+      additions: evaluated.diffSummary.additions,
+      deletions: evaluated.diffSummary.deletions,
+      binaryFiles: evaluated.files.filter((file) => file.binary).length,
+    },
+    files: evaluated.files,
+    decision,
+    approvalClass: approvalRequired ? 'high-risk-diff' : null,
+    policyHash: evaluated.policyHash,
+    blocked,
+    approvalRequired,
+    canPush:
+      policy.mode === 'autofix-push-when-safe' && !blocked && !approvalRequired,
+    reasons,
+    requires: [...requires],
+    fetchedAt: new Date().toISOString(),
+  };
+}
+
+function requirementForViolation(
+  kind:
+    | 'denied-path'
+    | 'high-risk-file'
+    | 'max-files'
+    | 'max-lines'
+    | 'force-push'
+    | 'push-destination',
+) {
+  switch (kind) {
+    case 'denied-path':
+      return 'deniedFileGlobs';
+    case 'high-risk-file':
+      return 'approval';
+    case 'max-files':
+      return 'maxFilesChanged';
+    case 'max-lines':
+      return 'maxLinesChanged';
+    case 'force-push':
+      return 'allowForcePush';
+    case 'push-destination':
+      return 'allowedPushDestinations';
+  }
+}
+
+export async function checkAutopilotConcurrency(
+  input: {
+    repoId: string;
+    prNumber?: number | null;
+    workflow: string;
+    mutation?: boolean;
+  },
+  paths: RuntimePaths = runtimePaths(),
+): Promise<AutopilotConcurrencyDecision> {
+  await ensureRuntimeHome(paths);
+  const appConfig = await readRuntimeJson(paths.config, parseAppConfig);
+  const registry = await readRuntimeJson(paths.repos, parseRepoRegistry);
+  const worktreeSnapshot = await listWorktrees(paths);
+  const repo = registry.repos.find(
+    (candidate) => candidate.id === input.repoId,
+  );
+  const limits = repo
+    ? repoAutopilotPolicy(repo, appConfig).concurrency
+    : globalAutopilotPolicy(appConfig).concurrency;
+  const activeRuns = readActiveAutopilotRuns(paths);
+  const activeRunIds = new Set(activeRuns.map((run) => run.run_id));
+  const activeWorkflowRuns = activeRuns.length;
+  const activeWorktrees = worktreeSnapshot.worktrees.filter((worktree) => {
+    if (worktree.owningWorkflowRunId) {
+      return activeRunIds.has(worktree.owningWorkflowRunId);
+    }
+    if (worktree.lifecycleStatus !== 'busy') return false;
+    return input.workflow !== 'verify_pr_worktree';
+  });
+  const perRepoAutonomousJobs = activeWorktrees.filter(
+    (worktree) => worktree.repoId === input.repoId,
+  ).length;
+  const samePrMutationWorkflows = activeWorktrees.filter(
+    (worktree) =>
+      input.prNumber !== null &&
+      input.prNumber !== undefined &&
+      worktree.repoId === input.repoId &&
+      worktree.prNumber === input.prNumber &&
+      (worktree.owningWorkflowRunId
+        ? mutationWorkflowNames.has(
+            normalizeWorkflowName(
+              activeRuns.find(
+                (run) => run.run_id === worktree.owningWorkflowRunId,
+              )?.workflow ?? '',
+            ),
+          )
+        : true),
+  ).length;
+  const reasons: string[] = [];
+  if (activeWorkflowRuns >= limits.maxActiveWorkflowRuns) {
+    reasons.push(
+      `Active autopilot workflow limit reached (${activeWorkflowRuns}/${limits.maxActiveWorkflowRuns}).`,
+    );
+  }
+  if (activeWorkflowRuns >= limits.maxAutonomousJobs) {
+    reasons.push(
+      `Global autonomous job limit reached (${activeWorkflowRuns}/${limits.maxAutonomousJobs}).`,
+    );
+  }
+  if (perRepoAutonomousJobs >= limits.maxPerRepoAutonomousJobs) {
+    reasons.push(
+      `Per-repo autonomous job limit reached for ${input.repoId} (${perRepoAutonomousJobs}/${limits.maxPerRepoAutonomousJobs}).`,
+    );
+  }
+  if (
+    limits.singleMutationPerPr &&
+    input.mutation !== false &&
+    samePrMutationWorkflows > 0
+  ) {
+    reasons.push(
+      `A mutation workflow is already active for ${input.repoId}#${input.prNumber}.`,
+    );
+  }
+
+  return {
+    ok: reasons.length === 0,
+    action: 'autopilot_concurrency_check',
+    changed: false,
+    message:
+      reasons.length === 0
+        ? 'Autopilot concurrency allows admission.'
+        : 'Autopilot concurrency blocks admission.',
+    allowed: reasons.length === 0,
+    repoId: input.repoId,
+    prNumber: input.prNumber ?? null,
+    workflow: input.workflow,
+    mutation: input.mutation !== false,
+    limits,
+    usage: {
+      autonomousJobs: activeWorkflowRuns,
+      activeWorkflowRuns,
+      perRepoAutonomousJobs,
+      samePrMutationWorkflows,
+      localExecutions: activeLocalExecutions,
+    },
+    reasons,
+  };
+}
+
+export async function withAutopilotLocalExecutionSlot<T>(
+  limits: AutopilotConcurrencyPolicy,
+  run: () => Promise<T>,
+): Promise<T | { blocked: true; message: string }> {
+  if (activeLocalExecutions >= limits.localExecutionLimit) {
+    return {
+      blocked: true,
+      message: `Local execution concurrency limit reached (${activeLocalExecutions}/${limits.localExecutionLimit}).`,
+    };
+  }
+  activeLocalExecutions += 1;
+  try {
+    return await run();
+  } finally {
+    activeLocalExecutions -= 1;
+  }
+}

package/src/modules/briefings/actions.ts

@@ -0,0 +1,80 @@
+import { defineAction } from '@flue/runtime';
+import * as v from 'valibot';
+import { briefingProfileUpdateSchema, briefingRunNowSchema } from './schemas';
+import {
+  readBriefingRunDetails,
+  readBriefingState,
+  rotateBriefingSession,
+  runBriefingNow,
+  updateBriefingProfile,
+} from './service';
+
+const outputSchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.string(),
+  changed: v.boolean(),
+  message: v.optional(v.string()),
+});
+
+export const briefingProfileReadAction = defineAction({
+  name: 'neondeck_briefing_profile_read',
+  description:
+    'Read the typed morning briefing profile, its durable conversation link, and recent operational run metadata.',
+  input: v.object({}),
+  output: outputSchema,
+  async run() {
+    return readBriefingState();
+  },
+});
+
+export const briefingProfileUpdateAction = defineAction({
+  name: 'neondeck_briefing_profile_update',
+  description:
+    'Update the enabled state, cron schedule, timezone, title, or user-authored instructions for the morning briefing profile.',
+  input: briefingProfileUpdateSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return updateBriefingProfile(input);
+  },
+});
+
+export const briefingRunReadAction = defineAction({
+  name: 'neondeck_briefing_run_read',
+  description:
+    'Read one exact persisted deterministic briefing snapshot and its operational dispatch metadata. This never reads or parses the assistant transcript.',
+  input: v.object({ id: v.pipe(v.string(), v.minLength(1)) }),
+  output: outputSchema,
+  async run({ input }) {
+    return readBriefingRunDetails(input.id);
+  },
+});
+
+export const briefingRunNowAction = defineAction({
+  name: 'neondeck_briefing_run_now',
+  description:
+    'Queue an informational briefing in its persistent briefing conversation. All configured display-assistant MCP tools remain available under their normal auth and approval controls.',
+  input: briefingRunNowSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return runBriefingNow(input);
+  },
+});
+
+export const briefingSessionRotateAction = defineAction({
+  name: 'neondeck_briefing_session_rotate',
+  description:
+    'Explicitly start a fresh durable briefing conversation when its captured model, SOUL, memory, skill, or provider context is stale. The old transcript remains preserved.',
+  input: v.object({ id: v.optional(v.string()) }),
+  output: outputSchema,
+  async run({ input }) {
+    return rotateBriefingSession(input);
+  },
+});
+
+export const neondeckBriefingActions = [
+  briefingProfileReadAction,
+  briefingProfileUpdateAction,
+  briefingRunReadAction,
+  briefingRunNowAction,
+  briefingSessionRotateAction,
+];

package/src/modules/briefings/index.ts

@@ -0,0 +1,5 @@
+export * from './actions';
+export * from './schemas';
+export * from './service';
+export * from './snapshot';
+export * from './store';

package/src/modules/briefings/schemas.ts

@@ -0,0 +1,125 @@
+import type { JsonValue } from '@flue/runtime';
+import * as v from 'valibot';
+
+export const defaultBriefingProfileId = 'morning';
+export const defaultBriefingInstructions =
+  'Summarize what needs my attention today. Prioritize review requests, failing checks, blocked automation, and time-sensitive follow-up. Keep the briefing concise and distinguish observed facts from inference.';
+export const defaultBriefingSchedule = '0 8 * * 1-5';
+
+const nonEmptyStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+const timezoneSchema = v.pipe(
+  nonEmptyStringSchema,
+  v.check((value) => {
+    try {
+      new Intl.DateTimeFormat('en-US', { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, 'Timezone must be a valid IANA timezone.'),
+);
+
+export const briefingProfileUpdateSchema = v.object({
+  id: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(64))),
+  name: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(96))),
+  enabled: v.optional(v.boolean()),
+  instructions: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(8_000))),
+  schedule: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(160))),
+  timezone: v.optional(timezoneSchema),
+});
+
+export const briefingRunNowSchema = v.object({
+  profileId: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(64))),
+  sessionId: v.optional(nonEmptyStringSchema),
+  commandEventId: v.optional(nonEmptyStringSchema),
+  trigger: v.optional(v.picklist(['manual', 'dashboard'])),
+});
+
+export const briefingWorkflowInputSchema = v.object({
+  profileId: v.optional(v.pipe(nonEmptyStringSchema, v.maxLength(64))),
+  taskId: v.optional(nonEmptyStringSchema),
+  sessionId: v.optional(nonEmptyStringSchema),
+  commandEventId: v.optional(nonEmptyStringSchema),
+  trigger: v.optional(v.picklist(['manual', 'scheduled', 'dashboard'])),
+});
+
+export const briefingSnapshotSchema = v.object({
+  version: v.literal(1),
+  collectedAt: nonEmptyStringSchema,
+  byteSize: v.pipe(v.number(), v.integer(), v.minValue(0)),
+  truncated: v.boolean(),
+  sources: v.record(
+    v.string(),
+    v.object({
+      status: v.picklist(['ok', 'partial', 'unavailable']),
+      fetchedAt: nonEmptyStringSchema,
+      truncated: v.boolean(),
+      error: v.optional(v.string()),
+      data: v.nullable(v.unknown()),
+    }),
+  ),
+});
+
+export type BriefingSourceStatus = {
+  status: 'ok' | 'partial' | 'unavailable';
+  fetchedAt: string;
+  truncated: boolean;
+  error?: string;
+};
+
+export type BriefingSnapshotSource = BriefingSourceStatus & {
+  data: JsonValue | null;
+};
+
+export type BriefingSnapshot = {
+  version: 1;
+  collectedAt: string;
+  byteSize: number;
+  truncated: boolean;
+  sources: Record<string, BriefingSnapshotSource>;
+};
+
+export type BriefingProfile = {
+  id: string;
+  name: string;
+  enabled: boolean;
+  instructions: string;
+  instructionsVersion: number;
+  schedule: string;
+  timezone: string;
+  sessionId: string | null;
+  compatibility: boolean;
+  createdAt: string | null;
+  updatedAt: string | null;
+};
+
+export type BriefingRunStatus = 'queued' | 'ready' | 'failed';
+
+export type BriefingRun = {
+  id: string;
+  profileId: string | null;
+  trigger: 'manual' | 'scheduled' | 'dashboard';
+  snapshot: BriefingSnapshot;
+  instructions: string;
+  instructionsVersion: number;
+  sessionId: string;
+  commandEventId: string | null;
+  dispatchId: string | null;
+  workflowRunId: string | null;
+  status: BriefingRunStatus;
+  error: string | null;
+  queuedAt: string;
+  completedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type BriefingRunMetadata = Omit<
+  BriefingRun,
+  'snapshot' | 'instructions'
+> & {
+  snapshot: Pick<
+    BriefingSnapshot,
+    'version' | 'collectedAt' | 'byteSize' | 'truncated'
+  >;
+};