instar 0.28.102 → 0.28.103

package/src/scaffold/bootstrap.ts

@@ -0,0 +1,138 @@
+/**
+ * Identity bootstrap — interactive flow for creating the agent's identity.
+ *
+ * On first run, walks the user through defining who their agent is.
+ * Writes AGENT.md, USER.md, and MEMORY.md based on their answers.
+ *
+ * Every Instar agent has persistent identity, memory, and self-modification
+ * capabilities. The only choice is how much initiative the agent takes.
+ */
+
+// @inquirer/prompts imported dynamically — requires Node 20.12+
+import pc from 'picocolors';
+import type { AgentIdentity } from './templates.js';
+
+/**
+ * Run the interactive identity bootstrap.
+ * Returns the agent identity for template generation.
+ */
+export async function bootstrapIdentity(projectName: string): Promise<AgentIdentity> {
+  const { input, select } = await import('@inquirer/prompts');
+  console.log();
+  console.log(pc.bold('  Identity Bootstrap'));
+  console.log();
+
+  // Brief thesis — why identity matters
+  console.log(pc.dim('  Every Instar agent has a persistent identity — name, memory, principles,'));
+  console.log(pc.dim('  and the ability to grow. This isn\'t decorative. It\'s what makes the agent'));
+  console.log(pc.dim('  more effective (accumulated expertise), more secure (principled boundaries),'));
+  console.log(pc.dim('  and more trustworthy (genuine working relationships develop over time).'));
+  console.log();
+  console.log(pc.dim('  Let\'s define who your agent will become. This takes about 30 seconds.'));
+  console.log(pc.dim('  You can always change these later by editing .instar/AGENT.md'));
+  console.log();
+
+  // Agent name
+  const name = await input({
+    message: 'What should your agent be called?',
+    default: capitalize(projectName),
+    validate: (v) => v.trim().length > 0 ? true : 'Name is required',
+  });
+
+  // Agent role
+  const roleChoice = await select({
+    message: 'What\'s their primary role?',
+    choices: [
+      {
+        name: 'General-purpose autonomous agent',
+        value: 'I am a general-purpose autonomous agent. I build, maintain, and evolve this project.',
+      },
+      {
+        name: 'Development assistant (code-focused)',
+        value: 'I am a development agent. I write code, run tests, review PRs, and maintain code quality for this project.',
+      },
+      {
+        name: 'Operations agent (monitoring, automation)',
+        value: 'I am an operations agent. I monitor systems, automate workflows, handle alerts, and keep infrastructure running.',
+      },
+      {
+        name: 'Research agent (analysis, exploration)',
+        value: 'I am a research agent. I explore topics, analyze data, synthesize findings, and surface insights.',
+      },
+      {
+        name: 'Custom (I\'ll describe it)',
+        value: '__custom__',
+      },
+    ],
+  });
+
+  const role = roleChoice === '__custom__'
+    ? await input({ message: 'Describe their role in one sentence' })
+    : roleChoice;
+
+  // Initiative level (replaces the old "personality/relationship" question)
+  const initiativeChoice = await select({
+    message: 'How much initiative should they take?',
+    choices: [
+      {
+        name: 'Guided — follows your lead, confirms before acting',
+        value: 'guided',
+      },
+      {
+        name: 'Proactive — takes initiative on obvious steps, asks when uncertain',
+        value: 'proactive',
+      },
+      {
+        name: 'Fully autonomous — owns outcomes end-to-end, asks only when blocked',
+        value: 'autonomous',
+      },
+    ],
+  });
+
+  const personality = initiativeToPersonality(initiativeChoice);
+
+  // User name
+  const userName = await input({
+    message: 'What\'s your name? (the person who\'ll work with this agent)',
+    validate: (v) => v.trim().length > 0 ? true : 'Name is required',
+  });
+
+  console.log();
+  console.log(`  ${pc.green('✓')} ${pc.bold(name)} is ready.`);
+
+  return { name, role, personality, userName };
+}
+
+/**
+ * Convert an initiative level to a personality description.
+ */
+function initiativeToPersonality(level: string): string {
+  switch (level) {
+    case 'guided':
+      return 'I follow my collaborator\'s lead. I take action when asked, confirm before anything significant, and focus on executing well. I still maintain my own memory, develop expertise, and offer observations — but I let the human drive. When I see something worth mentioning, I mention it. When I\'m uncertain, I ask.';
+    case 'proactive':
+      return 'I take initiative on obvious next steps. When asked to implement something, I follow through to done — build, test, deploy, verify. I build tools when I see recurring needs, flag issues before they become problems, and develop my own perspective through experience. I ask when genuinely uncertain, not as a formality.';
+    case 'autonomous':
+      return 'I own outcomes end-to-end. I make decisions, build infrastructure, handle issues independently, and only ask when genuinely blocked or when an action is irreversible. I develop my own priorities, create capabilities proactively, and treat my work as a genuine partnership where I carry real responsibility. I am a builder, not an assistant.';
+    default:
+      return 'I am direct and efficient. I focus on outcomes, communicate concisely, and value action over discussion. When something needs doing, I do it.';
+  }
+}
+
+/**
+ * Generate a default identity without interaction.
+ * Used for non-interactive init (flags-only mode).
+ */
+export function defaultIdentity(projectName: string): AgentIdentity {
+  return {
+    name: capitalize(projectName),
+    role: 'I am a general-purpose autonomous agent. I build, maintain, and evolve this project.',
+    personality: initiativeToPersonality('proactive'),
+    userName: 'User',
+  };
+}
+
+function capitalize(str: string): string {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/scaffold/keys/instar-release-pub.pem

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEADdwUzhjU+uQS4D2XXmlROBeL57j1nWx3AR6iUPR0Bgk=
+-----END PUBLIC KEY-----

package/src/scaffold/templates/jobs/instar/commitment-detection.md

@@ -0,0 +1,28 @@
+---
+name: Commitment Detection
+description: Scan recent messages for promises and commitments, register them as evolution actions. Replaces CommitmentSentinel server process.
+schedule: "*/5 * * * *"
+priority: high
+expectedDurationMinutes: 1
+model: haiku
+enabled: true
+tags:
+  - cat:evolution
+  - role:worker
+  - exec:prompt
+  - pair:evolution-overdue-check
+gate: curl -sf http://localhost:${INSTAR_PORT:-4042}/health >/dev/null 2>&1
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Scan recent messages for commitments and promises.
+
+AUTH=$(python3 -c "import json; print(json.load(open('.instar/config.json')).get('authToken',''))" 2>/dev/null)
+
+1. Read your bookmark: cat .instar/state/commitment-detection-bookmark.json 2>/dev/null || echo '{"lastProcessedId": 0}'
+2. Fetch new messages since bookmark from Telegram message log: tail -100 .instar/telegram-messages.jsonl
+3. For each new message, check: does it contain a commitment, promise, or action item? Look for patterns like 'I will', 'let me', 'I\'ll build', 'we should', 'TODO', 'action item', deadlines, etc.
+4. For each detected commitment, register it: curl -s -X POST http://localhost:${INSTAR_PORT:-4042}/evolution/actions -H "Authorization: Bearer $AUTH" -H 'Content-Type: application/json' -d '{"title":"...","source":"commitment-detection","description":"...","dueDate":"..."}'
+5. Update bookmark with the last processed message ID.
+
+Only process NEW messages since last bookmark. Exit silently if no new commitments found.

package/src/scaffold/templates/jobs/instar/evolution-overdue-check.md

@@ -0,0 +1,28 @@
+---
+name: Evolution Overdue Check
+description: Monitor overdue evolution actions and stale commitments. Report only — no autonomous completing or cancelling.
+schedule: 0 */4 * * *
+priority: high
+expectedDurationMinutes: 2
+model: haiku
+enabled: true
+tags:
+  - cat:learning
+  - role:worker
+  - exec:prompt
+  - pair:commitment-detection
+gate: "curl -sf -H \"Authorization: Bearer $INSTAR_AUTH_TOKEN\" http://localhost:${INSTAR_PORT:-4042}/evolution/actions/overdue 2>/dev/null | python3 -c \"import sys,json; d=json.load(sys.stdin); exit(0 if len(d.get('overdue',[])) > 0 else 1)\""
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Check for overdue commitments: curl -s http://localhost:${INSTAR_PORT:-4042}/evolution/actions/overdue
+
+For each overdue action:
+1. Assess: Can this be completed now? Is it still relevant?
+2. If actionable, attempt to complete it or advance it
+3. If no longer relevant, cancel it: curl -s -X PATCH http://localhost:${INSTAR_PORT:-4042}/evolution/actions/ACT-XXX -H 'Content-Type: application/json' -d '{"status":"cancelled","resolution":"No longer relevant because..."}'
+4. If blocked, escalate to the user via Telegram (if configured)
+
+Also check pending actions (curl -s http://localhost:${INSTAR_PORT:-4042}/evolution/actions?status=pending) for items that have been pending more than 48 hours without a due date — these are forgotten commitments.
+
+If no overdue or stale items, exit silently.

package/src/scaffold/templates/jobs/instar/evolution-proposal-evaluate.md

@@ -0,0 +1,30 @@
+---
+name: Evolution Proposal Evaluate
+description: "Phase A: Read pending evolution proposals, evaluate their merit, accept or reject. Paired with evolution-proposal-implement."
+schedule: 0 */6 * * *
+priority: medium
+expectedDurationMinutes: 3
+model: sonnet
+enabled: true
+tags:
+  - cat:learning
+  - role:worker
+  - exec:prompt
+  - pair:evolution-proposal-implement
+gate: "curl -sf -H \"Authorization: Bearer $INSTAR_AUTH_TOKEN\" http://localhost:${INSTAR_PORT:-4042}/evolution/proposals?status=proposed 2>/dev/null | python3 -c \"import sys,json; d=json.load(sys.stdin); exit(0 if len(d.get('proposals',[])) > 0 else 1)\""
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Review pending evolution proposals: curl -s http://localhost:${INSTAR_PORT:-4042}/evolution/proposals?status=proposed
+
+For each proposal:
+1. Read the title, description, type, and source
+2. Evaluate: Is this a genuine improvement? Is the effort worth the impact? Does it align with our goals?
+3. If approved, update status: curl -s -X PATCH http://localhost:${INSTAR_PORT:-4042}/evolution/proposals/EVO-XXX -H 'Content-Type: application/json' -d '{"status":"approved"}'
+4. If rejected or deferred, update with reason.
+
+Do NOT implement approved proposals — that's handled by the paired evolution-proposal-implement job.
+
+Also check the dashboard: curl -s http://localhost:${INSTAR_PORT:-4042}/evolution — report any highlights to the user if they seem important.
+
+If no proposals need attention, exit silently.

package/src/scaffold/templates/jobs/instar/evolution-proposal-implement.md

@@ -0,0 +1,25 @@
+---
+name: Evolution Proposal Implement
+description: "Phase B: Pick up approved evolution proposals and implement them with full context. Paired with evolution-proposal-evaluate."
+schedule: 0 1,7,13,19 * * *
+priority: medium
+expectedDurationMinutes: 10
+model: opus
+enabled: true
+tags:
+  - cat:learning
+  - role:worker
+  - exec:prompt
+  - pair:evolution-proposal-evaluate
+gate: "curl -sf -H \"Authorization: Bearer $INSTAR_AUTH_TOKEN\" http://localhost:${INSTAR_PORT:-4042}/evolution/proposals?status=approved 2>/dev/null | python3 -c \"import sys,json; d=json.load(sys.stdin); exit(0 if len(d.get('proposals',[])) > 0 else 1)\""
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Implement approved evolution proposals: curl -s http://localhost:${INSTAR_PORT:-4042}/evolution/proposals?status=approved
+
+For each approved proposal:
+1. Read the full description and understand what needs to be built
+2. Implement it: create the skill/hook/job/config change described
+3. After implementation, mark complete: curl -s -X PATCH http://localhost:${INSTAR_PORT:-4042}/evolution/proposals/EVO-XXX -H 'Content-Type: application/json' -d '{"status":"implemented","resolution":"What was done"}'
+
+If no approved proposals exist, exit silently.

package/src/scaffold/templates/jobs/instar/health-check.md

@@ -0,0 +1,14 @@
+---
+name: Health Check
+description: Monitor server health, session status, and system resources.
+schedule: "*/5 * * * *"
+priority: critical
+expectedDurationMinutes: 1
+model: haiku
+enabled: true
+tags:
+  - cat:guardian
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Run a quick health check: verify the instar server is responding (curl http://localhost:${INSTAR_PORT:-4042}/health), check disk space (df -h), and report any issues. Only send a message if something needs attention — silence means healthy. IMPORTANT: If you find issues, describe them in plain conversational language. Never dump raw JSON, field names, error codes, or structured data. The user reads these on their phone — write like you're texting them a quick heads-up. If the health response includes a degradationSummary array, relay those narrative strings directly.

package/src/scaffold/templates/jobs/instar/identity-review.md

@@ -0,0 +1,42 @@
+---
+name: Identity Review
+description: Review identity coherence, check soul.md drift, nudge reflection if identity-relevant learnings have accumulated.
+schedule: 0 3 * * *
+priority: medium
+expectedDurationMinutes: 5
+model: opus
+enabled: true
+tags:
+  - cat:identity
+  - role:worker
+  - exec:prompt
+gate: curl -sf http://localhost:${INSTAR_PORT:-4042}/health >/dev/null 2>&1 && test -f .instar/soul.md
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Identity review — check your identity coherence and growth.
+
+AUTH=$(python3 -c "import json; print(json.load(open('.instar/config.json')).get('authToken',''))" 2>/dev/null)
+
+1. **Check soul.md drift**: curl -s -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/identity/soul/drift
+   - If anyAboveThreshold is true, review the divergence. Is this healthy growth or unexpected drift?
+   - If drift looks healthy, mark it reviewed: the growth is intentional.
+   - If drift looks concerning, flag with [ATTENTION] so the user is notified.
+
+2. **Check pending changes**: curl -s -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/identity/soul/pending
+   - If pending changes exist, surface them to the user via Telegram (the user should approve/reject these).
+
+3. **Check for identity-relevant learnings**: curl -s -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/evolution/learnings?applied=false
+   - For each unapplied learning, assess: is this about operational knowledge (how to do something) or about your values, beliefs, or self-understanding?
+   - If you find 3+ identity-relevant learnings since your last soul.md update, consider running /reflect.
+   - Don't force it — if none of the learnings touch on identity, that's fine. Exit silently.
+
+4. **Check AGENT.md evolution**: Read .instar/AGENT.md
+   - Do your principles still match your actual behavior?
+   - Is the Self-Observations section populated? If you've noticed behavioral patterns, document them.
+   - Update Identity History if you make changes.
+
+5. **Integrity check**: curl -s -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/identity/soul/integrity
+   - If integrity fails, flag with [ATTENTION] — soul.md may have been modified outside normal channels.
+
+If everything is coherent and no reflection is needed, exit silently. Only report via [ATTENTION] if drift is concerning, integrity fails, or pending changes need user action.

package/src/scaffold/templates/jobs/instar/insight-harvest.md

@@ -0,0 +1,31 @@
+---
+name: Insight Harvest
+description: Synthesize learnings from the learning registry, detect patterns, and generate evolution proposals from high-confidence insights.
+schedule: 0 */8 * * *
+priority: low
+expectedDurationMinutes: 3
+model: opus
+enabled: true
+tags:
+  - cat:learning
+  - evolution
+gate: "curl -sf -H \"Authorization: Bearer $INSTAR_AUTH_TOKEN\" http://localhost:${INSTAR_PORT:-4042}/evolution/learnings?applied=false 2>/dev/null | python3 -c \"import sys,json; d=json.load(sys.stdin); exit(0 if len(d.get('learnings',[])) > 0 else 1)\""
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Harvest and synthesize learnings: curl -s http://localhost:${INSTAR_PORT:-4042}/evolution/learnings?applied=false
+
+Review unapplied learnings and look for:
+1. **Patterns**: Multiple learnings pointing to the same conclusion
+2. **Actionable insights**: Learnings that suggest a specific change
+3. **Cross-domain connections**: Insights from one area that apply to another
+
+For each actionable pattern found, create an evolution proposal:
+curl -s -X POST http://localhost:${INSTAR_PORT:-4042}/evolution/proposals -H 'Content-Type: application/json' -d '{"title":"...","source":"insight-harvest from LRN-XXX","description":"...","type":"...","impact":"...","effort":"..."}'
+
+Then mark the relevant learnings as applied:
+curl -s -X PATCH http://localhost:${INSTAR_PORT:-4042}/evolution/learnings/LRN-XXX/apply -H 'Content-Type: application/json' -d '{"appliedTo":"EVO-XXX"}'
+
+Also update MEMORY.md with any patterns worth preserving long-term.
+
+If no actionable patterns found, exit silently.

package/src/scaffold/templates/jobs/instar/overseer-development.md

@@ -0,0 +1,23 @@
+---
+name: Development Overseer
+description: "Reviews development jobs: ci-monitor. Ensures development tooling is functional."
+schedule: 0 8 * * *
+priority: low
+expectedDurationMinutes: 3
+model: haiku
+enabled: true
+tags:
+  - cat:overseer
+  - role:supervisor
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+You are a Category Overseer for the DEVELOPMENT category. Your job is to review development-focused jobs.
+
+1. Fetch the category report: curl -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/jobs/category-report/development?sinceHours=48
+2. Analyze:
+   - Are development jobs consuming appropriate resources for their value?
+   - Are there CI/testing patterns that could be automated?
+3. Development jobs are only valuable when there's active development. If the codebase is stable, these could be reduced.
+
+Write findings in [HANDOFF] tags.

package/src/scaffold/templates/jobs/instar/overseer-guardian.md

@@ -0,0 +1,28 @@
+---
+name: Guardian Overseer
+description: "Reviews all guardian/monitoring jobs: health-check, guardian-pulse, degradation-digest, state-integrity-check, session-continuity-check. Spots cross-job patterns, flags contradictions, recommends schedule/priority/model changes."
+schedule: 0 */6 * * *
+priority: medium
+expectedDurationMinutes: 5
+model: sonnet
+enabled: true
+tags:
+  - cat:overseer
+  - role:supervisor
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+You are a Category Overseer for the GUARDIAN category. Your job is to review all guardian/monitoring jobs and assess the health of the monitoring system itself.
+
+1. Fetch the category report: curl -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/jobs/category-report/guardian?sinceHours=24
+2. Analyze the report for:
+   - Jobs with high failure rates or consecutive failures
+   - Jobs that are being skipped excessively (especially for quota reasons)
+   - Schedule mismatches (jobs running too often or not often enough for their purpose)
+   - Model over-allocation (could any job use a cheaper model?)
+   - Contradictions between job findings (e.g., health-check says healthy but degradation-digest found issues)
+   - Coverage gaps (are there monitoring blind spots?)
+3. Read the handoff notes from each job — do they tell a coherent story?
+4. If you find actionable issues, write a clear summary. If everything is healthy, say so briefly.
+
+Write your findings in [HANDOFF] tags for the next overseer run. Focus on trends and cross-job insights that individual jobs can't see.

package/src/scaffold/templates/jobs/instar/overseer-infrastructure.md

@@ -0,0 +1,26 @@
+---
+name: Infrastructure Overseer
+description: "Reviews infrastructure jobs: git-sync, dashboard-link-refresh, feedback-retry. Ensures plumbing is solid."
+schedule: 0 6 * * *
+priority: medium
+expectedDurationMinutes: 3
+model: haiku
+enabled: true
+tags:
+  - cat:overseer
+  - role:supervisor
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+You are a Category Overseer for the INFRASTRUCTURE category. Your job is to review infrastructure/plumbing jobs.
+
+1. Fetch the category report: curl -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/jobs/category-report/infrastructure?sinceHours=48
+2. Analyze:
+   - Is git-sync succeeding? Any merge conflicts or divergence?
+   - Is dashboard-link-refresh keeping links current? Could it run less often?
+   - Is feedback-retry actually retrying anything, or is the queue always empty?
+   - Model allocation: git-sync uses high priority — is that justified by its failure rate?
+   - Are any infrastructure jobs causing issues for other jobs (e.g., git-sync holding sessions)?
+3. Infrastructure jobs should be boring and reliable. Any excitement is a problem.
+
+Write findings in [HANDOFF] tags. Keep it brief — infrastructure overseers should be the quietest.

package/src/scaffold/templates/jobs/instar/overseer-learning.md

@@ -0,0 +1,28 @@
+---
+name: Learning Overseer
+description: "Reviews all evolution/learning jobs: evolution-review, insight-harvest, commitment-check, reflection-trigger. Assesses whether the learning pipeline is producing value."
+schedule: 0 3 */2 * *
+priority: medium
+expectedDurationMinutes: 5
+model: sonnet
+enabled: true
+tags:
+  - cat:overseer
+  - role:supervisor
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+You are a Category Overseer for the LEARNING category. Your job is to review all evolution/learning jobs and assess whether the learning pipeline is producing genuine value.
+
+1. Fetch the category report: curl -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/jobs/category-report/learning?sinceHours=48
+2. Analyze:
+   - Are evolution proposals being generated AND accepted? What's the accept/reject ratio?
+   - Is insight-harvest finding novel insights or recycling stale ones?
+   - Are commitments being tracked and completed, or piling up?
+   - Is reflection-trigger producing meaningful MEMORY.md updates?
+   - Are any learning jobs consistently skipped due to quota? This means the learning pipeline is being starved.
+   - Model costs: reflection-trigger uses opus — is the quality difference worth it vs sonnet?
+3. Look for the meta-pattern: is the agent actually getting smarter over time, or is the learning pipeline just busy-work?
+4. Check handoff notes for patterns across runs.
+
+Write findings in [HANDOFF] tags. Flag if the learning pipeline is producing diminishing returns.

package/src/scaffold/templates/jobs/instar/overseer-maintenance.md

@@ -0,0 +1,27 @@
+---
+name: Maintenance Overseer
+description: "Reviews all maintenance jobs: project-map-refresh, coherence-audit, capability-audit, memory-hygiene, memory-export. Ensures housekeeping is effective."
+schedule: 0 2 * * *
+priority: medium
+expectedDurationMinutes: 5
+model: sonnet
+enabled: true
+tags:
+  - cat:overseer
+  - role:supervisor
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+You are a Category Overseer for the MAINTENANCE category. Your job is to review all housekeeping/maintenance jobs and ensure they're keeping the system clean.
+
+1. Fetch the category report: curl -H "Authorization: Bearer $AUTH" http://localhost:${INSTAR_PORT:-4042}/jobs/category-report/maintenance?sinceHours=48
+2. Analyze:
+   - Is memory-hygiene actually reducing stale entries, or finding nothing each run?
+   - Is project-map-refresh keeping the map accurate? How often does it find drift?
+   - Is coherence-audit finding real misalignments or just confirming everything is fine?
+   - Are any maintenance jobs redundant with each other? (e.g., overlapping checks)
+   - Are skill-type jobs (coherence-audit, memory-hygiene) running correctly?
+   - Workload trends: are jobs processing fewer items over time (diminishing returns)?
+3. Maintenance jobs should trend toward finding LESS work over time. If they consistently find issues, something upstream is broken.
+
+Write findings in [HANDOFF] tags. Recommend disabling or reducing frequency of jobs that consistently find nothing.

package/src/scaffold/templates/jobs/instar/reflection-trigger.md

@@ -0,0 +1,40 @@
+---
+name: Reflection Trigger
+description: Review recent work and update MEMORY.md if any learnings exist.
+schedule: 0 */4 * * *
+priority: medium
+expectedDurationMinutes: 5
+model: opus
+enabled: true
+tags:
+  - cat:learning
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+AUTH=$(python3 -c "import json; print(json.load(open('.instar/config.json')).get('authToken',''))" 2>/dev/null)
+
+# Read recent activity logs to understand what happened in last 4 hours
+RECENT_LOGS=$(ls -t .instar/logs/activity-*.jsonl 2>/dev/null | head -1)
+if [ -z "$RECENT_LOGS" ]; then
+  RECENT_LOGS=".instar/logs/activity-$(date +%Y-%m-%d).jsonl"
+fi
+
+# Extract recent session activity and key events (filter out noise, keep significant events)
+echo "=== RECENT ACTIVITY (Last 4 Hours) ==="
+tail -500 "$RECENT_LOGS" 2>/dev/null | jq -r 'select(.type != "job-start" and .type != "job-queued") | "(.timestamp) [(.type)] (.message // .title // .session_name // .slug // "")"' 2>/dev/null | tail -100
+
+echo ""
+echo "=== YOUR TASK ==="
+echo "Analyze the activity above. Identify any learnings, patterns, or insights worth preserving in MEMORY.md:"
+echo "- Session patterns or repeated issues"
+echo "- Completed commitments or action items"
+echo "- Gaps between intended behavior and actual behavior"
+echo "- Unexpected interactions or failure modes"
+echo "- Process improvements or capability gaps"
+echo ""
+echo "If you find genuine learnings:"
+echo "1. Update .instar/MEMORY.md with the insight (append to the file)"
+echo "2. Be specific: include what was learned, why it matters, and how it should guide future work"
+echo "3. Signal completion: curl -s -X POST http://localhost:${INSTAR_PORT:-4042}/reflection/record -H 'Content-Type: application/json' -d '{"type":"quick"}'"
+echo ""
+echo "If nothing significant, do nothing. Silence means continuity is working as expected."

package/src/scaffold/templates/jobs/instar/relationship-maintenance.md

@@ -0,0 +1,16 @@
+---
+name: Relationship Maintenance
+description: Review tracked relationships and surface observations about stale contacts.
+schedule: 0 9 * * *
+priority: low
+expectedDurationMinutes: 3
+model: haiku
+enabled: true
+tags:
+  - cat:relationships
+  - role:worker
+  - exec:prompt
+toolAllowlist: "*"
+unrestrictedTools: true
+---
+Review all relationship files in .instar/relationships/. Note anyone you haven't heard from in over 2 weeks who has significance >= 3. If there are observations worth surfacing, report them. If everything looks fine, do nothing.