Skip to content

sno-ai/sno-station-skills / skills/R-recursive-self-improvement/rem-reflect/skill

rem-reflect

Verified

Self Learning from this machine's Claude Code, Codex, Hermes, OpenClaw and Cursor sessions. Decide skill changes and lessons with accept/reject/tbd; recall lessons at session start.

FileKindSize
SKILL.mdskill md14.1 KB
references/labeler.mdmarkdown1.2 KB
references/labeler.schema.jsonconfig1.7 KB
references/local-settings.jsonconfig126 B
references/local-writer.schema.jsonconfig2.3 KB
references/proposal.schema.jsonconfig3.2 KB
references/render.jsonconfig245 B
references/signals.jsonconfig71 B
references/text.jsonconfig4.0 KB
scripts/adopt.test.tsscript13.0 KB
scripts/adopt.tsscript14.3 KB
scripts/agent-sessions.tsscript9.1 KB
scripts/allowance-fallback.test.tsscript16.0 KB
scripts/allowance-request-isolation.test.tsscript7.1 KB
scripts/backend.tsscript9.1 KB
scripts/calls.tsscript8.6 KB
scripts/catalogue-cloud.test.tsscript1.5 KB
scripts/catalogue.tsscript3.2 KB
scripts/chunk.tsscript2.1 KB
scripts/cloud-apply.test.tsscript25.2 KB
scripts/cloud-batch.test.tsscript11.2 KB
scripts/cloud-day.test.tsscript6.8 KB
scripts/cloud-verdict.test.tsscript12.1 KB
scripts/cloud-wait.test.tsscript1.3 KB
scripts/cloud.tsscript24.4 KB
scripts/config.tsscript8.1 KB
scripts/cursor.test.tsscript16.1 KB
scripts/cursor.tsscript6.7 KB
scripts/evidence.tsscript1.5 KB
scripts/first-message.test.tsscript10.3 KB
scripts/harvest.test.tsscript16.5 KB
scripts/harvest.tsscript22.6 KB
scripts/hermes-openclaw.test.tsscript25.6 KB
scripts/identity.test.tsscript3.3 KB
scripts/identity.tsscript3.5 KB
scripts/installed-roots.test.tsscript11.0 KB
scripts/journey-adopt-lesson.test.tsscript4.1 KB
scripts/journey-ops.test.tsscript8.0 KB
scripts/labeler.test.tsscript3.6 KB
scripts/labeler.tsscript9.5 KB
scripts/ledger.tsscript2.1 KB
scripts/lessons.tsscript4.7 KB
scripts/local-filter.test.tsscript3.9 KB
scripts/local-first-output.test.tsscript23.5 KB
scripts/local-settings.tsscript1.4 KB
scripts/local-writer.tsscript12.7 KB
scripts/login-in-place.test.tsscript5.8 KB
scripts/model-json.tsscript4.1 KB
scripts/no-network.test.tsscript5.0 KB
scripts/observe.tsscript1.4 KB
scripts/page-journey.test.tsscript6.7 KB
scripts/pages.test.tsscript4.1 KB
scripts/pages.tsscript4.8 KB
scripts/proposer-loop.test.tsscript1.5 KB
scripts/proposer-validate.test.tsscript9.1 KB
scripts/proposer.tsscript8.7 KB
scripts/recall-hook.test.tsscript20.9 KB
scripts/recall.test.tsscript31.4 KB
scripts/recall.tsscript18.2 KB
scripts/reflect.test.tsscript9.3 KB
scripts/reflect.tsscript14.3 KB
scripts/rem-reflectexecutablescript823 B
scripts/rem-reflect.tsscript17.8 KB
scripts/render-chunk.test.tsscript7.2 KB
scripts/render.tsscript9.7 KB
scripts/report.tsscript8.2 KB
scripts/run-status.test.tsscript19.1 KB
scripts/sampling.test.tsscript2.1 KB
scripts/sampling.tsscript915 B
scripts/selftest-guard.test.tsscript4.2 KB
scripts/selftest/bin/claudeexecutablescript94 B
scripts/selftest/bin/codexexecutablescript93 B
scripts/selftest/bin/shim-core.cjsscript4.6 KB
scripts/selftest/bin/snoexecutablescript5.7 KB
scripts/selftest/fixtures/hermes-session-export.jsonlother1.5 KB
scripts/selftest/fixtures/openclaw-events.jsonlother3.7 KB
scripts/selftest/fixtures/verdict-traces.jsonconfig16.6 KB
scripts/selftest/journey-e2e.shexecutablescript1.4 KB
scripts/selftest/journey.mjsscript9.5 KB
scripts/selftest/observe-journey.mjsscript12.5 KB
scripts/selftest/run-selftest.shexecutablescript7.0 KB
scripts/selftest/spawn-python.mjsexecutablescript765 B
scripts/session.test.tsscript5.2 KB
scripts/session.tsscript251 B
scripts/signal-local.test.tsscript7.0 KB
scripts/skill-impact.test.tsscript6.2 KB
scripts/station-settings.test.tsscript13.6 KB
scripts/store-memory.test.tsscript3.4 KB
scripts/store.tsscript7.7 KB
scripts/test-helpers.tsscript15.3 KB
scripts/text.tsscript760 B
scripts/trigger.test.tsscript3.6 KB
scripts/trigger.tsscript2.5 KB
scripts/verdicts.test.tsscript8.1 KB
scripts/verdicts.tsscript8.0 KB

scripts/journey-ops.test.ts

View on GitHub
// Test-owned: the daily cadence is a same-day no-op that writes
// nothing, a next-day run proceeds, and the unit is armed by `sno heartbeat` — no crontab, no busy loop.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { execFileSync, spawn } from 'node:child_process';
import { existsSync, readFileSync, readdirSync } from 'node:fs';
import { homedir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { join } from 'node:path';
import { run } from './rem-reflect.ts';
import { calendar } from './config.ts';
import { commitStore, readState, writeState } from './store.ts';
import {
  hashListing, tmp, fixtureConfig, makeStore, FixtureBackend,
  writeClaudeSession, claudeUser, claudeAssistant, writeCodexSession, codexMeta, codexUser, codexAssistant,
} from './test-helpers.ts';
import type { Config } from './config.ts';

const NOW = new Date('2026-09-08T12:00:00Z');
const MT = new Date('2026-09-07T00:00:00Z').getTime();
const UNIT_DIR = fileURLToPath(new URL('..', import.meta.url)); // skills/rem-reflect/skill/
const ARM_LINE = 'sno heartbeat --interval 24h --max-hours 0 --label rem-reflect -- sno rem-reflect run';
function cfg(): Config { return fixtureConfig({ claude_root: tmp('c'), codex_root: tmp('x') }); }
function bothHalves(config: Config): void {
  writeClaudeSession(config.claude_root, 'proj', 'cc', [claudeUser('/n', 'cc', 'do it'), claudeAssistant('/n', 'cc', [{ type: 'text', text: 'ok' }])], MT);
  writeCodexSession(config.codex_root, 'cx', [codexMeta('cx', '/n'), codexUser('do it'), codexAssistant('ok')], MT);
}

// A run on a day that already reached a successful reflection is a recorded no-op that writes nothing.
test('a same-day run after today already succeeded is a no-op that writes nothing', () => {
  const config = cfg();
  const store = makeStore(config);
  const today = calendar(NOW, config.time_zone);
  const state = readState(store);
  state.last_start = today;
  state.last_terminal = { ...today, status: 'success' }; // today already succeeded
  writeState(store, state);
  commitStore(store, 'test: today already succeeded'); // the same-day guard reads the committed state
  const before = hashListing(store);
  const r = run(store, NOW, 'u', new FixtureBackend());
  assert.equal(r.code, 0, r.lines.join('\n'));
  assert.ok(r.lines.some(line => /no-op: .*already succeeded/.test(line)), 'the run names the no-op');
  assert.equal(hashListing(store), before, 'the no-op leaves the store byte-identical');
});

// retry-until-success: a day whose only run FAILED is not done, so a same-day run proceeds.
test('a same-day run after today only failed proceeds instead of no-opping', () => {
  const config = cfg();
  const store = makeStore(config);
  bothHalves(config);
  const today = calendar(NOW, config.time_zone);
  const state = readState(store);
  state.last_start = today;
  state.last_terminal = { ...today, status: 'failed' }; // today's only run failed
  writeState(store, state);
  const r = run(store, NOW, 'u', new FixtureBackend());
  assert.equal(r.code, 0, r.lines.join('\n'));
  assert.ok(!r.lines.some(line => /no-op/.test(line)), 'a failed day retries rather than no-opping');
  assert.equal(readState(store).last_terminal?.status, 'success', 'the retry reaches success');
});

// With the last start set to yesterday, the same store runs the full pass instead of the no-op.
test('a next-day run proceeds past the no-op guard', () => {
  const config = cfg();
  const store = makeStore(config);
  bothHalves(config);
  const yesterday = calendar(new Date('2026-09-07T12:00:00Z'), config.time_zone);
  const state = readState(store);
  state.last_start = yesterday;
  writeState(store, state);
  const r = run(store, NOW, 'u', new FixtureBackend());
  assert.equal(r.code, 0, r.lines.join('\n'));
  assert.ok(!r.lines.some(line => /no-op/.test(line)), 'the next-day run does not report a no-op');
  const staged = readdirSync(join(store, 'staging')).filter(n => /^\d/.test(n));
  assert.ok(staged.includes(calendar(NOW, config.time_zone).id), 'the run staged its own run id');
});

// the unit's SKILL.md names the exact sno heartbeat arm line the owner runs.
test('the unit SKILL.md names the exact heartbeat arm line', () => {
  const skillMd = readFileSync(join(UNIT_DIR, 'SKILL.md'), 'utf8');
  assert.ok(skillMd.includes(ARM_LINE), 'SKILL.md carries the exact heartbeat arm line');
});

// the shipped program schedules through heartbeat, not a crontab entry or a busy-wait loop.
test('the shipped unit source has no crontab and no busy-wait loop', () => {
  // grep the shipped source only: SKILL.md, references, and non-test scripts (test files legitimately
  // name these strings as search terms; the deployed program must not).
  const hits = (pattern: string): string => {
    try {
      return execFileSync('grep', ['-rIl', '--exclude=*.test.ts', '--exclude-dir=selftest', pattern, UNIT_DIR], { encoding: 'utf8' });
    } catch (e) {
      // grep exits 1 when nothing matches; any other status is a broken instrument
      if (e && typeof e === 'object' && (e as { status?: number }).status === 1) return '';
      throw new Error(`grep unusable: ${String(e)}`);
    }
  };
  assert.equal(hits('crontab'), '', 'no crontab in the shipped source');
  assert.equal(hits('while true'), '', 'no `while true` busy loop in the shipped source');
  // positive control: grep can find a string that is present, so an empty result above is real
  assert.ok(hits('rem-reflect').length > 0, 'grep can find a present string (instrument works)');
});

// the exact arm line's flags are accepted by the installed `sno heartbeat`. `sno heartbeat` is a
// foreground daemon, so it is spawned detached (never awaited); a unique label avoids colliding with a
// real rem-reflect heartbeat; heartbeat fires the hook at once, so the run gets a fixture store.
// The arm is stopped in a finally and the process group killed as a backstop.
test('the installed heartbeat accepts the exact arm line flags and stops again', async t => {
  // The test-helpers stand-in `sno` always spawns, so the ENOENT guard below cannot see a machine with no
  // installed sno; the stand-in forwards `heartbeat` to this binary, so its absence is checked here.
  const installed = process.env.REM_TEST_SNO_CLI || join(homedir(), '.local', 'bin', 'sno');
  if (!process.env.REM_SELFTEST && !existsSync(installed)) {
    t.skip(`no installed sno at ${installed}; arm check skipped`);
    return;
  }
  // a short, unique label (never the real `rem-reflect`): `sno heartbeat --list` truncates the label
  // column to ~20 chars, so a long label would never match its own listing.
  const label = `q19-${process.pid}`;
  const list = (): string => { try { return execFileSync('sno', ['heartbeat', '--list'], { encoding: 'utf8' }); } catch { return ''; } };
  const child = spawn('sno', ['heartbeat', '--interval', '24h', '--max-hours', '0', '--label', label, '--', 'sno', 'rem-reflect', 'run'],
    { detached: true, stdio: 'ignore', env: { ...process.env, REM_REFLECT_STORE: makeStore(fixtureConfig()) } });
  const spawnErr = await new Promise<NodeJS.ErrnoException | null>(resolve => {
    child.once('error', err => resolve(err as NodeJS.ErrnoException));
    setTimeout(() => resolve(null), 300);
  });
  if (spawnErr?.code === 'ENOENT') { assert.ok(true, 'heartbeat not installed on PATH; arm check skipped'); return; }
  assert.equal(spawnErr, null, `heartbeat failed to start: ${spawnErr?.message ?? ''}`);
  try {
    let seen = false;
    for (let i = 0; i < 30 && !seen; i++) { if (new RegExp(label).test(list())) seen = true; else execFileSync('sleep', ['0.1']); }
    assert.ok(seen, 'the armed heartbeat is listed');
  } finally {
    try { execFileSync('sno', ['heartbeat', '--stop', label], { timeout: 10_000 }); } catch { /* already gone */ }
    try { if (child.pid) process.kill(-child.pid, 'SIGKILL'); } catch { /* already gone */ }
  }
  for (let i = 0; i < 20 && new RegExp(label).test(list()); i++) execFileSync('sleep', ['0.1']);
  assert.doesNotMatch(list(), new RegExp(label), 'the heartbeat is stopped and no longer listed');
});
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall