cj-now

now projects four task surfaces into one list. It is a projection of the sources. Nothing is written and nothing is synced, so nothing can drift.

now                     open work, grouped by profile, 10 rows each
now -v                  same, with ids and age (--verbose)
now --profile work      one profile, uncapped
now --source plans      one source (plans | things | ado), repeatable
now --grep 18520        search title and id, every profile, unfiltered
now --full              no row cap, and no Things relevance filter
now --dupes             only Things rows that name an ADO work item (personal sub-steps)
now --upcoming          only Things tasks scheduled to start later
now --all               include profiles the config does not mark as work
now --agent             JSON, owa-suite envelope, every profile (implies --all)
now --no-cache          force a fresh ADO fetch

Sibling: idea

idea does for ~/code/dev-ideas what now does for work: no args lists every idea (title, status, tagline from ideas/*/README.md, retired hidden, -a to show) plus the repo's open todos; idea <text> captures a new one with todo add in that repo. DEV_IDEAS overrides the path.

Sources

Each source stays authoritative for its own domain. now never reconciles them and never picks a winner.

The ADO adapter runs owa-ado wi --mine once for every owa-piggy profile with the ado service (owa-piggy profiles --json), passing --org from that profile's devops client capture url (https://dev.azure.com/<org>/...). Each work item is tagged with the profile it came from. --mine follows assignment across every project in the organisation.

now once carried its own cross-project WIQL, because --mine was pinned to the single project in ~/.config/owa-ado/config. That scoping was fixed one layer down in owa-ado, so now knows nothing about how ADO scopes a query.

Closed, Removed and Done are dropped here rather than in the query. Resolved is kept: it means fixed but still waiting on the board to be verified, which is the item that needs a last push.

The join key is the profile

A repo, an ADO project and a Things area all map to one owa-piggy profile. That is the only axis all three share, and it is what makes a merged list coherent.

The mappings are personal wiring, not tool logic, so they live in ~/.config/cj-now/config.json:

{
  "work_profiles":    ["acme", "acme-misc"],
  "fallback_profile": "personal",
  "repo_profiles":    [["code/acme/api/", "acme"], ["code/acme/", "acme-misc"]],
  "area_profiles":    {"ACME": "acme"}
}

repo_profiles is a list of pairs rather than an object because first match wins, so order carries meaning: put the specific prefixes above the general ones.

With no config file every profile counts as work and every repo falls back to local, so the tool runs anywhere. Nothing here knows a customer name: the ADO organisation is read off each ADO profile's devops client in owa-piggy.

Reading the output

Sort order is how a human triages. A deadline inside 14 days jumps the queue; everything else falls back to most recently touched. 2026-09-11 in the last column is a deadline.

Bare now shows only status and title (clipped to the terminal width), with ado: on ADO statuses and loop for ledger loops. -v adds the id column and the deadline, or age when there is none (17d is how long since anything moved).

Things reports Today and Upcoming only as group titles: the items inside still say start=Anytime or Someday. Both are read from the group, so status says today or upcoming, and an upcoming task carries starts with the date it arrives.

An upcoming task earns a row in the normal view the same way anything else does, so one deliberately scheduled for the 21st stays out until its deadline or its start brings it in. --upcoming looks ahead on purpose. It skips the relevance filter, which is what hides deferred work, and leads each row with the date the task arrives.

A Things task shows up only if it has a deadline, sits in Today, or duplicates an ADO work item. Anything and Someday with no date is backlog the user keeps in Things on purpose, and it used to bury the work items. --full brings it back.

A .plans/ directory is a document library as much as a task list, so the same rule applies: TODO.md lines are tasks and always show, a plan file is the document about work and shows when its ado: frontmatter names an open work item. Across every repo that is 90 plan files against 76 todo lines. --full and --grep bring them back.

Size

now --agent always covers every profile (it implies --all), around 75 KB; the human view without --all is the work view, around a third of that. Scope with --profile; --source things as a size control silently drops ADO and plans.

⧉ marks a Things row whose title names an ADO work item also in the list. By convention such a task is a personal sub-step of that work item: the work item holds the status, the Things task holds what the user does next about it.

The mark is informational and there is no footer nag. A .plans/ file naming its work item carries no mark, since that is where the reasoning lives and the duplication is intended.

--grep is a search, so it runs before the relevance filter and across every profile: naming a needle means look everywhere, so a search needs no --full --all.

--dupes lists them and names the work item each one belongs to. Look there for a Things task that is the work item (same title, no personal step in it); that one is a leftover and gets cancelled. From an agent, prefer --agent: every record carries dupe_of with the work item id.

Drift shows up on its own, no detector needed. A plan touched 2 days ago sitting next to its Things task untouched for 17 days in Someday is the signal. Read it and close the stale side.

For agents

• Use --agent and read data[]. Every record has id, source, title, profile, status, updated, deadline, url, plus source-specific extras.
• Ids are stable and source-prefixed: plans:<repo>/<slug>, things:<uuid8>, ado:<id>, loops:<slug>.
• Check _owa.warnings before trusting a gap. A source that is down is reported there, never silently dropped. An expired profile token yields owa-piggy reseed --profile <name>, which only the user can run.
• Before creating a task, run now --grep <keyword> to see whether one exists. The search already spans every profile and the filtered-out backlog, so no flags are needed to make a dedupe check see everything.
• After finishing work, close it in the source that owns it, not here.
• Writes and the logbook live in the source skill. Creating, completing or editing a Things task, and any completed-work view, is cj-things; a work item is owa-ado (or the cj-owa-ado skill, if installed); a plan or todo line is cj-todo; a loop is cj-notes.

Deliberately not built

Write-back, pinning, a link file between related records, and drift as a subcommand. Add them when the read-only view proves it needs them, not before.