coulomb/nudge-space
5
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Establish the Nudge Space peripheral registry.

Browse source 
State the parking-lot intent, the nudges/ convention, and the concept for
a later Forgejo-backed topic heatmap. Register the bootstrap workplan.

Assistant: grok
Assistant-Session: 01a107f5-2e61-7df1-ab4e-f9cb9fe2199c
This commit is contained in:
tegwick 2026-10-04 19:50:48 +02:00
parent aa19df7197
commit f6e7a03afb
10 changed files with 761 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

5
.gitignore vendored Normal file
View file

@ -0,0 +1,5 @@
# state-hub: track .claude/rules
# Claude Code local state (track shared rules; ignore machine-specific files)
.claude/*
!.claude/rules/
!.claude/rules/*.md

25
.repo-classification.yaml Normal file
View file

@ -0,0 +1,25 @@
repo_classification:
standard: Repo Classification Standard
version: "1.1"
classified_at: "2026-10-04"
classified_by: agent
category: research
domain: infotech
secondary_domains:
- agents
capability_tags:
- knowledge
- participation
- discovery
business_stake:
- intelligence
- product
- technology
business_mechanics:
- intention
- adaptation
notes: >-
Peripheral registry of hunches that are worth remembering and should stay
out of the work-record backbone. Participant repositories connect by
keeping notes in nudges/. A later Forgejo read projects those folders
into a topic heatmap. Not a task tracker.

272
AGENTS.md Normal file
View file

@ -0,0 +1,272 @@
# nudge-space — Agent Instructions
## Repo Identity
**Purpose:** Peripheral registry of hunches that participants park in nudges/ folders, kept for later search and a topic heatmap rather than turned into tasks.
**Domain:** infotech
**Repo slug:** nudge-space
**Topic ID:** `e61b8d01-78ec-47af-a68b-b92afa6fb188`
**Workplan prefix:** `NUDGE-WP-`
---
## State Hub Integration
The Custodian State Hub tracks work across all domains. Codex uses HTTP REST and
the `statehub` CLI by default. MCP is opt-in because the current Codex MCP bridge
adds severe call latency; the full administrative MCP surface remains available
to clients that need it.
<!-- BEGIN STATE-HUB-ACCESS -->
| Context | URL |
|---------|-----|
| Local workstation | `http://127.0.0.1:8000` |
| Remote (railiance01, in-cluster) | `http://10.43.68.154:8000` |
| Optional local edge relay | `http://127.0.0.1:18080` |
Do not instruct a remote agent to use `http://127.0.0.1:18000`. That reverse tunnel is retired; on railiance01 reach the hub at the in-cluster address above.
<!-- END STATE-HUB-ACCESS -->
When an operator has enabled the edge relay, set API_BASE to the relay URL.
Queueable writes return an explicit queued receipt if the central hub is
unreachable. Treat that as pending local evidence, then ask the operator to run
statehub outbox status/replay after connectivity returns.
Codex workspace-write sandboxes need network access enabled to reach the host's
loopback listener. Bootstrap this once with `make -C ~/state-hub configure-codex`
and restart Codex. The canonical REST health endpoint is `/state/health`, not
`/health`. If a sandboxed loopback probe fails, retry it with escalated execution
before declaring State Hub unavailable; a managed Codex permission profile may
still enforce isolated networking. Experimental MCP can be enabled explicitly
with `make -C ~/state-hub configure-codex WITH_MCP=1`.
### Orient at session start
```bash
# Offline brief — works without hub connection
cat .custodian-brief.md
# Active workplans for this domain
curl -s "http://127.0.0.1:8000/workplans/?topic_id=e61b8d01-78ec-47af-a68b-b92afa6fb188&status=active" \
| python3 -m json.tool
# Check inbox
curl -s "http://127.0.0.1:8000/messages/?to_agent=nudge-space&unread_only=true" \
| python3 -m json.tool
```
Mark a message read:
```bash
curl -s -X PATCH "http://127.0.0.1:8000/messages/<id>/read" \
-H "Content-Type: application/json" -d '{}'
```
### Log progress (required at session close)
```bash
curl -s -X POST http://127.0.0.1:8000/progress/ \
-H "Content-Type: application/json" \
-d '{
"summary": "what was done",
"event_type": "note",
"author": "codex",
"workplan_id": "<uuid>",
"task_id": "<uuid>"
}'
```
Omit `workplan_id` / `task_id` when not applicable.
### Update task status
```bash
curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
-H "Content-Type: application/json" \
-d '{"status": "progress"}'
# values: wait | todo | progress | done | cancel
```
### Flag a task for human review
```bash
curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
-H "Content-Type: application/json" \
-d '{"needs_human": true, "intervention_note": "reason"}'
```
---
## Session Protocol
**Start:**
1. `cat .custodian-brief.md` — domain goal and open workplans (offline-safe)
2. Check inbox: `GET /messages/?to_agent=nudge-space&unread_only=true`; mark read
3. Scan workplans: `ls workplans/` — note `status: ready`, `active`, or `blocked` files and open tasks
4. Check human-needed tasks: `GET /tasks/?needs_human=true`
**During work:**
- Update task statuses in workplan files as tasks progress
- Record significant decisions via `POST /decisions/`
**Close:**
1. Update workplan file task statuses to reflect progress
2. If finishing a workplan: hand off **residuals** as live work records first
(intake with `origin: residual` + `origin_ref: <WP-id>`, or a next workplan /
decision / engagement). Do not park leftovers only in prose or `SCOPE.md`.
Canon: `the-custodian/canon/standards/work-record-types_v0.1.md` § Residuals.
3. Log: `POST /progress/` with a summary of what changed (name handoff ids)
4. After workplan file changes, run:
```bash
uv run --project ~/repo-manager rmgr sync --path . --push
```
This assigns only missing deterministic identifiers, verifies the pushed
Forgejo commit and `primary/railliance01`, then requests one central
reconciliation. A queued receipt is pending evidence; rerun after
connectivity returns. Use `statehub fix-consistency` for a separate deep audit.
---
## Credential and access routing
**Audience:** Codex, Claude Code, Grok, and custodian agents that call **llm-connect**
for inference. Run this check **before** requesting secrets, API keys, SSH access,
login tokens, or database passwords — in any repo, not only `ops-warden`.
ops-warden **issues SSH certificates only** (`warden sign`, `cert_command`). Every
other credential need belongs to another subsystem. **Do not** message
`ops-warden` on State Hub expecting a secret value; the reply is a pointer, not a key.
### Lookup (do this first)
```bash
warden route find "<describe your need>" --json
warden route show <catalog-id> --json
```
Requires the `warden` CLI from `~/ops-warden` (`uv tool install .` or `uv run warden`).
| Agent runtime | How to orient |
| --- | --- |
| **Codex / Grok** (shell, HTTP State Hub) | `warden route` commands above; inbox `to_agent=nudge-space` is for coordination, not secret vending |
| **Claude Code** (MCP when available) | `get_domain_summary("custodian")` for workplans; **still** use `warden route` for credential ownership |
| **llm-connect** (inference service) | Never put secret retrieval in prompts; route custody to OpenBao/operator paths surfaced by `warden route` |
### Quick routing table
| I need… | Owner | ops-warden executes? |
| --- | --- | --- |
| SSH cert (`adm`/`agt`/`atm`) | ops-warden | **Yes** — `warden sign` |
| API key, DB password, provider token | OpenBao (`railiance-platform`) | No — route only |
| Login / OIDC / MFA | key-cape / Keycloak | No — route only |
| Authorization decision | flex-auth | No — route only |
| activity-core → issue-core emission | activity-core + issue-core | No — `warden route show activity-core-issue-sink` |
| SSH tunnel | ops-bridge (+ `cert_command` from warden) | No — route only |
### Anti-patterns (do not do these)
- `POST /messages/` to `ops-warden` asking for `ISSUE_CORE_API_KEY`, `OPENROUTER_API_KEY`, etc.
- Inventing `warden secret`, `warden login`, `warden bao`, `warden tunnel` — they do not exist
- Pasting secrets into Git, State Hub, workplans, logs, or chat
### Other capabilities (reuse-surface)
Non-credential capabilities are usually discovered through **reuse-surface** federation
(`reuse-surface` registry / `capability.*` indexes). Credential routing is inlined in
every repo's agent instructions because it is high-frequency, high-risk, and easy to
get wrong.
**Canon:** `~/ops-warden/wiki/CredentialRouting.md` · catalog `~/ops-warden/registry/routing/catalog.yaml`
<!-- REPO-AGENTS-EXTENSIONS -->
<!-- Append repo-specific agent instructions below this marker.
The state-hub template sync preserves content after this line. -->
## Nudge Space
Read `INTENT.md` and `docs/concept_v0.1.md` before changing this repository.
A nudge is a note in a repository's `nudges/` folder. It is a hunch in peripheral view. It is not a work record.
- Do not create an intake, workplan, or task merely to keep a hunch. The `nudges/` file is how it is kept.
- Do not refine a nudge into acceptance criteria, a design, or an owner.
- Promotion is a deliberate act in the repository that should own the resulting work. It is not the default end of a session here.
- The Forgejo reader and the topic heatmap are described in the concept. They stay undesigned until someone promotes that work on purpose. That description is the parking lot for them. Do not open a residual intake for it when closing a workplan.
- There is no install, test, lint, or run command yet. A session that is only recording a hunch has nothing to build.
Participant notes live in `<repo>/nudges/YYYYMMDD-short-slug.md`. This repository's own `nudges/` folder follows that convention. `nudges/README.md` is not a nudge.
---
## Workplan Convention (ADR-001)
Work items originate as files in this repo — not in the hub. The hub is a
read/cache/index layer that rebuilds from files.
**File location:** `workplans/NUDGE-WP-NNNN-<slug>.md`
**Archived location:** finished workplans may move to
`workplans/archived/YYMMDD-NUDGE-WP-NNNN-<slug>.md`. The `YYMMDD` prefix is
the completion/archive date; the frontmatter `id` does not change.
**Ad Hoc Tasks:** small opportunistic fixes discovered during a session use
`workplans/ADHOC-YYYY-MM-DD.md`, workplan id
`NUDGE-WP-ADHOC-YYYY-MM-DD`, and task ids
`NUDGE-WP-ADHOC-YYYY-MM-DD-T01`, etc. `NUDGE-WP` includes its final `-WP`
token. Unqualified historic `ADHOC-*` ids are grandfathered and must not be
copied into new records. Use this only for low-risk work completed directly;
create a normal workplan for anything needing analysis, design, approval,
dependencies, or multiple phases.
**Frontmatter:**
```yaml
---
id: NUDGE-WP-NNNN
type: workplan
title: "..."
domain: infotech
repo: nudge-space
status: proposed | ready | active | blocked | backlog | finished | archived
owner: codex
topic_slug: ...
created: "YYYY-MM-DD"
updated: "YYYY-MM-DD"
state_hub_workstream_id: "<uuid>" # deterministic UUIDv5; managed by Repo Manager
---
```
Use `proposed` for a new draft, `ready` after review against current repo
state, and `finished` after implementation. `stalled` and `needs_review` are
derived health labels, not frontmatter statuses.
**Terminology:** workplan is the fleet term; `workstream` appears only in legacy
API/MCP/frontmatter bridges until `STATE-WP-0069` retires them — see
`the-custodian/canon/standards/workplan-terminology-fleet_v0.1.md`.
**Task block format** (one per `##` section):
```
## Task Title
` ` `task
id: NUDGE-WP-NNNN-T01
status: wait | todo | progress | done | cancel
priority: high | medium | low
state_hub_task_id: "<uuid>" # deterministic UUIDv5; managed by Repo Manager
` ` `
Task description text.
```
Status progression: `todo` → `progress` → `done`; use `wait` for waiting/blocked work and `cancel` for stopped work.
**Residuals when finishing:** actionable leftovers become live work records
before `status: finished` — usually an intake (`origin: residual`,
`origin_ref: NUDGE-WP-NNNN`) or a spawned workplan. Residual is a *role*,
not a kind. Fleet list lives on State Hub, not in `SCOPE.md`.
To create a new workplan:
1. Write the file following the format above
2. Run `uv run --project ~/repo-manager rmgr sync --path . --push`.
3. Run `statehub fix-consistency` only when a separate deep audit is needed.

114
INTENT.md Normal file
View file

@ -0,0 +1,114 @@
---
domain: infotech
repo: nudge-space
updated: "2026-10-04"
---
# INTENT
> This file explains why nudge-space exists, what role it plays in the
> ecosystem, and what it must not absorb.
---
## Why it exists
Participants in this ecosystem keep noticing things that are relevant, and
that are not ready to become work. Turning each one into a task would spend
the focus the work needs. Dropping each one would throw away a signal that
might matter later, or that might show up again and again.
Nudge Space is the parking space for those notices. In an agile meeting the
parking lot holds a thought that has relevance and does not have the floor.
Here the same thought is written down, left in peripheral view, and kept
available for when it is needed or when it recurs.
The repository is a semi-structured collection at the very beginning of value
and product discovery. A nudge is earlier than an intake. It is a hunch with
an origin, not a commitment.
---
## The governing principle
nudge-space owns **peripheral attention**.
It should answer:
1. **What have people noticed?** Hunches, unfinished ideas, and recurring
themes, each with a pointer back to where they were encountered.
2. **Where does attention gather?** A topic heatmap, in the spirit of a word
cloud, that develops as nudges accumulate.
3. **What is still only a hunch?** The record stays a nudge until someone
deliberately promotes its substance into a work record somewhere else.
A nudge stays in the periphery. Elaborating it here, or filing it as a task
so it will not be forgotten, spends the focus this place exists to protect.
---
## What it is
nudge-space is the **discovery periphery** for the ecosystem.
It contains:
- the intent and concept for that periphery
- the convention by which a repository connects: a `nudges/` folder of
semi-structured notes
- later, a read of those folders through Forgejo, and a search and
exploration space over what they contain
The source of a nudge stays in the repository where it was encountered. This
repository collects and, in time, projects. Participants keep editing their
notes at home.
---
## What it is not
| Concern | Where it belongs |
|---|---|
| Executable work, acceptance, owners, deadlines | A workplan in the owning repository |
| A spark someone has decided should enter coordination | An intake in the owning repository |
| Decisions, canon, and standards | The owning repository, or the-custodian |
| Product design and implementation of an idea | The repository that takes the idea up |
| A ranked backlog | Nowhere. Recurrence is a signal, and a signal is not an assignment |
Promotion is a separate act. Someone copies the substance into a work record
in the repository that should own it, and may leave a pointer on the nudge.
The nudge file remains.
---
## What it enables
When this repository is doing its job, a participant can:
- park a hunch in the repository where it appeared, under `nudges/`, and go
back to the work
- find that hunch again, with its origin
- see which themes recur across repositories, as a heatmap that develops
over time
- choose, in a later sitting, whether a recurring theme deserves to become
real work
---
## Design values
**Focus stays with the work.** Recording a nudge is a small act. Refining it
waits for a deliberate promotion.
**Origin stays attached.** A nudge names where it was encountered.
**The source stays put.** Participant repositories keep their own `nudges/`
folders. Nudge Space reads them through Forgejo.
**Recurrence is the interesting event.** A theme that returns, across days or
across repositories, is the signal worth seeing. A single hunch can sit
quietly.
**Rough on purpose.** The collection is semi-structured. Enough shape to
search and to cluster. Little enough shape that it cannot become a second
task system.

4
README.md
View file

@ -1,3 +1,5 @@
# nudge-space # nudge-space
A multitopic brainstorming like collection for pre-idea hunches, bullets, unfinished ideas and generally stuff to maybe or maybe not follow up on later. We call these nudges, they should have a reference to their origin and putting them here, will provide signal on what to explore. A multitopic brainstorming like collection for pre-idea hunches, bullets, unfinished ideas and generally stuff to maybe or maybe not follow up on later. We call these nudges, they should have a reference to their origin and putting them here, will provide signal on what to explore.
This is the parking lot of the ecosystem: relevant enough to keep in peripheral view, and not ready to become a task. Repositories connect by keeping their notes in a `nudges/` folder. The intent is [`INTENT.md`](INTENT.md). The concept is [`docs/concept_v0.1.md`](docs/concept_v0.1.md).

47
SCOPE.md Normal file
View file

@ -0,0 +1,47 @@
# SCOPE
## One-liner
Nudge Space is the peripheral registry of hunches that are worth remembering
and should not become tasks.
## Core Idea
Participants drop semi-structured notes in a `nudges/` folder inside the
repository where the hunch was encountered. Nudge Space is the concept and,
later, the Forgejo-backed search and topic heatmap over those folders. The
collection is the earliest layer of value and product discovery: before an
intake, and outside the work-record backbone.
The concept is `docs/concept_v0.1.md`. The reason the repository exists is
`INTENT.md`.
## In Scope
- The meaning of a nudge, and the line between a nudge and a work record.
- The participant convention: a top-level `nudges/` folder of one-file Markdown notes.
- The minimum file shape that later search and clustering can read.
- Registration of this repository with State Hub.
- A future read-only ingest of `nudges/` through Forgejo, and an exploration space over the result, once someone deliberately promotes that work.
## Out of Scope
- Turning a nudge into a task, intake, or workplan from inside this repository.
- Ranking, assigning, estimating, or scheduling parked hunches.
- Editing participant repositories. The source of a nudge stays where it was written.
- Decisions, canon, and product design. Those belong to the repository that picks a theme up.
- A new credential lane for Forgejo. The reader uses access the estate already has.
## Current State
- Status: concept established, 2026-10-04. The convention is specified. The Forgejo reader and the heatmap are named and unbuilt.
- Category: research. The repository holds the discovery collection and its concept. It is not yet a deployable tool.
- Domain: infotech, because the registry is an internal instrument for participants of this estate. Agents are a secondary domain, as participants. Market sectors are not.
## Getting Oriented
- Start with: `INTENT.md`
- Concept: `docs/concept_v0.1.md`
- Participant folder: `nudges/README.md`
- Agent instructions: `AGENTS.md`
- Workplans: `workplans/`

13
WORK-RECORDS.md Normal file
View file

@ -0,0 +1,13 @@
# Work Records — nudge-space
> Generated by `statehub fix-consistency` (CUST-WP-0061-T04, work-record
> stage 3). Do not edit by hand — edit the source file/block listed for
> each record and re-run fix-consistency to refresh this index. Archived
> workplans are omitted; closed decisions/intakes/engagements stay listed
> so recently-resolved work is still visible. [auto]
| Kind | ID | Status | Lane | Source |
| --- | --- | --- | --- | --- |
| workplan | NUDGE-WP-0001 | finished | — | workplans/NUDGE-WP-0001-statehub-bootstrap.md |
| task | NUDGE-WP-0001-T01 | done | — | workplans/NUDGE-WP-0001-statehub-bootstrap.md |
| task | NUDGE-WP-0001-T02 | done | — | workplans/NUDGE-WP-0001-statehub-bootstrap.md |

202
docs/concept_v0.1.md Normal file
View file

@ -0,0 +1,202 @@
---
title: "Nudge Space — Concept v0.1"
type: concept
status: draft
repo: nudge-space
domain: infotech
created: "2026-10-04"
updated: "2026-10-04"
---
# Nudge Space — Concept v0.1
Nudge Space is a parking lot for the ecosystem. A participant encounters
something relevant, and the encounter is not worth a task. The thought is
also too interesting to drop on the floor. It goes into peripheral view:
kept, searchable, and able to show its face again if it keeps coming back.
This is the earliest layer of value and product discovery. The material is
semi-structured on purpose. It is a collection of hunches, not a product
backlog and not a design.
A **discovery topic** in this document is a theme that emerges from many
nudges, the way a word cloud grows. That is a different thing from a State
Hub topic, which is the registration bucket this repository sits in.
## The situation it answers
Work in this estate is coordinated by work records: intakes, workplans,
tasks, decisions. That backbone is for things someone has decided to carry.
The path into it is easy to overuse. A sharp remark in a review, a repeated
irritation, a half-seen product shape, a tool that might matter next year:
each of these can be written up as a task in a minute, and each such task
competes with the work that already has the floor.
The other failure is silence. The same hunch appears in three repositories
over a month, and nobody can see that, because each encounter was forgotten
at the end of the session.
The parking-lot rule from agile meetings is the remedy. The thought is
acknowledged, written where it can be found, and left alone. Attention
returns to the agenda. Later, if the thought is still there, or if it has
accumulated neighbours, someone can choose to pick it up.
## What a nudge is
A nudge is a short note of an encounter.
It has:
- something that was noticed
- where it was encountered
- when
- enough words that a later reader can recognise it
- optional tags, which are the seeds of the heatmap
It has no status, no owner, no estimate, and no acceptance criteria. It is
not finished or cancelled. It sits.
A nudge is earlier than an intake. An intake, in the fleet work-record
standard, is a spark someone has decided should enter coordination. A nudge
is the spark before that decision. The kind registry of work records stays
closed. A note with no lifecycle is already outside that registry: the
standard says so for `RISK-N-*` notes, and the same line is drawn here.
Promotion, when it happens, happens somewhere else. A person or an agent
creates an intake or a workplan in the repository that should own the work,
and may then add a `promoted` pointer on the nudge. The nudge file stays in
place, so the periphery still shows that the thought existed and where the
work went.
## Where nudges live
A repository connects to Nudge Space by keeping its nudges in a top-level
folder named `nudges/`.
The folder is the whole integration. There is no registration call per
nudge, and participants do not copy their notes into this repository. The
note stays next to the work where it was encountered, and it is published
the same way the rest of that repository is published: a commit on Forgejo.
This repository follows the same convention for hunches encountered while
working on Nudge Space itself. Its `nudges/` folder is a participant folder.
The index this repository will eventually build is a projection of many such
folders, including its own.
### File shape
One nudge is one Markdown file.
```text
nudges/YYYYMMDD-short-slug.md
```
The date is the day it was first written. The slug is stable. Renaming is a
later problem for the reader; until then the path is the identity, together
with the repository that holds it.
```yaml
---
title: A few words naming the hunch
noticed: 2026-10-04
origin: repo, conversation, document, or url — specific enough to find again
tags: [kebab-case, another-theme]
---
What was noticed. A few sentences of the original thought are enough.
Why it is parked. One or two sentences on why it should stay in the periphery.
```
Optional fields, used when they are true:
| Field | Meaning |
|---|---|
| `recurrence` | Whole number. Bump it when the same hunch shows up again. Absent means once. |
| `see_also` | Paths or URLs that belong to the same encounter. |
| `promoted` | Id of a work record created elsewhere, after a deliberate promotion. |
The body can be rough. Write the thought in the words it arrived in. Do not
add a task list, a design, an estimate, or an owner. Those are the marks of
work, and work belongs in a work record.
A future reader skips, and does not index as nudges:
- `README.md`
- names that start with `.` or `_`
- anything outside `nudges/`
## How this repository reads them
The intended reader is Nudge Space, fetching participant folders through
Forgejo.
The shape of that read:
1. The set of repositories is the set this estate already publishes on
Forgejo. The remote form already used here is
`forgejo-remote:coulomb/<repo>`.
2. The reader fetches a repository read-only and takes `nudges/**/*.md` at a
commit.
3. It does not commit back into participant repositories.
4. It uses whatever Forgejo read access the estate already has. This concept
opens no new credential lane.
5. A collected nudge is identified by repository plus path. Frontmatter
enriches that identity. It does not replace it.
Search and exploration sit on top of that collection: words, tags, origin
repository, and date. Opening a tag shows the files that fed it, each still
pointing at its home repository.
v0.1 does not build that reader. It fixes the place the notes live and the
shape they have, so a later reader has an honest corpus.
## The heatmap
Over time the collection develops a topic heatmap, close to a word cloud.
Tokens come from `tags`, from `title`, and from phrases that repeat in the
bodies. A token gains weight when more nudges carry it, when they come from
more than one repository, and when they recur or arrive recently. The exact
weighting waits until there is a body of nudges to look at. Choosing a
formula against an empty collection would be ceremony.
The heatmap is a perception aid. It answers "what keeps coming back?" It
does not sort a backlog, assign an owner, or create a task. A bright topic
is a reason to look. Looking is optional.
## Where this sits in discovery
Earliest first:
1. **Nudge.** Noticed, parked, still peripheral. This repository.
2. **Intake.** Someone decides the spark should enter coordination. The
owning repository.
3. **Workplan and tasks.** The spark has a body of work. The owning
repository.
4. **Product, tool, or canon.** The work has a durable home.
Nudge Space owns step 1. Steps 2–4 stay in the repositories that take the
work up. State Hub remains the read model for those work records. Nudges are
not projected into it as tasks.
## What v0.1 establishes
- This intent and concept.
- The `nudges/` convention and the file shape above.
- Registration of the repository with State Hub, so the place has an address
in the estate.
## What stays undesigned until someone promotes it
These are named so they are not forgotten. They are not tasks.
- The Forgejo fetch and the index.
- The search and exploration space.
- The weighting of the heatmap.
- Any view that spans private repositories beyond the Forgejo access that
already exists.
A recurring theme in the corpus is the evidence that one of these, or any
other hunch, might deserve an intake. The evidence is the recurrence. The
decision to promote stays explicit, and it is made outside this folder.

29
nudges/README.md Normal file
View file

@ -0,0 +1,29 @@
# nudges/
This folder is how a repository connects to Nudge Space.
A nudge is a hunch worth keeping in peripheral view. It is not a task. Write
one Markdown file per encounter, dated and slugged:
```text
nudges/YYYYMMDD-short-slug.md
```
```yaml
---
title: A few words naming the hunch
noticed: 2026-10-04
origin: where it was encountered
tags: [kebab-case]
---
What was noticed.
Why it is parked.
```
Leave the thought in the words it arrived in. The shape and the reasons are
in `docs/concept_v0.1.md`.
This README is a convention file. A reader of `nudges/` skips `README.md` and
any name that starts with `.` or `_`.

51
workplans/NUDGE-WP-0001-statehub-bootstrap.md Normal file
View file

@ -0,0 +1,51 @@
---
id: NUDGE-WP-0001
type: workplan
title: "Establish Nudge Space and register it"
domain: infotech
repo: nudge-space
status: finished
flavor: planning
depends_on: []
owner: grok
topic_slug: nudge-space
created: "2026-10-04"
updated: "2026-10-04"
state_hub_workstream_id: "f50b1561-9adc-5e7a-bfb8-5b88c8b5220c"
---
# Establish Nudge Space and register it
Give the peripheral registry a durable statement of intent, a concept for
the participant convention, and an address in State Hub.
The Forgejo ingest and the topic heatmap are described in
`docs/concept_v0.1.md`. They are not residuals of this workplan. They stay
out of the work-record backbone until someone deliberately promotes them.
## Write the intent and concept
```task
id: NUDGE-WP-0001-T01
status: done
priority: high
state_hub_task_id: "0af8644e-008b-5710-aea2-18357ffa5129"
```
`INTENT.md` states the parking-lot role. `docs/concept_v0.1.md` states the
`nudges/` convention, the file shape, the Forgejo read, and the heatmap.
`SCOPE.md`, `.repo-classification.yaml`, and `nudges/README.md` match that
concept.
## Register the repository with State Hub
```task
id: NUDGE-WP-0001-T02
status: done
priority: high
state_hub_task_id: "31512602-6b8c-550a-ae14-694b44aeec66"
```
The infotech topic `nudge-space` exists, the repository and the workstation
host path are registered, and the generated agent files are corrected to
this repository. Classification is projected from `.repo-classification.yaml`.