Skip to content

v0.10.0 — Recurring audit & the supervision dial

Choose a tag to compare

@askwigconsulting askwigconsulting released this 30 Jul 14:18
· 26 commits to master since this release
beb37f9

Added

  • Working memory: continuous mid-session capture, consolidated at boundaries.
    Context is now staged as you work, not only at a boundary. A new global
    working-memory memory prompts the model to stage durable context at task milestones
    (cohort working-note "…"), and a deterministic Stop hook (cohort working-capture)
    records what changed each turn as a backstop — both into a git-ignored, disposable
    .cohort/state/working-memory/. At the next compaction or session start,
    compact-recall/session-recall surface the staged notes so the durable ones are
    promoted into memory and the rest cleared. This captures the reasoning an exit can't
    (there's no model turn at exit) because it's written during turns. Adds a canonical
    stop hook event, mapped across all three adapters. Governed by the same auto_capture
    opt-out.
  • session-recall — the exit→next-session memory bridge. At SessionEnd the
    model gets no turn and its context is already gone, so nothing model-authored can be
    saved at exit — which is how a closed session lost its context. A new global
    session-recall hook closes the gap from the next session's side: on a
    non-compaction session_start it surfaces the prior session's auto-captured record
    once and injects a nudge to promote its key decisions, in-flight state, and open
    questions into durable memory before resuming. It writes nothing but a git-ignored
    marker (so each record surfaces at most once) and stays silent on the compact
    source, where post-compact-memory already owns the recall. The exit-time analog of
    the pre-compact-capture/post-compact-memory pair.
  • Grok can write code natively, sandboxed by bubblewrap. cohort engine work grok
    now dispatches grok-cli as a write doer that edits a throwaway worktree directly — the
    Codex-equivalent "native filesystem" path, so Grok can implement and review with real
    file access, not only propose a gated patch. Because grok-cli has no sandbox of its
    own, Cohort imposes one with bubblewrap: every write is kernel-confined to the
    worktree, the user's real home (SSH keys, other repos) is not mounted, and only the
    network for the xAI API is left up. The API key rides the environment, never argv.
    Requires bwrap (Linux); where it's absent the doer refuses rather than run grok
    unconfined, and engine propose grok --agentic remains the gated fallback.
  • Supervision dial: cohort autonomy (paired → autopilot). Choose how often Cohort
    stops to ask, from confirm-every-step to run-up-to-the-PR. It tunes discretionary
    friction over cheaply-reversible actions only, on a fixed safety floor no level can
    lower: the human PR-merge gate, the code egress/secret/footprint gates, verification of
    every foreign diff, and the operational hard-limits — and confirm-for-irreversible stays
    stop-and-ask at every level. "Full autopilot, no checks" is deliberately not offered
    (merge is human by construction; the honest ceiling is autopilot up-to-PR). The level
    is machine-local (stored under state/, never synced) and fail-closed, so a pulled
    config can never raise a machine's autonomy. A new autonomy-levels memory + a
    session-start hook make the current level ambient to the coordinator.
  • /audit — recurring, rotating whole-application adversarial audit. The recurring
    sibling of /scout: rather than reviewing a target you name, it audits the app you
    didn't, on a staleness rotation with a coverage ledger (docs/audit/ledger.md) so no
    dimension goes more than ~4 runs unlooked-at — and it sweeps the project's declared
    critical path (whatever can move money, write prod data, grant access, deploy, or
    act irreversibly) every run. Fourteen distinct dimensions, each with a diagnostic
    "tell" (critical-path, security, correctness, concurrency, resilience, dead-ends,
    honesty, performance, naming, docs, tests, supply-chain, accessibility, ops),
    cross-vendor fan-out, round-two refutation, and a close-the-loop step (file tickets,
    update the ledger, record per-dimension false-positive rate). Read-only and advisory,
    coordinator-verified — same posture as /scout. Generalized from a project-specific
    audit command so it fits any application, not one domain.
  • GitHub Copilot CLI renderer (--ide copilot, experimental). A fourth renderer
    alongside Claude/Codex/Cursor, doc-verified 2026-07-24 against the official Copilot
    CLI docs (docs.github.com/en/copilot). Agents compile to
    ~/.copilot/agents/<name>.md with a real tools: alias allow-list
    (read/search/web/edit/execute); advisory is enforced mechanically by
    restricting that list to the read-only aliases, the same invariant Claude/Codex/Cursor
    apply via their own mechanisms. Skills compile to ~/.copilot/skills/<name>/SKILL.md.
    Hooks compile to their own dedicated ~/.copilot/hooks/cohort-hooks.json — Copilot
    loads every *.json under hooks/ independently, so no merge op is needed there,
    unlike Codex/Cursor. Memory merges an @import into
    ~/.copilot/copilot-instructions.md, mirroring Claude's CLAUDE.md shape. command
    is a declared parity gap (Copilot CLI has no user-definable slash-command mechanism).
    Same experimental, doc-cited-but-not-live-verified caveat Codex/Cursor already carry.
  • /audit gains a business track (go-to-market, business-ops, privacy). The audit now
    reviews the business that ships the app, not only the code, as a second track with
    its own evidence standard — a named artifact or a searched-and-documented absence
    rather than file:line — budgeted separately so a business dimension never displaces a
    code one. Adds a privacy code dimension (are the rights the law grants actually
    executable in code — deletion, export, opt-out — with the deletion-vs-retention trap
    named), go-to-market and business-ops business dimensions, a business-context
    declaration in the ledger (stage, jurisdictions, entity/filings, data categories,
    regulatory posture), top-tier + web-search + two-vendor routing for the business track,
    and a hard "no legal/compliance conclusions" guardrail — reviewers frame questions
    and tag anything needing counsel REQUIRES PROFESSIONAL OPINION, and never touch personal
    data to test a privacy claim. Go-to-market joins critical-path as always-on.

Changed

  • Session capture is on by default now (opt-out, was opt-in). auto_capture
    flips from false to true in the scaffold and in the read default, so a session
    end writes its minimal record (branch, change summary, timestamp) to
    .cohort/sessions/ unless a repo sets auto_capture = false. This is what feeds the
    new session-recall bridge — exit context is no longer lost silently.
  • Orchestration cap raised to 20, with an optional federated three-tier mode. The
    global in-flight cap moves from 10 to 20, and /crew gains a Director→Manager→Agent
    mode for large work: the Director delegates task-groups to ephemeral manager
    sub-coordinators (≤5 agents per manager, ≤20 global), each verifying its own group while
    the Director re-verifies group contracts and every foreign-engine diff. It stays
    coordination discipline — no declared graph, no persisted status, no durable-session
    scheduler (that's the design a prior panel rejected). Requires the platform to permit
    nested agents (CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH=2, or Agent Teams for the top
    tier); flat single-coordinator is the fallback. Both cap numbers are single-sourced in
    docs/model-tiers.md and lint-checked for drift. New docs/orchestration-patterns.md
    documents when federation pays off (and when it's over-engineering); ship.md's stale
    "subagents cannot spawn subagents" is corrected to "not by default."
  • Supply-chain hardened. Floating dependency ranges are bounded (PyYAML<7,
    pytest<10, jsonschema<5) so a build can't silently pull a new major; a new
    requirements.lock pins the exact runtime dependency closure for reproducible installs
    (pyproject.toml keeps the human-authored ranges); jsonschema moved to dev-only (it
    was an unused runtime dependency); and CI installs bubblewrap so the grok
    confinement test runs instead of silently skip-gating.

Fixed

  • Concurrent-writer races on all JSON state, closed with a portable file lock. A new
    stdlib filelock.py (an O_CREAT|O_EXCL lock-file — the one primitive identical on
    POSIX and Windows — plus a stale-steal and an acquire timeout) serializes every
    read-modify-write on the project registry, the install manifest, and the sync
    quarantine. Two concurrent cohort processes could previously lose a manifest op record
    (a placed file with no reversal entry, breaking uninstall) or drop a quarantine record
    (a gate bypass). The manifest guard covers every RMW call site, with the fresh-init
    bootstrap and the full-uninstall state/ teardown correctly left unlocked.
  • Sync quarantine no longer trusts a just-pulled artifact. cohort update seeds the
    trusted-office baseline from the pre-pull tree, so an artifact a pull introduces is
    measured as a delta and withheld for review instead of folded into "trusted" on the
    first update.
  • Python 3.10 floor restored. The tomllib import (3.11+) is guarded with a minimal
    fallback parser, so cohort no longer crashes at import on the declared 3.10 floor; CI
    now tests 3.10 alongside 3.12.
  • Assorted audit LOW fixes: the egress opt-out fails closed on any indentation and a
    .git path can't be smuggled past the gate via a Windows trailing-dot segment;
    dangling-symlink uninstall only removes a link still pointing at our recorded target;
    SCAFFOLD ops default to preserved on pre-migration manifests; --force hook restore
    replaces a diverged entry instead of duplicating it (it would otherwise fire twice).

Security

  • External-engine egress hardened (audit-driven). Closed several ways an external
    engine could over-expose data. The grok bubblewrap doer no longer inherits the full host
    environment or unrestricted network — _scrubbed_env passes only a minimal per-engine
    allow-list, and base-URL userinfo credentials are stripped. The agentic patch-proposer
    now runs the code-enforced secret scan like every other egress path. A doer's committed
    worktree files are secret-scanned (fail-closed) and bounded by a total wire-byte cap
    before dispatch, so a runaway worktree can't be shipped off-machine unbounded. Verified
    in the same pass: a user-local grok binary is still bubblewrap-jailed (the wrap is on
    the command, not the binary path), and codex's inability to restrict reads under
    workspace-write is documented as a known residual rather than papered over.