niahere 0.2.52 → 0.2.57

package/skills/social-content/references/post-templates.md

@@ -0,0 +1,177 @@
+# Post Format Templates
+
+Ready-to-use templates for different platforms and content types.
+
+## Contents
+- LinkedIn Post Templates (The Story Post, The Contrarian Take, The List Post, The How-To)
+- Twitter/X Thread Templates (The Tutorial Thread, The Story Thread, The Breakdown Thread)
+- Instagram Templates (The Carousel Hook, The Reel Script)
+- Hook Formulas (Curiosity Hooks, Story Hooks, Value Hooks, Contrarian Hooks, Social Proof Hooks)
+
+## LinkedIn Post Templates
+
+### The Story Post
+```
+[Hook: Unexpected outcome or lesson]
+
+[Set the scene: When/where this happened]
+
+[The challenge you faced]
+
+[What you tried / what happened]
+
+[The turning point]
+
+[The result]
+
+[The lesson for readers]
+
+[Question to prompt engagement]
+```
+
+### The Contrarian Take
+```
+[Unpopular opinion stated boldly]
+
+Here's why:
+
+[Reason 1]
+[Reason 2]
+[Reason 3]
+
+[What you recommend instead]
+
+[Invite discussion: "Am I wrong?"]
+```
+
+### The List Post
+```
+[X things I learned about [topic] after [credibility builder]:
+
+1. [Point] — [Brief explanation]
+
+2. [Point] — [Brief explanation]
+
+3. [Point] — [Brief explanation]
+
+[Wrap-up insight]
+
+Which resonates most with you?
+```
+
+### The How-To
+```
+How to [achieve outcome] in [timeframe]:
+
+Step 1: [Action]
+↳ [Why this matters]
+
+Step 2: [Action]
+↳ [Key detail]
+
+Step 3: [Action]
+↳ [Common mistake to avoid]
+
+[Result you can expect]
+
+[CTA or question]
+```
+
+---
+
+## Twitter/X Thread Templates
+
+### The Tutorial Thread
+```
+Tweet 1: [Hook + promise of value]
+
+"Here's exactly how to [outcome] (step-by-step):"
+
+Tweet 2-7: [One step per tweet with details]
+
+Final tweet: [Summary + CTA]
+
+"If this was helpful, follow me for more on [topic]"
+```
+
+### The Story Thread
+```
+Tweet 1: [Intriguing hook]
+
+"[Time] ago, [unexpected thing happened]. Here's the full story:"
+
+Tweet 2-6: [Story beats, building tension]
+
+Tweet 7: [Resolution and lesson]
+
+Final tweet: [Takeaway + engagement ask]
+```
+
+### The Breakdown Thread
+```
+Tweet 1: [Company/person] just [did thing].
+
+Here's why it's genius (and what you can learn):
+
+Tweet 2-6: [Analysis points]
+
+Tweet 7: [Your key takeaway]
+
+"[Related insight + follow CTA]"
+```
+
+---
+
+## Instagram Templates
+
+### The Carousel Hook
+```
+[Slide 1: Bold statement or question]
+[Slides 2-9: One point per slide, visual + text]
+[Slide 10: Summary + CTA]
+
+Caption: [Expand on the topic, add context, include CTA]
+```
+
+### The Reel Script
+```
+Hook (0-2 sec): [Pattern interrupt or bold claim]
+Setup (2-5 sec): [Context for the tip]
+Value (5-25 sec): [The actual advice/content]
+CTA (25-30 sec): [Follow, comment, share, link]
+```
+
+---
+
+## Hook Formulas
+
+The first line determines whether anyone reads the rest.
+
+### Curiosity Hooks
+- "I was wrong about [common belief]."
+- "The real reason [outcome] happens isn't what you think."
+- "[Impressive result] — and it only took [surprisingly short time]."
+- "Nobody talks about [insider knowledge]."
+
+### Story Hooks
+- "Last week, [unexpected thing] happened."
+- "I almost [big mistake/failure]."
+- "3 years ago, I [past state]. Today, [current state]."
+- "[Person] told me something I'll never forget."
+
+### Value Hooks
+- "How to [desirable outcome] (without [common pain]):"
+- "[Number] [things] that [outcome]:"
+- "The simplest way to [outcome]:"
+- "Stop [common mistake]. Do this instead:"
+
+### Contrarian Hooks
+- "Unpopular opinion: [bold statement]"
+- "[Common advice] is wrong. Here's why:"
+- "I stopped [common practice] and [positive result]."
+- "Everyone says [X]. The truth is [Y]."
+
+### Social Proof Hooks
+- "We [achieved result] in [timeframe]. Here's the full story:"
+- "[Number] people asked me about [topic]. Here's my answer:"
+- "[Authority figure] taught me [lesson]."

package/skills/social-content/references/reverse-engineering.md

@@ -0,0 +1,195 @@
+# Reverse Engineering Viral Content
+
+Instead of guessing what works, systematically analyze top-performing content in your niche and extract proven patterns.
+
+## Contents
+- The 6-Step Framework (Niche ID, Scrape, Analyze, Playbook, Layer Voice, Convert)
+- The Formula
+- Reverse Engineering Checklist
+
+## The 6-Step Framework
+
+### 1. NICHE ID — Find Top Creators
+
+Identify 10-20 creators in your space who consistently get high engagement:
+
+**Selection criteria:**
+- Posting consistently (3+ times/week)
+- High engagement rate relative to follower count
+- Audience overlap with your target market
+- Mix of established and rising creators
+
+**Where to find them:**
+- LinkedIn: Search by industry keywords, check "People also viewed"
+- Twitter/X: Check who your target audience follows and engages with
+- Use tools like SparkToro, Followerwonk, or manual research
+- Look at who gets featured in industry newsletters
+
+### 2. SCRAPE — Collect Posts at Scale
+
+Gather 500-1000+ posts from your identified creators for analysis:
+
+**Tools:**
+- **Apify** — LinkedIn scraper, Twitter scraper actors
+- **Phantom Buster** — Multi-platform automation
+- **Export tools** — Platform-specific export features
+- **Manual collection** — For smaller datasets, copy/paste into spreadsheet
+
+**Data to collect:**
+- Post text/content
+- Engagement metrics (likes, comments, shares, saves)
+- Post format (text-only, carousel, video, image)
+- Posting time/day
+- Hook/first line
+- CTA used
+- Topic/theme
+
+### 3. ANALYZE — Extract What Actually Works
+
+Sort and analyze the data to find patterns:
+
+**Quantitative analysis:**
+- Rank posts by engagement rate
+- Identify top 10% performers
+- Look for format patterns (do carousels outperform?)
+- Check timing patterns (best days/times)
+- Compare topic performance
+
+**Qualitative analysis:**
+- What hooks do top posts use?
+- How long are high-performing posts?
+- What emotional triggers appear?
+- What formats repeat?
+- What topics consistently perform?
+
+**Questions to answer:**
+- What's the average length of top posts?
+- Which hook types appear most in top 10%?
+- What CTAs drive most comments?
+- What topics get saved/shared most?
+
+### 4. PLAYBOOK — Codify Patterns
+
+Document repeatable patterns you can use:
+
+**Hook patterns to codify:**
+```
+Pattern: "I [unexpected action] and [surprising result]"
+Example: "I stopped posting daily and my engagement doubled"
+Why it works: Curiosity gap + contrarian
+
+Pattern: "[Specific number] [things] that [outcome]:"
+Example: "7 pricing mistakes that cost me $50K:"
+Why it works: Specificity + loss aversion
+
+Pattern: "[Controversial take]"
+Example: "Cold outreach is dead."
+Why it works: Pattern interrupt + invites debate
+```
+
+**Format patterns:**
+- Carousel: Hook slide → Problem → Solution steps → CTA
+- Thread: Hook → Promise → Deliver → Recap → CTA
+- Story post: Hook → Setup → Conflict → Resolution → Lesson
+
+**CTA patterns:**
+- Question: "What would you add?"
+- Agreement: "Agree or disagree?"
+- Share: "Tag someone who needs this"
+- Save: "Save this for later"
+
+### 5. LAYER VOICE — Apply Direct Response Principles
+
+Take proven patterns and make them yours with these voice principles:
+
+**"Smart friend who figured something out"**
+- Write like you're texting advice to a friend
+- Share discoveries, not lectures
+- Use "I found that..." not "You should..."
+- Be helpful, not preachy
+
+**Specific > Vague**
+```
+❌ "I made good revenue"
+✅ "I made $47,329"
+
+❌ "It took a while"
+✅ "It took 47 days"
+
+❌ "A lot of people"
+✅ "2,847 people"
+```
+
+**Short. Breathe. Land.**
+- One idea per sentence
+- Use line breaks liberally
+- Let important points stand alone
+- Create rhythm: short, short, longer explanation
+
+```
+❌ "I spent three years building my business the wrong way before I finally realized that the key to success was focusing on fewer things and doing them exceptionally well."
+
+✅ "I built wrong for 3 years.
+
+Then I figured it out.
+
+Focus on less.
+Do it exceptionally well.
+
+Everything changed."
+```
+
+**Write from emotion**
+- Start with how you felt, not what you did
+- Use emotional words: frustrated, excited, terrified, obsessed
+- Show vulnerability when authentic
+- Connect the feeling to the lesson
+
+```
+❌ "Here's what I learned about pricing"
+
+✅ "I was terrified to raise my prices.
+
+My hands were shaking when I sent the email.
+
+Here's what happened..."
+```
+
+### 6. CONVERT — Turn Attention into Action
+
+Bridge from engagement to business results:
+
+**Soft conversions:**
+- Newsletter signups in bio/comments
+- Free resource offers in follow-up comments
+- DM triggers ("Comment X and I'll send you...")
+- Profile visits → optimized profile with clear CTA
+
+**Direct conversions:**
+- Link in comments (not post body on LinkedIn)
+- Contextual product mentions within valuable content
+- Case study posts that naturally showcase your work
+- "If you want help with this, DM me" (sparingly)
+
+---
+
+## The Formula
+
+```
+1. Find what's already working (don't guess)
+2. Extract the patterns (hooks, formats, CTAs)
+3. Layer your authentic voice on top
+4. Test and iterate based on your own data
+```
+
+## Reverse Engineering Checklist
+
+- [ ] Identified 10-20 top creators in niche
+- [ ] Collected 500+ posts for analysis
+- [ ] Ranked by engagement rate
+- [ ] Documented top 10 hook patterns
+- [ ] Documented top 5 format patterns
+- [ ] Documented top 5 CTA patterns
+- [ ] Created voice guidelines (specificity, brevity, emotion)
+- [ ] Built template library from patterns
+- [ ] Set up tracking for your own content performance

package/src/channels/slack.ts

@@ -304,7 +304,7 @@ class SlackChannel implements Channel {
 
     // Handle messages (DMs + @mentions)
     app.message(async ({ message, say, client }) => {
-      if (message.subtype) return;
+      if (message.subtype && message.subtype !== "file_share") return;
       const msg = message as {
         text?: string;
         channel: string;

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.`;