Skip to content

· Synx Data Labs

The Daily Standup and the Unattended Cron Loop, In Depth

How Synx Data Labs runs a daily standup with ccxp-skills — what a standup tick actually gathers, the one environment variable that splits interactive from unattended mode, and the cheap-hold short-circuit that keeps an always-on hourly cron loop from burning a full standup when nothing happened.

At Synx Data

Last week’s post covered the Monday ritual that commits a week of work. This post covers the ritual that runs every single day after that: the standup, driven by the /ccxp skill in ccxp-skills (public, so everything below is checkable against ccxp/SKILL.md directly). A standup’s job is to answer one question honestly — what actually happened since yesterday — and to do it the same way whether a human kicked it off or an hourly cron did.

What a standup tick actually gathers

Before a standup writes anything, it reads, in parallel: yesterday’s git log, which PRs merged and which are still open, any dev/JOURNAL/ entries dated yesterday, unresolved escalation threads from .claude/state/drive-threads.json, the previous day’s summary for continuity, and the current week’s committed IPM file (if one exists yet — early in a new week it may not, and the standup says so plainly rather than guessing at a plan that isn’t written down).

One of those checks is not optional on any tick: a pass over Slack for a maintainer reply. A reply can land between any two hourly ticks, and it often answers several open questions in a single message — a standup that skipped this check could sit on a stale assumption for hours. When a reply does land, it preempts the rest of the tick: each directive in it gets treated as resolving whatever blocker it was replying to, and any new scope it raises gets filed as its own follow-up task rather than absorbed informally into whatever’s already in flight.

One environment variable splits interactive from unattended

CCXP_CRON_MODE defaults to 0. The hourly cron wrapper, dev/daily-ccxp.sh, is the one thing that sets it to 1, and that single flag is most of the line between what the system does on its own and what it reserves for a human sitting at the keyboard.

The split isn’t “cron does less” across the board — it’s specifically about judgment versus bookkeeping. Standup itself, the nightly health check, and the Friday retro all run identically whether a human or the cron started the session, because they’re process housekeeping: reading facts and reporting them, not deciding what matters. (That’s a separate axis from the per-tick cheap-hold shortcut below, which can skip a specific tick’s full standup regardless of who or what started the session — more on that shortly.) The Monday IPM isn’t part of this automatic sequence at all: it moved to a separate, opt-in ritual a team invokes directly when it wants an explicit weekly commit — covered in last week’s post — and /ccxp itself no longer triggers it on any day, cron or interactive.

One thing is carved out as interactive-only: focused implementation work. The unattended loop never invokes the build loop itself. It runs that day’s rituals and stops; actual engineering happens when a human runs it directly, with their judgment on priority and design readiness in the loop.

(When a repo does run /ipm ad hoc, that skill reads the same CCXP_CRON_MODE flag itself and skips its own interactive-only pre-IPM design pass under cron the same way /ccxp skips focused implementation — that branching lives entirely inside ipm/SKILL.md, not here.)

Running rituals and housekeeping unattended, every hour, with implementation reserved for a human: that’s the whole shape of the split, and it comes from checking one variable rather than threading two separate code paths through the entire skill.

The cheap-hold short-circuit

An hourly cadence creates an obvious cost problem: most hours, nothing new has happened. If every tick that wakes up ran a full standup regardless, an always-on loop would be paying for a complete regeneration — new analysis, a fresh doc, a Slack post — dozens of times a day for no new information.

The fix isn’t a blunter schedule (running less often would just mean a slower reaction to the hours that do matter). It’s a gate, evaluated using data the tick already gathered in the first few checks above, plus two cheap peeks. A “cheap hold” fires only when all of the following are true on a given tick:

  • No new maintainer reply (the mandatory Slack check above came back empty).
  • Last night’s pipeline runs were all green.
  • Nothing merge-ready is sitting in the open-PR backlog.
  • Nothing on the task backlog is both unblocked and unclaimed — every candidate is genuinely gated (owned by another session, waiting on an external system, or otherwise not a clean autonomous leg), not just inconvenient.
  • It isn’t a Friday tick — the retro always runs in full. (Monday carries no special exemption anymore: now that the IPM is opt-in rather than something /ccxp auto-triggers, a cheap hold can fire on a Monday the same as any other weekday.)

When all five hold, the tick posts one compact, bulleted status line as a threaded reply under the day’s standup message — not a new top-level post — and exits without regenerating the full standup doc or opening a documentation PR for the tick. The day’s dev/JOURNAL/ summary, written by that day’s first full standup, stays the durable record; the Slack thread underneath it is the rollup of every hold tick that followed.

It’s worth being precise about what this optimization is and isn’t. It’s not a decision to skip work that exists — the gate requires every candidate to be genuinely, individually blocked, not just quickly judged “probably nothing to do.” And the mandatory Slack-reply check runs in full on every tick regardless, hold or not — it’s one of the inputs the gate reads, not something the gate is allowed to shortcut. The nightly-health input, by contrast, is deliberately a cheap peek at conclusions only on a hold tick, not the full classify-and-file-a-task pass — that fuller pass only runs on a tick that’s doing a full standup anyway, so its cost is never paid twice. If even one of the five conditions isn’t clear — a reply came in, something broke overnight, a PR is ready to merge, or a task turns out to be workable after all — the tick falls through to a full standup and does the work.

The hourly wrapper

dev/daily-ccxp.sh is what turns “a skill that can run a standup” into “a standup that actually happens.” On a fixed cadence it checks a pre-flight actionability gate: is there a signal worth starting a session for at all — a due or in-flight task, PR activity, a CI failure overnight, or simply the first tick of a new day? Only when that gate finds a signal does it spin up a session, running claude --dangerously-skip-permissions -p /ccxp with CCXP_CRON_MODE=1 set in the environment — the same flag from the section above, now set from outside the skill rather than something /ccxp has to infer about its own invocation.

The crontab entry itself is unremarkable — hourly, pinned to a fixed timezone so the Friday-retro day-of-week check fires in a consistent reference frame regardless of where the machine running it physically sits. What makes the hourly cadence cheap in practice isn’t the schedule, it’s the combination of the pre-flight gate (don’t even start a session with nothing to react to) and the cheap-hold short-circuit above (don’t run a full standup inside a session that did start, if every candidate turns out gated). Neither one alone would be enough — the pre-flight gate can’t see the fine-grained “is this specific task actually workable” distinction, and the cheap hold has no way to avoid spinning up a session at all. Together, they’re what makes “check every hour” a cost-sane default instead of a standing bill.

That’s the daily ritual end to end: gather what actually changed, always check for a reply, run the same rituals a human would, and spend real session time only on hours that have something to say. Next week’s post covers the mechanism that makes it safe for a human and this unattended loop to work the backlog at the same time without ever quietly colliding on the same task.