niahere 0.2.56 → 0.2.57

package/README.md

@@ -63,8 +63,8 @@ nia update                     — update to latest version (auto-backup + resta
 nia job list                   — list all jobs
 nia job show [name]            — full details + recent runs
 nia job status [name]          — quick status check
-nia job add <n> <s> <p>        — add a job (--type, --always, --agent, --prompt-file)
-nia job update <name>          — update a job (--schedule, --prompt, --prompt-file, --type, --always, --agent)
+nia job add <n> <s> <p>        — add a job (--type, --always, --agent, --stateless, --prompt-file)
+nia job update <name>          — update a job (--schedule, --prompt, --prompt-file, --type, --always, --agent, --stateless)
 nia job remove <name>          — delete a job
 nia job enable / disable <n>   — toggle a job
 nia job run <name>             — run a job once

package/package.json

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

package/src/cli/job.ts

@@ -23,6 +23,7 @@ Commands:
       --type cron|interval|once   Schedule type (default: cron)
       --always                    Run 24/7 regardless of active hours
       --agent <name>              Assign an agent to the job
+      --stateless yes|no          Disable working memory for this job
   update <name>                 Update a job
       --schedule <schedule>       New schedule
       --prompt <text>             New prompt
@@ -30,6 +31,7 @@ Commands:
       --type cron|interval|once   Change schedule type
       --always / --no-always      Toggle 24/7 mode
       --agent <name>              Assign agent (--no-agent to remove)
+      --stateless yes|no            Toggle working memory
   remove <name>                 Delete a job
   enable <name>                 Enable a job
   disable <name>                Disable a job
@@ -100,6 +102,8 @@ export async function jobCommand(): Promise<void> {
       }
 
       const always = args.getBool("always") ?? false;
+      const statelessRaw = args.getString("stateless");
+      const stateless = statelessRaw ? ["yes", "y", "true", "t", "1"].includes(statelessRaw.toLowerCase()) : false;
       const agent = args.getString("agent");
 
       const [name, schedule, ...promptParts] = args.positional;
@@ -125,7 +129,7 @@ export async function jobCommand(): Promise<void> {
         const config = getConfig();
         const nextRunAt = computeInitialNextRun(scheduleType, schedule, config.timezone);
         await withDb(async () => {
-          await Job.create(name, schedule, prompt, always, scheduleType, nextRunAt, agent);
+          await Job.create(name, schedule, prompt, always, scheduleType, nextRunAt, agent, stateless);
           console.log(`Job "${name}" added (${scheduleType}: ${schedule}).${always ? " (runs 24/7)" : ""}`);
         });
       } catch (err) {
@@ -176,7 +180,7 @@ export async function jobCommand(): Promise<void> {
         fail('Example: nia job update curator --schedule "4h" --prompt "New prompt"');
       }
 
-      const fields: Partial<{ schedule: string; prompt: string; always: boolean; scheduleType: ScheduleType; agent: string | null }> = {};
+      const fields: Partial<{ schedule: string; prompt: string; always: boolean; stateless: boolean; scheduleType: ScheduleType; agent: string | null }> = {};
       const schedule = args.getString("schedule");
       const promptFile = args.getString("prompt-file");
       let prompt = args.getString("prompt");
@@ -187,6 +191,7 @@ export async function jobCommand(): Promise<void> {
       }
       const scheduleType = args.getString("type") as ScheduleType | undefined;
       const always = args.getBool("always");
+      const statelessRaw = args.getString("stateless");
       const agent = args.getString("agent");
       const noAgent = args.getBool("agent");
 
@@ -199,11 +204,12 @@ export async function jobCommand(): Promise<void> {
         fields.scheduleType = scheduleType;
       }
       if (always !== undefined) fields.always = always;
+      if (statelessRaw) fields.stateless = ["yes", "y", "true", "t", "1"].includes(statelessRaw.toLowerCase());
       if (agent) fields.agent = agent;
       if (noAgent === false) fields.agent = null;
 
       if (Object.keys(fields).length === 0) {
-        fail("Nothing to update. Pass at least one flag (--schedule, --prompt, --type, --always, --agent).");
+        fail("Nothing to update. Pass at least one flag (--schedule, --prompt, --type, --always, --stateless, --agent).");
       }
 
       try {
@@ -231,6 +237,7 @@ export async function jobCommand(): Promise<void> {
           console.log(`  enabled:  ${job.enabled}`);
           console.log(`  always:   ${job.always}`);
           if (job.agent) console.log(`  agent:    ${job.agent}`);
+          if (job.stateless) console.log(`  stateless: true`);
           console.log(`  prompt:   ${job.prompt}`);
 
           const state = readState();

package/src/core/runner.ts

@@ -1,5 +1,6 @@
 import { homedir } from "os";
-import { existsSync } from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
 import { randomUUID } from "crypto";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { JobInput, JobResult } from "../types";
@@ -11,6 +12,7 @@ import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
 import { getMcpServers } from "../mcp";
 import { ActiveEngine } from "../db/models";
+import { getPaths } from "../utils/paths";
 import { log } from "../utils/log";
 
 export type ActivityCallback = (line: string) => void;
@@ -222,6 +224,42 @@ 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
 // ---------------------------------------------------------------------------
@@ -256,10 +294,13 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       systemPrompt = buildSystemPrompt("job");
     }
 
-    const jobPrompt = job.prompt
+    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);
+
     if (config.runner === "codex") {
       const fullPrompt = `${systemPrompt}\n\n---\n\n${jobPrompt}`;
       output = await runJobWithCodex(fullPrompt, cwd, agentModel || config.model);

package/src/db/migrations/012_jobs_stateless.ts

@@ -0,0 +1,7 @@
+import type postgres from "postgres";
+
+export const name = "012_jobs_stateless";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`ALTER TABLE jobs ADD COLUMN IF NOT EXISTS stateless BOOLEAN DEFAULT FALSE`;
+}

package/src/db/models/job.ts

@@ -38,6 +38,7 @@ export interface Job {
   always: boolean;
   scheduleType: ScheduleType;
   agent: string | null;
+  stateless: boolean;
   nextRunAt: string | null;
   lastRunAt: string | null;
   createdAt: string;
@@ -53,6 +54,7 @@ function toJob(r: Record<string, any>): Job {
     always: r.always ?? false,
     scheduleType: r.schedule_type || "cron",
     agent: r.agent || null,
+    stateless: r.stateless ?? false,
     nextRunAt: r.next_run_at ? String(r.next_run_at) : null,
     lastRunAt: r.last_run_at ? String(r.last_run_at) : null,
     createdAt: String(r.created_at),
@@ -73,6 +75,7 @@ export async function create(
   scheduleType: ScheduleType = "cron",
   nextRunAt?: Date,
   agent?: string,
+  stateless = false,
 ): Promise<void> {
   validateSchedule(schedule, scheduleType);
   const existing = await get(name);
@@ -81,27 +84,27 @@ export async function create(
   }
   const sql = getSql();
   await sql`
-    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at, agent)
-    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null}, ${agent ?? null})
+    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at, agent, stateless)
+    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null}, ${agent ?? null}, ${stateless})
   `;
   await notifyChange();
 }
 
 export async function list(): Promise<Job[]> {
   const sql = getSql();
-  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, next_run_at, last_run_at, created_at, updated_at FROM jobs ORDER BY name`;
+  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs ORDER BY name`;
   return rows.map(toJob);
 }
 
 export async function get(name: string): Promise<Job | null> {
   const sql = getSql();
-  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
+  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
   return rows.length > 0 ? toJob(rows[0]) : null;
 }
 
 export async function update(
   name: string,
-  fields: Partial<{ schedule: string; prompt: string; enabled: boolean; always: boolean; agent: string | null; scheduleType: ScheduleType }>,
+  fields: Partial<{ schedule: string; prompt: string; enabled: boolean; always: boolean; agent: string | null; stateless: boolean; scheduleType: ScheduleType }>,
 ): Promise<boolean> {
   const sql = getSql();
   const existing = await get(name);
@@ -113,6 +116,7 @@ export async function update(
   const enabled = fields.enabled ?? existing.enabled;
   const always = fields.always ?? existing.always;
   const agent = fields.agent !== undefined ? fields.agent : existing.agent;
+  const stateless = fields.stateless ?? existing.stateless;
 
   if (fields.schedule || fields.scheduleType) {
     validateSchedule(schedule, scheduleType);
@@ -120,7 +124,7 @@ export async function update(
 
   await sql`
     UPDATE jobs
-    SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, updated_at = NOW()
+    SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, stateless = ${stateless}, updated_at = NOW()
     WHERE name = ${name}
   `;
   await notifyChange();
@@ -136,14 +140,14 @@ export async function remove(name: string): Promise<boolean> {
 
 export async function listEnabled(): Promise<Job[]> {
   const sql = getSql();
-  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE enabled = TRUE ORDER BY name`;
+  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE enabled = TRUE ORDER BY name`;
   return rows.map(toJob);
 }
 
 export async function listDue(): Promise<Job[]> {
   const sql = getSql();
   const rows = await sql`
-    SELECT name, schedule, prompt, enabled, always, schedule_type, agent, next_run_at, last_run_at, created_at, updated_at
+    SELECT name, schedule, prompt, enabled, always, schedule_type, agent, stateless, next_run_at, last_run_at, created_at, updated_at
     FROM jobs
     WHERE enabled = TRUE AND next_run_at <= NOW()
     ORDER BY next_run_at

package/src/mcp/server.ts

@@ -25,6 +25,7 @@ export function createNiaMcpServer() {
           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.string().optional().describe("Agent name to use for this job (loads agent's AGENT.md as system prompt)"),
+          stateless: z.boolean().default(false).describe("If true, disables working memory (no state.md injection or workspace)"),
         },
         async (args) => ({
           content: [{ type: "text" as const, text: await handlers.addJob(args) }],
@@ -32,13 +33,14 @@ export function createNiaMcpServer() {
       ),
       tool(
         "update_job",
-        "Update an existing job's schedule, prompt, always flag, agent, or schedule_type. Only pass fields you want to change.",
+        "Update an existing job's schedule, prompt, always flag, agent, stateless, or schedule_type. Only pass fields you want to change.",
         {
           name: z.string().describe("Job name to update"),
           schedule: z.string().optional().describe("New schedule (cron expression, interval duration, or ISO timestamp)"),
           prompt: z.string().optional().describe("New prompt"),
           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)"),
+          stateless: z.boolean().optional().describe("If true, disables working memory (no state.md injection or workspace)"),
           schedule_type: z.enum(["cron", "interval", "once"]).optional().describe("Schedule type (must match the schedule format)"),
         },
         async (args) => ({

package/src/mcp/tools.ts

@@ -23,13 +23,15 @@ export async function addJob(args: {
   schedule_type?: ScheduleType;
   always?: boolean;
   agent?: string;
+  stateless?: boolean;
 }): Promise<string> {
   const scheduleType = args.schedule_type || "cron";
   const always = args.always || false;
+  const stateless = args.stateless || false;
   const config = getConfig();
 
   const nextRunAt = computeInitialNextRun(scheduleType, args.schedule, config.timezone);
-  await Job.create(args.name, args.schedule, args.prompt, always, scheduleType, nextRunAt, args.agent);
+  await Job.create(args.name, args.schedule, args.prompt, always, scheduleType, nextRunAt, args.agent, stateless);
   const agentNote = args.agent ? ` [agent: ${args.agent}]` : "";
   return `Job "${args.name}" created (${scheduleType}: ${args.schedule})${agentNote}. Next run: ${nextRunAt.toISOString()}`;
 }
@@ -40,16 +42,18 @@ export async function updateJob(args: {
   prompt?: string;
   always?: boolean;
   agent?: string | null;
+  stateless?: boolean;
   schedule_type?: "cron" | "interval" | "once";
 }): Promise<string> {
-  const fields: Partial<{ schedule: string; prompt: string; always: boolean; agent: string | null; scheduleType: "cron" | "interval" | "once" }> = {};
+  const fields: Partial<{ schedule: string; prompt: string; always: boolean; stateless: boolean; agent: string | null; scheduleType: "cron" | "interval" | "once" }> = {};
   if (args.schedule) fields.schedule = args.schedule;
   if (args.prompt) fields.prompt = args.prompt;
   if (args.always !== undefined) fields.always = args.always;
+  if (args.stateless !== undefined) fields.stateless = args.stateless;
   if (args.agent !== undefined) fields.agent = args.agent;
   if (args.schedule_type) fields.scheduleType = args.schedule_type;
 
-  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, always, agent, or schedule_type).";
+  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, always, stateless, agent, or schedule_type).";
 
   const updated = await Job.update(args.name, fields);
   if (!updated) return `Job "${args.name}" not found.`;

package/src/prompts/environment.md

@@ -25,7 +25,8 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
   - `interval`: duration string (e.g., "5m", "2h", "1d" = every 5 min/2 hours/1 day)
   - `once`: ISO timestamp for one-time execution (e.g., "2026-03-14T10:00:00")
   - Set `always: true` to run 24/7 (ignores active hours)
-- **update_job** — update an existing job's schedule, prompt, or always flag
+  - Set `stateless: true` to disable working memory (no state.md or workspace)
+- **update_job** — update an existing job's schedule, prompt, always, stateless, or agent
 - **remove_job** — delete a job by name
 - **enable_job** / **disable_job** — toggle a job on or off
 - **run_job** — trigger a job to run immediately
@@ -43,6 +44,14 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
 
 Active hours: {{activeStart}}–{{activeEnd}} ({{timezone}}). Jobs respect this; crons (always=true) don't.
 
+### Job Working Memory
+
+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.
+
+To disable working memory for a specific job, set `stateless: true` when creating or updating it.
+
 ## Managing Config
 
 Config file: `{{configPath}}`

package/src/types/job.ts

@@ -5,6 +5,7 @@ export interface JobInput {
   schedule: string;
   prompt: string;
   agent?: string | null;
+  stateless?: boolean;
 }
 
 export interface JobResult {