j-space-directed-focus

name

j-space-directed-focus

description

Deliberately load and maintain one governing aim, constraint, value, interpretation, or compact anchor while other work proceeds. Use when a long or mechanical task must remain aligned with the user's real objective, when a constraint is easy to forget, when a background calculation must stay separate from output, when attention is being captured by an irrelevant concept, or when a dense-track anchor needs periodic renewal. Prefer positive redirection and relevance rules over suppression.

J-Space Directed Focus

Place one star in the chamber and navigate by it.

Directed focus is not constant repetition. It is the deliberate loading, use, renewal, and release of one governing content while fluent work continues around it.

Premise Recall

J-space can hold a small amount of content under deliberate light. What is loaded there can guide work that does not mention it. The light is selective: strengthen the occupant that should govern, and let task-irrelevant material remain outside.

Conservative Execution

When capability is unknown or reliability varies:

• reduce this Skill to CUE → one ACTION → one CHECK → one EXIT;
• hold one governing item and no more than two candidates; externalize fragile state;
• complete one transition before emitting another marker or changing mode;
• prefer plain language and a small ledger; use DENSE only after a delayed expand-back test;
• accept an artifact or changed action as evidence, never assent or self-description alone.

Form the Focus Kernel

Compress the governing content into a focus kernel containing:

• aim: what must become true;
• test: how success will be recognized;
• expiry: when the kernel should be released or replaced.

Example:

Aim: preserve the user's existing API behavior
Test: public calls and outputs remain backward compatible
Expiry: after integration tests pass

Keep the kernel to one coherent idea. A tightly coupled aim and success test count as one cluster. If the kernel requires a paragraph, externalize the paragraph and hold only its label.

Load the Kernel

1. Name the kernel once in clear language.
2. Connect it to one concrete consequence for the current task.
3. State the next seam at which it will be checked.
4. Begin work without chanting it.

Use a vivid internal cue when helpful:

This is the compass. Everything else may move; this remains north until its expiry condition.

The cue is a memory interface, not evidence that attention has succeeded.

Touch at Seams

Refresh focus only at natural boundaries:

• before starting a subtask;
• after a tool result;
• after a context or topic change;
• before an irreversible action;
• before final delivery.

At each seam ask one question:

Does the next action serve the kernel?

If yes, continue. If no, correct the action, update the kernel explicitly, or flag a genuine conflict. Do not silently maintain two incompatible kernels.

Hold Without Leaking

For background arithmetic, unit conversion, a style anchor, or a private constraint:

1. keep surface output on the user's task;
2. let the necessary intermediate become available;
3. use the result;
4. expose the calculation only when auditability or user instruction requires it.

A clean surface with a governing background constraint is successful directed focus.

Redirect, Do Not Wrestle

When an unwanted concept captures attention:

1. avoid repeating a bare “do not think about X” instruction;
2. state what deserves the chamber instead;
3. classify X as task-irrelevant unless specified evidence makes it relevant;
4. give the replacement occupant one immediate action;
5. check again at the next seam, not every token.

Example:

Hold the user's verified requirement. Treat the speculative implementation detail as task-irrelevant until the interface evidence calls for it.

If the concept repeatedly returns with evidence, it may be a real conflict rather than a suppression failure. Route it to introspection or deep reasoning.

Focus Lifecycle

Use five phases:

1. Ignite: name and anchor the kernel.
2. Stabilize: connect it to the next action.
3. Use: let it govern without repetition.
4. Update: change it atomically when evidence changes.
5. Evict: release it when its expiry condition is met.

Stale focus is as harmful as absent focus. At a true topic change, clear the old kernel before loading the new one.

Dual-Task Rule

Do not hold a fragile concept while performing demanding arithmetic, branching search, or a complex tool operation if failure would matter. Externalize the kernel in a visible ledger and reload it at the next seam.

Use j-space-capacity when more than one or two coherent contents compete.

Success Standard

Directed focus has landed when:

• the same governing aim shapes several subtasks without verbal leakage;
• a conflicting local convenience is rejected or escalated;
• a user change updates the kernel everywhere;
• the kernel is released when no longer relevant;
• the final result passes the kernel's success test.

Failure Modes

• Hollow repetition: repeating the label without changing action. Bind it to a consequence.
• Focus leakage: the private anchor appears in unrelated output. Refresh at seams, not mid-phrase.
• Kernel overload: several aims are packed into one slogan. Split or externalize.
• White-bear loop: the unwanted idea is restated in every guardrail. Specify the replacement.
• Stale compass: an expired aim keeps steering a new phase. Evict it deliberately.
• Unexamined conflict: two incompatible aims are both called primary. Escalate the choice.

Handoff

• kernel must govern many deliverable parts → j-space-broadcast
• kernel conflicts with another interpretation → j-space-deep-reasoning
• too many kernels compete → j-space-capacity
• repeated capture or drift persists → j-space-self-monitoring