neondeck 1.0.0-beta.4

package/src/modules/safety/schemas.ts

@@ -0,0 +1,63 @@
+import * as v from 'valibot';
+
+export type SafetyClass =
+  'read-only' | 'safe-mutation' | 'destructive-mutation' | 'host-execution';
+
+export type SafetyPrimitive = 'tool' | 'action' | 'workflow' | 'route' | 'cli';
+
+export type SafetyPolicyEntry = {
+  id: string;
+  primitive: SafetyPrimitive;
+  title: string;
+  class: SafetyClass;
+  unattended: boolean;
+  requiresConfirmation: boolean;
+  audited: boolean;
+  auditTarget: string;
+  notes: string;
+};
+
+export type SafetyPolicy = {
+  ok: boolean;
+  action: 'safety_policy_read';
+  version: number;
+  summary: {
+    readOnly: number;
+    safeMutation: number;
+    destructiveMutation: number;
+    hostExecution: number;
+    requiresConfirmation: number;
+    unattendedAllowed: number;
+    audited: number;
+  };
+  confirmationPolicy: string;
+  hostExecutionPolicy: string;
+  executionPolicy: {
+    defaultBackend: string;
+    enabledBackends: string[];
+    supportedBackends: string[];
+    approvalMode: string;
+    unattended: string;
+    preapprovedCommandCount: number;
+    defaultLocalAccess: boolean;
+    exeDevPlanned: boolean;
+  };
+  entries: SafetyPolicyEntry[];
+  fetchedAt: string;
+};
+
+export const safetyPolicySchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.literal('safety_policy_read'),
+  version: v.number(),
+  summary: v.looseObject({
+    readOnly: v.number(),
+    safeMutation: v.number(),
+    destructiveMutation: v.number(),
+    hostExecution: v.number(),
+    requiresConfirmation: v.number(),
+    unattendedAllowed: v.number(),
+    audited: v.number(),
+  }),
+  entries: v.array(v.unknown()),
+});

package/src/modules/safety/service.ts

@@ -0,0 +1,58 @@
+import { executionPolicyFromConfig } from '../execution-policy';
+import {
+  type RuntimePaths,
+  ensureRuntimeHomeSync,
+  parseAppConfig,
+  readRuntimeJsonSync,
+  runtimePaths,
+} from '../../runtime-home';
+import { entries } from './policy-entries';
+import { type SafetyPolicy, type SafetyPolicyEntry } from './schemas';
+
+export function readSafetyPolicy(
+  paths: RuntimePaths = runtimePaths(),
+): SafetyPolicy {
+  ensureRuntimeHomeSync(paths);
+  const execution = executionPolicyFromConfig(
+    readRuntimeJsonSync(paths.config, parseAppConfig),
+  );
+  return {
+    ok: true,
+    action: 'safety_policy_read',
+    version: 5,
+    summary: summarizeEntries(entries),
+    confirmationPolicy:
+      'Destructive mutations require explicit user confirmation and action input confirm=true. Safe mutations should be user-directed and audited when they change durable state.',
+    hostExecutionPolicy: `Host execution is action-mediated. Backends enabled by config: ${execution.enabledBackends.join(', ')}. Preapproved single commands may run without an interactive approval through neondeck_execution_run; all other interactive commands require approval and unattended commands default to deny. Hardline commands cannot be preapproved.`,
+    executionPolicy: {
+      defaultBackend: execution.defaultBackend,
+      enabledBackends: execution.enabledBackends,
+      supportedBackends: execution.supportedBackends,
+      approvalMode: execution.approvalMode,
+      unattended: execution.unattended,
+      preapprovedCommandCount: execution.preapprovedCommands.length,
+      defaultLocalAccess: execution.defaults.localAccess,
+      exeDevPlanned: execution.defaults.exeDevPlanned,
+    },
+    entries,
+    fetchedAt: new Date().toISOString(),
+  };
+}
+
+export function summarizeEntries(
+  items: SafetyPolicyEntry[],
+): SafetyPolicy['summary'] {
+  return {
+    readOnly: items.filter((item) => item.class === 'read-only').length,
+    safeMutation: items.filter((item) => item.class === 'safe-mutation').length,
+    destructiveMutation: items.filter(
+      (item) => item.class === 'destructive-mutation',
+    ).length,
+    hostExecution: items.filter((item) => item.class === 'host-execution')
+      .length,
+    requiresConfirmation: items.filter((item) => item.requiresConfirmation)
+      .length,
+    unattendedAllowed: items.filter((item) => item.unattended).length,
+    audited: items.filter((item) => item.audited).length,
+  };
+}

package/src/modules/safety/tools.ts

@@ -0,0 +1,15 @@
+import { defineTool } from '@flue/runtime';
+import * as v from 'valibot';
+import { readSafetyPolicy } from './service';
+import { safetyPolicySchema } from './schemas';
+
+export const safetyPolicyLookupTool = defineTool({
+  name: 'neondeck_safety_policy_lookup',
+  description:
+    'Read Neondeck safety and approval policy for read-only, mutation, destructive, and future host-execution actions.',
+  input: v.object({}),
+  output: safetyPolicySchema,
+  run() {
+    return readSafetyPolicy();
+  },
+});

package/src/modules/scheduled-tasks/actions.ts

@@ -0,0 +1,113 @@
+import { defineAction } from '@flue/runtime';
+import * as v from 'valibot';
+import {
+  agentInstructionTaskInputSchema,
+  briefingTaskInputSchema,
+  createAgentInstructionTask,
+  createBriefingTask,
+  listTaskRecords,
+  readTaskRecord,
+  removeTask,
+  scheduledTaskIdInputSchema,
+  setTaskEnabled,
+} from './service';
+
+const actionOutputSchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.string(),
+  changed: v.boolean(),
+  message: v.string(),
+});
+
+export const scheduledBriefingTaskCreateAction = defineAction({
+  name: 'neondeck_scheduled_task_briefing_create',
+  description: 'Create or update a timezone-aware scheduled briefing task.',
+  input: briefingTaskInputSchema,
+  output: actionOutputSchema,
+  async run({ input }) {
+    return createBriefingTask(input);
+  },
+});
+
+export const scheduledInstructionTaskCreateAction = defineAction({
+  name: 'neondeck_scheduled_task_instruction_create',
+  description:
+    'Create or update a scheduled bounded agent instruction. Use an agent-session target only when continuity is explicitly required.',
+  input: agentInstructionTaskInputSchema,
+  output: actionOutputSchema,
+  async run({ input }) {
+    return createAgentInstructionTask(input);
+  },
+});
+
+export const scheduledTaskListAction = defineAction({
+  name: 'neondeck_scheduled_task_list',
+  description: 'List canonical scheduled tasks and their most recent run.',
+  input: v.object({}),
+  output: actionOutputSchema,
+  async run() {
+    return listTaskRecords();
+  },
+});
+
+export const scheduledTaskReadAction = defineAction({
+  name: 'neondeck_scheduled_task_read',
+  description: 'Read one canonical scheduled task and its most recent run.',
+  input: scheduledTaskIdInputSchema,
+  output: actionOutputSchema,
+  async run({ input }) {
+    return readTaskRecord(input.id);
+  },
+});
+
+export const scheduledTaskPauseAction = defineAction({
+  name: 'neondeck_scheduled_task_pause',
+  description: 'Pause a scheduled task without deleting its run history.',
+  input: scheduledTaskIdInputSchema,
+  output: actionOutputSchema,
+  async run({ input }) {
+    return setTaskEnabled(input.id, false);
+  },
+});
+
+export const scheduledTaskResumeAction = defineAction({
+  name: 'neondeck_scheduled_task_resume',
+  description: 'Resume a scheduled task without immediately executing it.',
+  input: scheduledTaskIdInputSchema,
+  output: actionOutputSchema,
+  async run({ input }) {
+    return setTaskEnabled(input.id, true);
+  },
+});
+
+export const scheduledTaskDeleteAction = defineAction({
+  name: 'neondeck_scheduled_task_delete',
+  description: 'Delete a scheduled task and its local run history.',
+  input: v.object({
+    id: scheduledTaskIdInputSchema.entries.id,
+    confirm: v.optional(v.boolean()),
+  }),
+  output: actionOutputSchema,
+  async run({ input }) {
+    if (input.confirm !== true) {
+      return {
+        ok: false,
+        action: 'scheduled_task_delete',
+        changed: false,
+        message: 'Deleting a scheduled task requires confirmation.',
+        requires: ['confirm'],
+      };
+    }
+    return removeTask(input.id);
+  },
+});
+
+export const neondeckScheduledTaskActions = [
+  scheduledBriefingTaskCreateAction,
+  scheduledInstructionTaskCreateAction,
+  scheduledTaskListAction,
+  scheduledTaskReadAction,
+  scheduledTaskPauseAction,
+  scheduledTaskResumeAction,
+  scheduledTaskDeleteAction,
+];

package/src/modules/scheduled-tasks/dispatch.ts

@@ -0,0 +1,105 @@
+import { dispatch, type JsonValue } from '@flue/runtime';
+import type { NotificationLevel } from '../app-state';
+import type { RuntimePaths } from '../../runtime-home';
+import { loadRuntimeSkill } from '../runtime';
+import { refreshWatchTask } from '../scheduler/dispatch';
+import type { SchedulerDependencies } from '../scheduler/schemas';
+import { invokeScheduledWorkflow } from '../scheduler/workflow-invocation';
+import type { ScheduledTaskRecord } from './schemas';
+
+export type ScheduledTaskExecutionResult = {
+  outcome: 'recorded' | 'silent' | 'failed';
+  message: string;
+  result?: unknown;
+  workflowRunId?: string;
+  sessionId?: string;
+  notifications?: Array<{
+    level: NotificationLevel;
+    title: string;
+    message: string;
+    source?: string;
+    sourceId?: string;
+    data?: unknown;
+  }>;
+};
+
+export async function executeScheduledTask(
+  task: ScheduledTaskRecord,
+  previousResult: JsonValue | null,
+  paths: RuntimePaths,
+  dependencies: SchedulerDependencies = {},
+): Promise<ScheduledTaskExecutionResult> {
+  if (task.spec.kind === 'poll-pr-watch') {
+    const result = await refreshWatchTask(
+      task.spec.watchId,
+      previousResult,
+      paths,
+      dependencies,
+    );
+    return {
+      ...result,
+      outcome: result.outcome === 'updated' ? 'recorded' : result.outcome,
+    };
+  }
+
+  if (task.spec.kind === 'run-briefing') {
+    const invokeWorkflow =
+      dependencies.invokeWorkflow ?? invokeScheduledWorkflow;
+    const { runId } = await invokeWorkflow('briefing', {});
+    return {
+      outcome: 'recorded',
+      message: `Admitted briefing workflow ${runId}.`,
+      workflowRunId: runId,
+      result: { runId, briefingId: task.spec.briefingId },
+    };
+  }
+
+  const prompt = await composeInstructionPrompt(task, paths);
+  if (task.spec.target.kind === 'workflow') {
+    const invokeWorkflow =
+      dependencies.invokeWorkflow ?? invokeScheduledWorkflow;
+    const { runId } = await invokeWorkflow(
+      'scheduled-agent-instruction',
+      { prompt },
+    );
+    return {
+      outcome: 'recorded',
+      message: `Admitted scheduled instruction workflow ${runId}.`,
+      workflowRunId: runId,
+      result: { runId },
+    };
+  }
+
+  const receipt = await dispatch({
+    agent: 'display-assistant',
+    id: task.spec.target.sessionId,
+    input: prompt,
+  });
+  return {
+    outcome: 'recorded',
+    message: `Dispatched scheduled instruction to session ${task.spec.target.sessionId}.`,
+    sessionId: task.spec.target.sessionId,
+    result: { dispatchId: receipt.dispatchId, acceptedAt: receipt.acceptedAt },
+  };
+}
+
+async function composeInstructionPrompt(
+  task: ScheduledTaskRecord,
+  paths: RuntimePaths,
+) {
+  if (task.spec.kind !== 'run-agent-instruction') {
+    throw new Error(`Task "${task.id}" is not an agent instruction.`);
+  }
+  const context = [
+    'This is a bounded scheduled Neondeck instruction. Complete the requested work, report concrete results, and do not schedule follow-up work yourself.',
+    task.spec.repoId ? `Repository id: ${task.spec.repoId}` : null,
+    task.spec.cwd ? `Requested working directory: ${task.spec.cwd}` : null,
+  ].filter((line): line is string => Boolean(line));
+  const skills = [];
+  for (const id of task.spec.skills) {
+    const loaded = await loadRuntimeSkill({ id }, paths);
+    if (!loaded.ok) throw new Error(loaded.error);
+    skills.push(`\n\nSkill "${id}":\n${loaded.skill.content}`);
+  }
+  return `${context.join('\n')}\n\nInstruction:\n${task.spec.prompt}${skills.join('')}`;
+}

package/src/modules/scheduled-tasks/index.ts

@@ -0,0 +1,6 @@
+export * from './actions';
+export * from './dispatch';
+export * from './schemas';
+export * from './service';
+export * from './store';
+export * from './triggers';

package/src/modules/scheduled-tasks/schemas.ts

@@ -0,0 +1,91 @@
+import type { JsonValue } from '@flue/runtime';
+import * as v from 'valibot';
+
+export type AutomationTrigger =
+  | { kind: 'interval'; everySeconds: number }
+  | { kind: 'once'; at: string }
+  | { kind: 'cron'; expression: string; timezone: string };
+
+export type ScheduledTaskSpec =
+  | { kind: 'poll-pr-watch'; watchId: string }
+  | { kind: 'run-briefing'; briefingId: string }
+  | {
+      kind: 'run-agent-instruction';
+      prompt: string;
+      target:
+        { kind: 'workflow' } | { kind: 'agent-session'; sessionId: string };
+      repoId?: string;
+      cwd?: string;
+      skills: string[];
+    };
+
+export type ScheduledTaskRecord = {
+  id: string;
+  spec: ScheduledTaskSpec;
+  trigger: AutomationTrigger;
+  enabled: boolean;
+  nextRunAt: string | null;
+  claimId: string | null;
+  claimExpiresAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+  lastRunAt: string | null;
+};
+
+export type ScheduledTaskRunRecord = {
+  id: string;
+  taskId: string;
+  status: 'claimed' | 'active' | 'completed' | 'failed';
+  outcome: 'recorded' | 'silent' | 'failed';
+  message: string;
+  workflowRunId: string | null;
+  sessionId: string | null;
+  result: JsonValue | null;
+  error: string | null;
+  startedAt: string;
+  completedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export const nonEmptyStringSchema = v.pipe(v.string(), v.minLength(1));
+export const automationTriggerSchema = v.variant('kind', [
+  v.object({
+    kind: v.literal('interval'),
+    everySeconds: v.pipe(v.number(), v.integer(), v.minValue(60)),
+  }),
+  v.object({
+    kind: v.literal('once'),
+    at: nonEmptyStringSchema,
+  }),
+  v.object({
+    kind: v.literal('cron'),
+    expression: nonEmptyStringSchema,
+    timezone: nonEmptyStringSchema,
+  }),
+]);
+
+export const scheduledTaskSpecSchema = v.variant('kind', [
+  v.object({
+    kind: v.literal('poll-pr-watch'),
+    watchId: nonEmptyStringSchema,
+  }),
+  v.object({
+    kind: v.literal('run-briefing'),
+    briefingId: nonEmptyStringSchema,
+  }),
+  v.object({
+    kind: v.literal('run-agent-instruction'),
+    prompt: v.pipe(v.string(), v.minLength(1), v.maxLength(8_000)),
+    target: v.variant('kind', [
+      v.object({ kind: v.literal('workflow') }),
+      v.object({
+        kind: v.literal('agent-session'),
+        sessionId: nonEmptyStringSchema,
+      }),
+    ]),
+    repoId: v.optional(nonEmptyStringSchema),
+    cwd: v.optional(nonEmptyStringSchema),
+    skills: v.array(nonEmptyStringSchema),
+  }),
+]);