niahere 0.2.80 → 0.2.82

package/README.md

@@ -110,7 +110,7 @@ All config and data lives in `~/.niahere/`:
     soul.md         — how the agent works
     rules.md        — behavioral instructions (loaded every session)
     memory.md       — persistent facts and context (loaded every session)
-  jobs/               — per-job working memory and state (auto-created)
+  jobs/               — per-job prompt.md, working memory, and state (auto-created)
   optimizations/      — optimization loop run workspaces
   images/
     reference.webp  — visual identity reference image

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.80",
+  "version": "0.2.82",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/chat/engine.ts

@@ -24,11 +24,14 @@ import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
 import { isRetryableApiError, sleep } from "../utils/retry";
 import { registerActiveHandle, unregisterActiveHandle } from "../core/active-handles";
+import { resolveJobPrompt } from "../core/job-prompt";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 const LONG_RUNNING_WARN = 30 * 60 * 1000; // 30 minutes
 const MAX_SEND_RETRIES = 2;
 const SEND_RETRY_DELAYS = [3_000, 8_000];
+const GENERIC_CHAT_ERROR =
+  "Claude/Anthropic returned an error without details. This is usually temporary; please try again shortly.";
 
 interface SDKUserMessage {
   type: "user";
@@ -93,6 +96,15 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
   return blocks as MessageParam["content"];
 }
 
+/** Convert SDK error text into a channel-safe chat response. */
+export function formatChatError(rawError: string | null | undefined): string {
+  const error = rawError?.trim();
+  if (!error || error.toLowerCase() === "unknown error") {
+    return GENERIC_CHAT_ERROR;
+  }
+  return `[error] ${error}`;
+}
+
 /**
  * Push-based async iterable for streaming user messages to the SDK.
  * Keeps the query subprocess alive between messages.
@@ -187,7 +199,9 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         const agentDef = agents.find((a) => a.name === jobData.agent);
         if (agentDef) systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
       }
-      systemPrompt += `\n\n## Job Context\nYou are chatting in the context of job "${jobData.name}" (schedule: ${jobData.schedule}).\n\nJob prompt:\n${jobData.prompt}`;
+      const resolvedPrompt = resolveJobPrompt(jobData);
+      const source = resolvedPrompt.source === "file" ? ` from ${resolvedPrompt.filePath}` : "";
+      systemPrompt += `\n\n## Job Context\nYou are chatting in the context of job "${jobData.name}" (schedule: ${jobData.schedule}).\n\nJob prompt (${resolvedPrompt.source}${source}):\n${resolvedPrompt.prompt}`;
     }
   }
 
@@ -505,7 +519,18 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                 retryPending.onActivity?.("retrying after API error...");
                 stream!.push(retryPending.userMessage);
               } else {
-                const errorText = `[error] ${rawError}`;
+                const errorText = formatChatError(rawError);
+                log.error(
+                  {
+                    room,
+                    error: rawError,
+                    errors,
+                    subtype: msg.subtype,
+                    terminal_reason: msg.terminal_reason,
+                    session_id: msg.session_id,
+                  },
+                  "chat send failed with SDK result error",
+                );
                 await ActiveEngine.unregister(room);
                 clearLongRunningTimer();
                 pending.resolve({ result: errorText, costUsd: 0, turns: 0 });

package/src/cli/job.ts

@@ -10,6 +10,7 @@ import type { ScheduleType } from "../types";
 import { errMsg } from "../utils/errors";
 import { fail, parseArgs, pickFromList, ICON_PASS, ICON_FAIL } from "../utils/cli";
 import { computeInitialNextRun } from "../core/scheduler";
+import { resolveJobPrompt } from "../core/job-prompt";
 
 const HELP = `Usage: nia job <command>
 
@@ -104,7 +105,8 @@ export async function jobCommand(): Promise<void> {
               const type = job.scheduleType !== "cron" ? ` (${job.scheduleType})` : "";
               const agentTag = job.agent ? `  [${job.agent}]` : "";
               const empTag = job.employee ? `  [emp:${job.employee}]` : "";
-              console.log(`  ${icon} ${job.name}  ${job.schedule}${type}${tag}${agentTag}${empTag}`);
+              const promptTag = resolveJobPrompt(job).source === "file" ? "  [prompt.md]" : "";
+              console.log(`  ${icon} ${job.name}  ${job.schedule}${type}${tag}${agentTag}${empTag}${promptTag}`);
             }
             if (archived.length > 0) {
               console.log(
@@ -283,6 +285,15 @@ export async function jobCommand(): Promise<void> {
           const updated = await Job.update(name, fields);
           if (!updated) fail(`Job not found: "${name}". Use \`nia job list\` to see available jobs.`);
           console.log(`Job "${name}" updated.`);
+          if (fields.prompt !== undefined) {
+            const job = await Job.get(name);
+            if (job) {
+              const resolvedPrompt = resolveJobPrompt(job);
+              if (resolvedPrompt.source === "file") {
+                console.log(`Note: runtime prompt is still overridden by ${resolvedPrompt.filePath}.`);
+              }
+            }
+          }
         });
       } catch (err) {
         fail(`Failed to update job: ${errMsg(err)}`);
@@ -307,7 +318,11 @@ export async function jobCommand(): Promise<void> {
           if (job.employee) console.log(`  employee: ${job.employee}`);
           if (job.model) console.log(`  model:    ${job.model}`);
           if (job.stateless) console.log(`  stateless: true`);
-          console.log(`  prompt:   ${job.prompt}`);
+          const resolvedPrompt = resolveJobPrompt(job);
+          const promptSource =
+            resolvedPrompt.source === "file" ? `file (${resolvedPrompt.filePath})` : resolvedPrompt.source;
+          console.log(`  prompt source: ${promptSource}`);
+          console.log(`  prompt:   ${resolvedPrompt.prompt}`);
 
           const state = readState();
           const info = state[job.name];

package/src/core/job-prompt.ts

@@ -0,0 +1,78 @@
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import type { JobInput, ResolvedJobPrompt } from "../types";
+import { log } from "../utils/log";
+import { getJobDir } from "../utils/job-workspace";
+
+const DEFAULT_JOB_PROMPT = "Execute your scheduled tasks.";
+
+export { getJobDir } from "../utils/job-workspace";
+
+export function resolveJobPrompt(job: JobInput): ResolvedJobPrompt {
+  let promptPath: string | null = null;
+  try {
+    promptPath = join(getJobDir(job.name), "prompt.md");
+  } catch (err) {
+    log.warn({ err, job: job.name }, "job has no safe workspace; falling back to database prompt");
+  }
+
+  if (promptPath && existsSync(promptPath)) {
+    try {
+      const filePrompt = readFileSync(promptPath, "utf8").trim();
+      if (filePrompt) {
+        return { prompt: filePrompt, source: "file", filePath: promptPath };
+      }
+      log.warn({ job: job.name, promptPath }, "job prompt.md is empty; falling back to database prompt");
+    } catch (err) {
+      log.warn({ err, job: job.name, promptPath }, "failed to read job prompt.md; falling back to database prompt");
+    }
+  }
+
+  const dbPrompt = job.prompt.trim();
+  if (dbPrompt) {
+    return { prompt: dbPrompt, source: "database", filePath: null };
+  }
+
+  return { prompt: DEFAULT_JOB_PROMPT, source: "default", filePath: null };
+}
+
+/** Build the working memory block for a stateful job. Returns empty string for stateless jobs. */
+export function buildWorkingMemory(jobName: string, stateless?: boolean): string {
+  if (stateless) return "";
+
+  let jobDir: string;
+  try {
+    jobDir = getJobDir(jobName);
+  } catch (err) {
+    log.warn({ err, job: jobName }, "job has no safe workspace; working memory disabled");
+    return "";
+  }
+  mkdirSync(jobDir, { recursive: true });
+  const statePath = join(jobDir, "state.md");
+  let stateContent = "";
+  if (existsSync(statePath)) {
+    try {
+      stateContent = readFileSync(statePath, "utf8").trim();
+    } catch {
+      stateContent = "";
+    }
+  }
+
+  const stateBlock = stateContent ? `\n${stateContent}\n` : "(first run - no prior state)";
+
+  return `
+
+## Working Memory
+
+You have a persistent workspace at \`${jobDir}/\`. This directory is yours - create files, organize data, track history, maintain state however you need.
+
+Your \`state.md\` from last run:
+${stateBlock}
+
+Before finishing, update \`state.md\` with: what you did this run, what you noticed, and what to do or focus on next time. Keep it concise - a working notebook, not a log.`;
+}
+
+export function buildJobPrompt(job: JobInput): string {
+  const resolved = resolveJobPrompt(job);
+  return `Job: ${job.name} (schedule: ${job.schedule})\n\n${resolved.prompt}${buildWorkingMemory(job.name, job.stateless)}`;
+}

package/src/core/runner.ts

@@ -1,6 +1,5 @@
 import { homedir } from "os";
-import { existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync } from "fs";
 import { randomUUID } from "crypto";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { JobInput, JobResult } from "../types";
@@ -11,14 +10,16 @@ import { buildSystemPrompt, buildContextSuffix } from "../chat/identity";
 import { buildEmployeePrompt } from "../chat/employee-prompt";
 import { getEmployee } from "./employees";
 import { scanAgents } from "./agents";
+import { buildJobPrompt } from "./job-prompt";
 import { truncate, formatToolUse } from "../utils/format-activity";
 import { getMcpServers, type McpSourceContext } from "../mcp";
 import { ActiveEngine } from "../db/models";
-import { getPaths } from "../utils/paths";
 import { log } from "../utils/log";
 import { isRetryableApiError, sleep } from "../utils/retry";
 import { registerActiveHandle, unregisterActiveHandle } from "./active-handles";
 
+export { buildWorkingMemory } from "./job-prompt";
+
 export type ActivityCallback = (line: string) => void;
 
 interface RunnerOutput {
@@ -284,40 +285,6 @@ export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Working memory
-// ---------------------------------------------------------------------------
-
-/** Build the working memory block for a stateful job. Returns empty string for stateless jobs. */
-export function buildWorkingMemory(jobName: string, stateless?: boolean): string {
-  if (stateless) return "";
-
-  const jobDir = join(getPaths().jobsDir, jobName);
-  mkdirSync(jobDir, { recursive: true });
-  const statePath = join(jobDir, "state.md");
-  let stateContent = "";
-  if (existsSync(statePath)) {
-    try {
-      stateContent = readFileSync(statePath, "utf8").trim();
-    } catch {
-      stateContent = "";
-    }
-  }
-
-  const stateBlock = stateContent ? `\n${stateContent}\n` : "(first run — no prior state)";
-
-  return `
-
-## Working Memory
-
-You have a persistent workspace at \`${jobDir}/\`. This directory is yours — create files, organize data, track history, maintain state however you need.
-
-Your \`state.md\` from last run:
-${stateBlock}
-
-Before finishing, update \`state.md\` with: what you did this run, what you noticed, and what to do or focus on next time. Keep it concise — a working notebook, not a log.`;
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -364,12 +331,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       systemPrompt = buildSystemPrompt("job");
     }
 
-    let jobPrompt = job.prompt
-      ? `Job: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`
-      : `Job: ${job.name} (schedule: ${job.schedule})\n\nExecute your scheduled tasks.`;
-
-    // Working memory: give stateful jobs a persistent workspace
-    jobPrompt += buildWorkingMemory(job.name, job.stateless);
+    const jobPrompt = buildJobPrompt(job);
 
     // Model priority: job.model > agent.model > config.model
     const resolvedModel = job.model || agentModel || config.model;

package/src/db/models/job.ts

@@ -3,6 +3,7 @@ import { CronExpressionParser } from "cron-parser";
 import { parseDuration } from "../../utils/duration";
 import { computeInitialNextRun } from "../../utils/schedule";
 import { getConfig } from "../../utils/config";
+import { validateJobName } from "../../utils/job-workspace";
 import type { ScheduleType, JobLifecycle } from "../../types";
 
 /** Validate that a schedule string matches its declared type. Throws on mismatch. */
@@ -96,6 +97,7 @@ export async function create(
   model?: string,
   employee?: string,
 ): Promise<void> {
+  validateJobName(name);
   validateSchedule(schedule, scheduleType);
   const existing = await get(name);
   if (existing) {

package/src/mcp/server.ts

@@ -17,7 +17,11 @@ export function createNiaMcpServer(sourceCtx?: McpSourceContext) {
         {
           name: z.string().describe("Unique job name"),
           schedule: z.string().describe("Cron expression, duration string, or ISO timestamp"),
-          prompt: z.string().describe("What the job should do"),
+          prompt: z
+            .string()
+            .describe(
+              "What the job should do. A non-empty ~/.niahere/jobs/<job-name>/prompt.md overrides this database prompt at runtime.",
+            ),
           schedule_type: z.enum(["cron", "interval", "once"]).default("cron").describe("Schedule type"),
           always: z.boolean().default(false).describe("If true, runs 24/7 ignoring active hours"),
           agent: z
@@ -50,7 +54,12 @@ export function createNiaMcpServer(sourceCtx?: McpSourceContext) {
             .string()
             .optional()
             .describe("New schedule (cron expression, interval duration, or ISO timestamp)"),
-          prompt: z.string().optional().describe("New prompt"),
+          prompt: z
+            .string()
+            .optional()
+            .describe(
+              "New database prompt. A non-empty ~/.niahere/jobs/<job-name>/prompt.md overrides this at runtime.",
+            ),
           always: z.boolean().optional().describe("If true, runs 24/7 ignoring active hours"),
           agent: z.string().nullable().optional().describe("Agent name (set null to remove agent)"),
           employee: z.string().nullable().optional().describe("Employee name (set null to remove employee)"),

package/src/mcp/tools.ts

@@ -11,12 +11,22 @@ import { log } from "../utils/log";
 import { classifyMime } from "../utils/attachment";
 import { scanAgents } from "../core/agents";
 import { listEmployeesForMcp } from "../core/employees";
+import { resolveJobPrompt } from "../core/job-prompt";
 import type { McpSourceContext } from "./index";
 
 export async function listJobs(): Promise<string> {
   const jobs = await Job.list();
   if (jobs.length === 0) return "No jobs found.";
-  return JSON.stringify(jobs, null, 2);
+  const withPromptSource = jobs.map((job) => {
+    const resolvedPrompt = resolveJobPrompt(job);
+    return {
+      ...job,
+      prompt: resolvedPrompt.prompt,
+      promptSource: resolvedPrompt.source,
+      promptPath: resolvedPrompt.filePath,
+    };
+  });
+  return JSON.stringify(withPromptSource, null, 2);
 }
 
 export async function addJob(args: {
@@ -89,6 +99,15 @@ export async function updateJob(args: {
 
   const updated = await Job.update(args.name, fields);
   if (!updated) return `Job "${args.name}" not found.`;
+  if (fields.prompt !== undefined) {
+    const job = await Job.get(args.name);
+    if (job) {
+      const resolvedPrompt = resolveJobPrompt(job);
+      if (resolvedPrompt.source === "file") {
+        return `Job "${args.name}" updated. Note: runtime prompt is still overridden by ${resolvedPrompt.filePath}.`;
+      }
+    }
+  }
   return `Job "${args.name}" updated.`;
 }
 

package/src/prompts/environment.md

@@ -39,7 +39,7 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
   - Set `stateless: true` to disable working memory (no state.md or workspace)
   - Set `model` to override the default (e.g., `haiku`, `sonnet`, `opus`) — use cheaper models for high-frequency or simple jobs. Priority: job model > agent model > config model.
   - Set `employee` to assign the job to an employee (employee identity takes precedence over agent)
-- **update_job** — update an existing job's schedule, prompt, always, stateless, agent, model, or employee
+- **update_job** — update an existing job's schedule, prompt, always, stateless, agent, model, or employee. If `~/.niahere/jobs/<job-name>/prompt.md` exists and is non-empty, it overrides the database prompt at runtime.
 - **remove_job** — delete a job by name
 - **enable_job** / **disable_job** — toggle a job on or off
 - **archive_job** — archive a job (hidden from list, won't run)
@@ -68,7 +68,9 @@ Active hours: {{activeStart}}–{{activeEnd}} ({{timezone}}). Jobs respect this;
 
 Jobs are **stateful by default**. Each job gets a persistent workspace at `~/.niahere/jobs/<job-name>/`. Before each run, the runner reads `state.md` from that directory and injects it into the prompt. The agent should update `state.md` at the end of each run with what it did, what it noticed, and what to focus on next time.
 
-The workspace is freeform — the agent can create any files it needs (data, cache, history, etc.). `state.md` is the convention for the runner to inject automatically; everything else is the agent's to organize.
+Jobs may also keep their task instructions in `~/.niahere/jobs/<job-name>/prompt.md`. If this file exists and is non-empty, it is the runtime job prompt. If it is missing or empty, the job falls back to the database prompt set through `add_job`, `update_job`, or `nia job update --prompt`.
+
+The workspace is freeform — the agent can create any files it needs (data, cache, history, etc.). `prompt.md` is the editable task prompt convention; `state.md` is the working-memory convention the runner injects automatically.
 
 To disable working memory for a specific job, set `stateless: true` when creating or updating it.
 

package/src/types/index.ts

@@ -1,6 +1,6 @@
 export type { Attachment } from "./attachment";
 export type { JobStatus, JobStateStatus, JobLifecycle, ScheduleType, Mode, AttachmentType, ChannelName } from "./enums";
-export type { JobInput, JobResult } from "./job";
+export type { JobInput, JobPromptSource, JobResult, ResolvedJobPrompt } from "./job";
 export type { SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "./engine";
 export type { AuditEntry, JobState, CronState } from "./audit";
 export type { Channel, ChannelFactory } from "./channel";

package/src/types/job.ts

@@ -10,6 +10,14 @@ export interface JobInput {
   stateless?: boolean;
 }
 
+export type JobPromptSource = "file" | "database" | "default";
+
+export interface ResolvedJobPrompt {
+  prompt: string;
+  source: JobPromptSource;
+  filePath: string | null;
+}
+
 export interface JobResult {
   job: string;
   timestamp: string;

package/src/utils/job-workspace.ts

@@ -0,0 +1,19 @@
+import { isAbsolute, relative, resolve } from "path";
+
+import { getPaths } from "./paths";
+
+export function getJobDir(jobName: string): string {
+  const jobsDir = resolve(getPaths().jobsDir);
+  const jobDir = resolve(jobsDir, jobName);
+  const rel = relative(jobsDir, jobDir);
+
+  if (!rel || rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`Invalid job name "${jobName}": job workspace must stay inside ${jobsDir}`);
+  }
+
+  return jobDir;
+}
+
+export function validateJobName(jobName: string): void {
+  getJobDir(jobName);
+}