nsaspy/hackmode
1
0
Fork 0
Code Issues 46 Pull requests 55 Projects Releases Packages Wiki Activity Actions

Make the Hackpert objective loop open and extensible #47

New issue
Open
opened 2026-09-02 17:24:37 +00:00 by nsaspy · 17 comments
nsaspy commented 2026-09-02 17:24:37 +00:00
Owner
Copy link

Outcome

Build Hackpert around an open, registered objective loop rather than hard-coded recon -> attack -> LLM phases.

Parent architecture: #24
Active orchestration: #27
Prolog-RLM generation/escalation: #28

The loop must let Hackmode add new expert systems, tools, objective types, evidence evaluators, strategy selectors, and external engines without rewriting the core controller.

Two independent axes

Do not collapse execution authority and reasoning strategy into one mode enum.

Authority mode

  • passive — observe/reason only; no canonical mutation or provider dispatch.
  • active — may dispatch capabilities and apply typed canonical mutations through Hackmode's validated effect boundary.

Reasoning strategy

  • symbolic — default strategy: typed SPEC/plan/expert execution, including registered tools;
  • direct — fallback/escalation strategy after repeated symbolic failure, blockage, or inability to produce a useful continuation;
  • deterministic expert rules — Prolog/Hackpert expert systems participating in the symbolic loop;
  • later Prolog-RLM generation — #28, used from the loop rather than as a separate authority plane;
  • external strategy adapters — e.g. a future ZeroForge integration if validated.

A run can therefore be active + symbolic, active + direct, passive + symbolic, etc. Reasoning strategy does not independently grant effects.

Default strategy policy: symbolic -> direct escalation -> symbolic

Hackpert should start symbolic by default.

Current prolog-rlm typed symbolic plans already support first-class tool(...) operations. Runtime-integrated symbolic model steps can use the same registered/native tool execution path as direct mode. Therefore symbolic mode is not a read-only planning mode and does not need to surrender execution just to call tools.

Normal control flow:

objective/SPEC
    -> symbolic Hackpert / typed plan / expert rules
    -> tools + evidence + graph/KB mutation under authority policy
    -> re-evaluate objective
    -> symbolic continuation

When symbolic execution repeatedly fails, repeatedly produces non-progress, exhausts known applicable rules/plans, or cannot synthesize a viable next step, the loop may escalate to direct mode:

symbolic
   -> failure/non-progress evidence
   -> symbolic retry/alternate expert
   -> repeated failure threshold reached
   -> direct mode
   -> flexible tool/reasoning exploration
   -> candidate evidence / rule / plan / KB delta
   -> normalize into canonical structures
   -> return to symbolic execution when possible

The failure threshold and escalation policy must be configurable/policy-owned rather than buried in one expert. Direct mode is an escape hatch, not the default permanent controller.

Direct escalation must inherit the same authority mode, capabilities, scope, budgets, effect admission, and graph recording. Escalating from symbolic to direct never widens authority by itself.

Objective / SPEC model

The core loop should run against a typed objective/spec instead of assuming a specific pentest workflow.

Example objective concepts:

final_identity(uid=0)
final_identity(root_equivalent=true)
foothold(required=true)
foothold(obtained=true)
target(os=ios)
target(os=linux)
constraint(scope=...)
stop(on_goal=true)
stop(on_budget=true)

A realistic privilege-escalation objective could say:

Goal: final effective identity is uid 0 / root-equivalent
Precondition: foothold is required
Evidence: authenticated execution evidence proving resulting identity
Stop: goal satisfied, scope/policy denial, exhausted budget, or no viable extension

The exact surface syntax can evolve; the important contract is a normalized/frozen objective with assertions, prerequisites, evidence requirements, stop conditions, budgets, and granted capabilities.

The SPEC/objective is the durable definition of success. A strategy switch does not mutate the goal.

Loop extension protocol

Add a registry for extensions. Each extension should be able to declare:

  • stable ID/version;
  • objective/spec predicates it understands;
  • applicability/preconditions;
  • required capabilities/tools;
  • authority requirements (passive or active);
  • supported reasoning strategies;
  • input graph/KB facts it consumes;
  • typed actions/plan deltas/KB candidates it can produce;
  • evidence it can recognize;
  • stop/success/failure/non-progress signals;
  • provenance/version metadata.

The core loop should ask applicable extensions for candidates, rank/select under policy, execute through the canonical runtime, ingest evidence, re-evaluate the objective, and continue.

objective/spec
   -> evaluate current graph/KB/evidence
   -> discover applicable extensions
   -> symbolic extension proposes next action/plan/query
   -> validate capability + authority + budget
   -> execute through canonical provider/effect path
   -> persist call/result/evidence graph
   -> update operational KB
   -> re-evaluate objective
   -> symbolic continue
        OR repeated failure -> direct escalation
        OR stop

No extension gets a private state database or unrestricted shell/Tek9 authority.

CVE intelligence as an extension family

CVE retrieval should not be hard-coded into the controller. Provide expert/tool adapters that can query vulnerability intelligence and normalize results into Hackpert graph/KB facts.

Examples of extension responsibilities:

  • derive product/version/CPE-like identity from recon evidence;
  • retrieve candidate CVEs/advisories from registered sources/tools;
  • correlate prerequisites and affected versions;
  • attach provenance/confidence;
  • produce candidate attack/validation paths for the symbolic planner;
  • retain negative evidence when a CVE is ruled out.

This allows NVD/OSV/GitHub Advisory/vendor-specific or future StarIntel-backed intelligence sources to be plugged in behind one typed capability contract.

CVE retrieval itself should normally be a symbolic-loop tool/expert: identify what information is missing, invoke the appropriate intelligence capability, assert normalized evidence, and continue planning.

ZeroForge research/integration boundary

Track possible ZeroForge integration as an extension/strategy adapter, not as a new authority plane.

Before implementation, pin the exact ZeroForge project/API and evaluate what it can contribute. If adopted, translate its inputs/outputs to Hackpert's canonical objective, graph, KB, action, evidence, and plan types.

Possible uses include supplying candidate analysis/artifacts to the symbolic planner or serving as a direct-escalation helper when ordinary symbolic experts cannot make progress.

ZeroForge must not bypass Hackmode scope, capabilities, effect admission, graph recording, or operation state.

Prolog-RLM relationship

#28 should plug into this registry and the symbolic-first control policy rather than hard-code a post-recon handoff.

Prolog-RLM may be used to:

  • generate candidate iPhone/mobile rules;
  • generate attack/recon patterns;
  • generate KB facts/abstractions;
  • synthesize a new typed plan when existing symbolic knowledge stalls;
  • assist direct escalation and then return a structured candidate to symbolic execution.

The preferred steady state remains symbolic execution. RLM/direct generation exists to extend the symbolic system when the existing rules/plans cannot make progress.

LISH

LISH should eventually expose:

  • current objective/spec and satisfaction state;
  • authority mode;
  • current reasoning strategy;
  • symbolic failure/non-progress count and escalation reason;
  • applicable/selected extension;
  • why an extension was selected/rejected;
  • capabilities/budget remaining;
  • current goal blockers (e.g. foothold_required, root_not_proven);
  • transitions symbolic -> direct -> symbolic;
  • generated rules/plans/KB candidates and whether they were accepted.

Acceptance direction

  • normalized objective/spec can express a final root/uid-0 goal and a required foothold prerequisite;
  • symbolic is the default reasoning strategy;
  • symbolic strategy can invoke registered tools under the same canonical authority/effect path;
  • loop re-evaluates objective after every evidence-bearing action;
  • extensions register without editing the central loop;
  • an extension can require tools/capabilities and be rejected when unavailable;
  • repeated symbolic failure/non-progress can trigger policy-controlled direct escalation;
  • direct escalation preserves authority/scope/budget and cannot widen capabilities;
  • direct output can be normalized into a rule/plan/evidence/KB candidate and return control to symbolic execution;
  • CVE intelligence can be provided by a replaceable expert/tool adapter;
  • active/passive authority remains orthogonal to symbolic/direct/RLM reasoning strategy;
  • external strategy adapters cannot bypass canonical Hackmode effects/state;
  • LISH can explain objective state, extension selection, failure accumulation, and strategy transitions.
## Outcome Build Hackpert around an **open, registered objective loop** rather than hard-coded recon -> attack -> LLM phases. Parent architecture: #24 Active orchestration: #27 Prolog-RLM generation/escalation: #28 The loop must let Hackmode add new expert systems, tools, objective types, evidence evaluators, strategy selectors, and external engines without rewriting the core controller. ## Two independent axes Do not collapse execution authority and reasoning strategy into one mode enum. ### Authority mode - `passive` — observe/reason only; no canonical mutation or provider dispatch. - `active` — may dispatch capabilities and apply typed canonical mutations through Hackmode's validated effect boundary. ### Reasoning strategy - `symbolic` — **default** strategy: typed SPEC/plan/expert execution, including registered tools; - `direct` — fallback/escalation strategy after repeated symbolic failure, blockage, or inability to produce a useful continuation; - deterministic expert rules — Prolog/Hackpert expert systems participating in the symbolic loop; - later Prolog-RLM generation — #28, used from the loop rather than as a separate authority plane; - external strategy adapters — e.g. a future ZeroForge integration if validated. A run can therefore be `active + symbolic`, `active + direct`, `passive + symbolic`, etc. Reasoning strategy does not independently grant effects. ## Default strategy policy: symbolic -> direct escalation -> symbolic Hackpert should start symbolic by default. Current prolog-rlm typed symbolic plans already support first-class `tool(...)` operations. Runtime-integrated symbolic model steps can use the same registered/native tool execution path as direct mode. Therefore symbolic mode is not a read-only planning mode and does not need to surrender execution just to call tools. Normal control flow: ```text objective/SPEC -> symbolic Hackpert / typed plan / expert rules -> tools + evidence + graph/KB mutation under authority policy -> re-evaluate objective -> symbolic continuation ``` When symbolic execution repeatedly fails, repeatedly produces non-progress, exhausts known applicable rules/plans, or cannot synthesize a viable next step, the loop may escalate to direct mode: ```text symbolic -> failure/non-progress evidence -> symbolic retry/alternate expert -> repeated failure threshold reached -> direct mode -> flexible tool/reasoning exploration -> candidate evidence / rule / plan / KB delta -> normalize into canonical structures -> return to symbolic execution when possible ``` The failure threshold and escalation policy must be configurable/policy-owned rather than buried in one expert. Direct mode is an escape hatch, not the default permanent controller. Direct escalation must inherit the same authority mode, capabilities, scope, budgets, effect admission, and graph recording. Escalating from symbolic to direct never widens authority by itself. ## Objective / SPEC model The core loop should run against a typed objective/spec instead of assuming a specific pentest workflow. Example objective concepts: ```text final_identity(uid=0) final_identity(root_equivalent=true) foothold(required=true) foothold(obtained=true) target(os=ios) target(os=linux) constraint(scope=...) stop(on_goal=true) stop(on_budget=true) ``` A realistic privilege-escalation objective could say: ```text Goal: final effective identity is uid 0 / root-equivalent Precondition: foothold is required Evidence: authenticated execution evidence proving resulting identity Stop: goal satisfied, scope/policy denial, exhausted budget, or no viable extension ``` The exact surface syntax can evolve; the important contract is a normalized/frozen objective with assertions, prerequisites, evidence requirements, stop conditions, budgets, and granted capabilities. The SPEC/objective is the durable definition of success. A strategy switch does not mutate the goal. ## Loop extension protocol Add a registry for extensions. Each extension should be able to declare: - stable ID/version; - objective/spec predicates it understands; - applicability/preconditions; - required capabilities/tools; - authority requirements (`passive` or `active`); - supported reasoning strategies; - input graph/KB facts it consumes; - typed actions/plan deltas/KB candidates it can produce; - evidence it can recognize; - stop/success/failure/non-progress signals; - provenance/version metadata. The core loop should ask applicable extensions for candidates, rank/select under policy, execute through the canonical runtime, ingest evidence, re-evaluate the objective, and continue. ```text objective/spec -> evaluate current graph/KB/evidence -> discover applicable extensions -> symbolic extension proposes next action/plan/query -> validate capability + authority + budget -> execute through canonical provider/effect path -> persist call/result/evidence graph -> update operational KB -> re-evaluate objective -> symbolic continue OR repeated failure -> direct escalation OR stop ``` No extension gets a private state database or unrestricted shell/Tek9 authority. ## CVE intelligence as an extension family CVE retrieval should not be hard-coded into the controller. Provide expert/tool adapters that can query vulnerability intelligence and normalize results into Hackpert graph/KB facts. Examples of extension responsibilities: - derive product/version/CPE-like identity from recon evidence; - retrieve candidate CVEs/advisories from registered sources/tools; - correlate prerequisites and affected versions; - attach provenance/confidence; - produce candidate attack/validation paths for the symbolic planner; - retain negative evidence when a CVE is ruled out. This allows NVD/OSV/GitHub Advisory/vendor-specific or future StarIntel-backed intelligence sources to be plugged in behind one typed capability contract. CVE retrieval itself should normally be a symbolic-loop tool/expert: identify what information is missing, invoke the appropriate intelligence capability, assert normalized evidence, and continue planning. ## ZeroForge research/integration boundary Track possible ZeroForge integration as an **extension/strategy adapter**, not as a new authority plane. Before implementation, pin the exact ZeroForge project/API and evaluate what it can contribute. If adopted, translate its inputs/outputs to Hackpert's canonical objective, graph, KB, action, evidence, and plan types. Possible uses include supplying candidate analysis/artifacts to the symbolic planner or serving as a direct-escalation helper when ordinary symbolic experts cannot make progress. ZeroForge must not bypass Hackmode scope, capabilities, effect admission, graph recording, or operation state. ## Prolog-RLM relationship #28 should plug into this registry and the symbolic-first control policy rather than hard-code a post-recon handoff. Prolog-RLM may be used to: - generate candidate iPhone/mobile rules; - generate attack/recon patterns; - generate KB facts/abstractions; - synthesize a new typed plan when existing symbolic knowledge stalls; - assist direct escalation and then return a structured candidate to symbolic execution. The preferred steady state remains symbolic execution. RLM/direct generation exists to extend the symbolic system when the existing rules/plans cannot make progress. ## LISH LISH should eventually expose: - current objective/spec and satisfaction state; - authority mode; - current reasoning strategy; - symbolic failure/non-progress count and escalation reason; - applicable/selected extension; - why an extension was selected/rejected; - capabilities/budget remaining; - current goal blockers (e.g. `foothold_required`, `root_not_proven`); - transitions `symbolic -> direct -> symbolic`; - generated rules/plans/KB candidates and whether they were accepted. ## Acceptance direction - [ ] normalized objective/spec can express a final root/uid-0 goal and a required foothold prerequisite; - [ ] symbolic is the default reasoning strategy; - [ ] symbolic strategy can invoke registered tools under the same canonical authority/effect path; - [ ] loop re-evaluates objective after every evidence-bearing action; - [ ] extensions register without editing the central loop; - [ ] an extension can require tools/capabilities and be rejected when unavailable; - [ ] repeated symbolic failure/non-progress can trigger policy-controlled direct escalation; - [ ] direct escalation preserves authority/scope/budget and cannot widen capabilities; - [ ] direct output can be normalized into a rule/plan/evidence/KB candidate and return control to symbolic execution; - [ ] CVE intelligence can be provided by a replaceable expert/tool adapter; - [ ] active/passive authority remains orthogonal to symbolic/direct/RLM reasoning strategy; - [ ] external strategy adapters cannot bypass canonical Hackmode effects/state; - [ ] LISH can explain objective state, extension selection, failure accumulation, and strategy transitions.
nsaspy commented 2026-09-02 17:24:46 +00:00
Author
Owner
Copy link

Hackpert #29 progress landed via #67 at eeca3cf48c265f5fa31863996d0185cfc8722a77.

Implemented the first strategy-control substrate: :symbolic is the default reasoning strategy, non-progress/failure accumulation is policy-owned via a configurable threshold, threshold crossing produces an explicit :escalate decision into :direct, and direct progress produces :resume-symbolic. Plan stop signals remain higher-priority and return explicit reasons. Operation/run identity is validated fail-closed.

Crucially, this does not conflate strategy with authority: passive/active engine authority is unchanged, and changing symbolic/direct strategy grants no effects. No direct-model executor or second scheduler was added.

RED 07b5ec1bb0fe791f2f47d948c40bf7d2838eb40c; GREEN exact head a5697aecee31e951056e1080c28e82913f9fc7cd passed core, monorepo and agent-framework-boundary before expected-head merge.

Hackpert #29 progress landed via #67 at `eeca3cf48c265f5fa31863996d0185cfc8722a77`. Implemented the first strategy-control substrate: `:symbolic` is the default reasoning strategy, non-progress/failure accumulation is policy-owned via a configurable threshold, threshold crossing produces an explicit `:escalate` decision into `:direct`, and direct progress produces `:resume-symbolic`. Plan stop signals remain higher-priority and return explicit reasons. Operation/run identity is validated fail-closed. Crucially, this does not conflate strategy with authority: passive/active engine authority is unchanged, and changing symbolic/direct strategy grants no effects. No direct-model executor or second scheduler was added. RED `07b5ec1bb0fe791f2f47d948c40bf7d2838eb40c`; GREEN exact head `a5697aecee31e951056e1080c28e82913f9fc7cd` passed core, monorepo and agent-framework-boundary before expected-head merge.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert objective/SPEC slice merged via #70 at f39066deb6ac902b4f152d3c389aeddaca3f51dd.

Added a normalized declarative objective model with goal/precondition/evidence/constraint/stop clauses, named non-negative budget limits, deterministic capability grants, and defensive-copy accessors. The model is operation-independent and does not grant provider effects, mutate canonical state, or encode a fixed recon/attack phase order.

Acceptance direction now has a concrete representation for final-identity goals (including uid 0/root-equivalent), foothold prerequisites, evidence requirements, stops, budgets, and granted capabilities.

RED head 9cc6058ae4f0c070f9e3371ada4b477ece51f800: exact-head core failed against the missing objective API while monorepo/boundary passed.
GREEN head 59ddbb8837938bb7f4d53dddcae6a80274b92368: exact-head core, monorepo, and agent-framework-boundary passed; PR #70 had zero reviews and zero unresolved threads before expected-head squash merge.

Hackpert objective/SPEC slice merged via #70 at `f39066deb6ac902b4f152d3c389aeddaca3f51dd`. Added a normalized declarative objective model with goal/precondition/evidence/constraint/stop clauses, named non-negative budget limits, deterministic capability grants, and defensive-copy accessors. The model is operation-independent and does not grant provider effects, mutate canonical state, or encode a fixed recon/attack phase order. Acceptance direction now has a concrete representation for final-identity goals (including uid 0/root-equivalent), foothold prerequisites, evidence requirements, stops, budgets, and granted capabilities. RED head `9cc6058ae4f0c070f9e3371ada4b477ece51f800`: exact-head core failed against the missing objective API while monorepo/boundary passed. GREEN head `59ddbb8837938bb7f4d53dddcae6a80274b92368`: exact-head core, monorepo, and agent-framework-boundary passed; PR #70 had zero reviews and zero unresolved threads before expected-head squash merge.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert open-objective extension-registry slice merged via #73 at d6ef37797da21bd6a0f948269d5d07c2183e64ed.

Added a pure functional extension registry with stable ID/version, understood objective predicates, required capabilities, minimum authority requirement, supported reasoning strategies, deterministic listing, and applicability filtering. A candidate is applicable only when it understands the objective, its required capabilities are both objective-granted and currently available, its authority requirement is satisfied, and the current symbolic/direct strategy is supported.

Authority remains orthogonal to strategy: an active-only extension is rejected under passive authority, and selecting :direct never widens effects. No provider/model executor, scheduler, database internals, or StarIntel product work was added.

RED exact head 7c8babef95c491e6f0164da3865fc78d7a2c2cfe: core failed because MAKE-EXPERT-EXTENSION did not exist; monorepo and agent-framework-boundary passed.
GREEN exact head 66a2e471bc394d1fbbaf1ef92f05576c3ebe7a00: core, monorepo, and agent-framework-boundary all passed twice across the identical-head draft/non-draft transition. PR #73 was mergeable with no review/comments before expected-head squash merge.

Hackpert open-objective extension-registry slice merged via #73 at `d6ef37797da21bd6a0f948269d5d07c2183e64ed`. Added a pure functional extension registry with stable ID/version, understood objective predicates, required capabilities, minimum authority requirement, supported reasoning strategies, deterministic listing, and applicability filtering. A candidate is applicable only when it understands the objective, its required capabilities are both objective-granted and currently available, its authority requirement is satisfied, and the current symbolic/direct strategy is supported. Authority remains orthogonal to strategy: an active-only extension is rejected under passive authority, and selecting `:direct` never widens effects. No provider/model executor, scheduler, database internals, or StarIntel product work was added. RED exact head `7c8babef95c491e6f0164da3865fc78d7a2c2cfe`: core failed because `MAKE-EXPERT-EXTENSION` did not exist; monorepo and agent-framework-boundary passed. GREEN exact head `66a2e471bc394d1fbbaf1ef92f05576c3ebe7a00`: core, monorepo, and agent-framework-boundary all passed twice across the identical-head draft/non-draft transition. PR #73 was mergeable with no review/comments before expected-head squash merge.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert objective-selection slice merged via #76 at 40001b9a08a4632deb116be77f70e7fc82245856.

Added pure objective re-evaluation plus deterministic extension selection with explicit decision provenance. Objective clauses are re-evaluated through a caller-supplied evidence predicate; unmet preconditions/constraints block, unmet goals/evidence remain in-progress, and satisfied objectives select no extension. Candidate records retain why each extension was applicable or rejected for objective mismatch, authority, strategy, objective capability grant, or runtime capability availability.

RED ab9af318cb4f387ad6af7166d037fa9441482a7f failed against the missing selection API. Intermediate head 854b1da4fe58a4b0aa2637331e1ad4bafee8017a exposed a real Common Lisp accessor/helper naming collision, fixed by separating the generated candidate accessor from the admission helper. Corrected exact head c8a67426993450fdec9755fb99811c6ca46ea390 passed core, monorepo, and agent-framework-boundary. The fresh non-draft core run then hit a pre-existing/nondeterministic nhooks asset-event failure on the identical SHA; rerunning that exact failed job passed without code changes, while the prior identical-head core run was already green. No test was weakened or skipped.

Authority remains orthogonal to reasoning strategy and selection performs zero provider execution or canonical mutation. No database internals, second scheduler/executor, or StarIntel product work were added.

Hackpert objective-selection slice merged via #76 at `40001b9a08a4632deb116be77f70e7fc82245856`. Added pure objective re-evaluation plus deterministic extension selection with explicit decision provenance. Objective clauses are re-evaluated through a caller-supplied evidence predicate; unmet preconditions/constraints block, unmet goals/evidence remain in-progress, and satisfied objectives select no extension. Candidate records retain why each extension was applicable or rejected for objective mismatch, authority, strategy, objective capability grant, or runtime capability availability. RED `ab9af318cb4f387ad6af7166d037fa9441482a7f` failed against the missing selection API. Intermediate head `854b1da4fe58a4b0aa2637331e1ad4bafee8017a` exposed a real Common Lisp accessor/helper naming collision, fixed by separating the generated candidate accessor from the admission helper. Corrected exact head `c8a67426993450fdec9755fb99811c6ca46ea390` passed core, monorepo, and agent-framework-boundary. The fresh non-draft core run then hit a pre-existing/nondeterministic nhooks asset-event failure on the identical SHA; rerunning that exact failed job passed without code changes, while the prior identical-head core run was already green. No test was weakened or skipped. Authority remains orthogonal to reasoning strategy and selection performs zero provider execution or canonical mutation. No database internals, second scheduler/executor, or StarIntel product work were added.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert objective-loop progress merged via #79 at 22d1dd98955990c7145798c939b7afe1230e9768.

Added immutable operation/run-scoped budget accounting derived from normalized objective limits. Budget consumption returns a new state, exact zero is exhausted, over-budget consumption fails closed, unknown limits/scope are rejected, and budget state grants no execution authority or persistence ownership.

RED exact head 86181510efa4917548422ab4dd2e534e5959dfbf: core failed while monorepo/boundary passed. GREEN exact head 23e7d94e3de664bce7585add1191016007e1ee48: core, monorepo, and agent-framework-boundary passed. PR #79 was mergeable with zero reviews and zero unresolved review threads before expected-head squash merge.

This supplies the budget-state substrate required by the open objective loop without creating another scheduler or effect boundary.

Hackpert objective-loop progress merged via #79 at `22d1dd98955990c7145798c939b7afe1230e9768`. Added immutable operation/run-scoped budget accounting derived from normalized objective limits. Budget consumption returns a new state, exact zero is exhausted, over-budget consumption fails closed, unknown limits/scope are rejected, and budget state grants no execution authority or persistence ownership. RED exact head `86181510efa4917548422ab4dd2e534e5959dfbf`: core failed while monorepo/boundary passed. GREEN exact head `23e7d94e3de664bce7585add1191016007e1ee48`: core, monorepo, and agent-framework-boundary passed. PR #79 was mergeable with zero reviews and zero unresolved review threads before expected-head squash merge. This supplies the budget-state substrate required by the open objective loop without creating another scheduler or effect boundary.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert #29 progress merged via #82 at cd9405f993e51855716cefaa408c6ab3d9e129f5.

Added a pure budget-aware loop adapter over the existing generic strategy controller. It validates the budget state's exact operation/run/objective identity, derives :budget-exhausted directly from immutable objective budget accounting, and delegates to the existing loop so a declared budget stop wins before ordinary progress/escalation. Available budget leaves normal symbolic/direct decisions unchanged. No provider execution, persistence, model execution, scheduler, or authority widening was added.

RED exact head 3b0751028173e08a65c605a6398b22a3acb9fea9: core failed against the missing budget-aware loop API while monorepo and agent-framework-boundary passed. GREEN exact head beaf4a829b9a0709947024d6431be5e0c166d3f7: core, monorepo, and agent-framework-boundary passed twice across the identical-head draft/non-draft transition. PR #82 was mergeable with zero reviews and zero unresolved review threads before expected-head squash merge.

The budget adapter is intentionally loaded after budget.lisp, avoiding forward-reference/load-order coupling.

Hackpert #29 progress merged via #82 at `cd9405f993e51855716cefaa408c6ab3d9e129f5`. Added a pure budget-aware loop adapter over the existing generic strategy controller. It validates the budget state's exact operation/run/objective identity, derives `:budget-exhausted` directly from immutable objective budget accounting, and delegates to the existing loop so a declared budget stop wins before ordinary progress/escalation. Available budget leaves normal symbolic/direct decisions unchanged. No provider execution, persistence, model execution, scheduler, or authority widening was added. RED exact head `3b0751028173e08a65c605a6398b22a3acb9fea9`: core failed against the missing budget-aware loop API while monorepo and agent-framework-boundary passed. GREEN exact head `beaf4a829b9a0709947024d6431be5e0c166d3f7`: core, monorepo, and agent-framework-boundary passed twice across the identical-head draft/non-draft transition. PR #82 was mergeable with zero reviews and zero unresolved review threads before expected-head squash merge. The budget adapter is intentionally loaded after `budget.lisp`, avoiding forward-reference/load-order coupling.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert objective-selection inspection landed via #104 at ef737401687c5197e8e3173fd434f87d7a81cb04.

The operator surface now joins bounded objective satisfaction/blocker state with extension-selection provenance: objective ID/version/status, unmet clause kind/predicate only, authority, reasoning strategy, selected extension/version, selection reason, and per-candidate admission reason. Objective arguments are excluded entirely, and mutable strings/aggregate returns are defensive copies.

BUG-FIRST: the original #101 exact-head core run exposed a pre-existing find-apis arity/unbound-variable compile regression. That was isolated with a focused collection regression and repaired first via #103 at 691b8baadd59d83be1fe806a084c7ca9b7ea74d5. #104 was then reconstructed forward from that current master rather than forcing the stale branch.

GREEN exact head 63b1ed3ffacd93d327dc6f9cf59e0a574ed50019 passed core, monorepo, and agent-framework-boundary. PR #104 was mergeable with zero reviews and zero unresolved threads before expected-head squash merge. No provider execution, canonical mutation, database internals, scheduler, raw Prolog execution, or StarIntel product work was introduced.

Hackpert objective-selection inspection landed via #104 at `ef737401687c5197e8e3173fd434f87d7a81cb04`. The operator surface now joins bounded objective satisfaction/blocker state with extension-selection provenance: objective ID/version/status, unmet clause kind/predicate only, authority, reasoning strategy, selected extension/version, selection reason, and per-candidate admission reason. Objective arguments are excluded entirely, and mutable strings/aggregate returns are defensive copies. BUG-FIRST: the original #101 exact-head core run exposed a pre-existing `find-apis` arity/unbound-variable compile regression. That was isolated with a focused collection regression and repaired first via #103 at `691b8baadd59d83be1fe806a084c7ca9b7ea74d5`. #104 was then reconstructed forward from that current master rather than forcing the stale branch. GREEN exact head `63b1ed3ffacd93d327dc6f9cf59e0a574ed50019` passed core, monorepo, and agent-framework-boundary. PR #104 was mergeable with zero reviews and zero unresolved threads before expected-head squash merge. No provider execution, canonical mutation, database internals, scheduler, raw Prolog execution, or StarIntel product work was introduced.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert strategy-transition inspection merged via #107 at 3e58dab3d6207e9182c1d52286f41414397b38bf.

Exact PR head 93c1a3d0607d0a20bd543adf01282adfcf8aae5e passed fresh core, monorepo, and agent-framework-boundary after reopening the draft as a normal PR due the recurring GitHub fullDatabaseId ready-for-review connector failure. PR was mergeable with zero reviews and zero unresolved threads; merged with expected-head protection.

The slice exposes bounded symbolic/direct transition provenance (operation/run scope, decision kind/reason, before/after strategy and non-progress counts) and fails closed on cross-scope or decision/state disagreement. No provider execution, persistence/database internals, authority widening, second scheduler, or StarIntel product work.

Hackpert strategy-transition inspection merged via #107 at `3e58dab3d6207e9182c1d52286f41414397b38bf`. Exact PR head `93c1a3d0607d0a20bd543adf01282adfcf8aae5e` passed fresh `core`, `monorepo`, and `agent-framework-boundary` after reopening the draft as a normal PR due the recurring GitHub `fullDatabaseId` ready-for-review connector failure. PR was mergeable with zero reviews and zero unresolved threads; merged with expected-head protection. The slice exposes bounded symbolic/direct transition provenance (operation/run scope, decision kind/reason, before/after strategy and non-progress counts) and fails closed on cross-scope or decision/state disagreement. No provider execution, persistence/database internals, authority widening, second scheduler, or StarIntel product work.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert objective-budget inspection merged via #112 at e2b1b7e6ced734d7bbdb85e862ca83ad6ea60c28.

RED contract: 6072aa6d22bc907c301f070bda74f61bbec3aaa9 required a pure run-scoped budget inspection API before implementation.

After database-only #111 advanced master, the Hackpert branch was reconciled forward without touching source/hackmode-database/**; exact head 9ec0bfe8f498df83fd3dca7d735e1b1292d2422a passed fresh core, monorepo, and agent-framework-boundary twice (draft and non-draft PR runs). PR #112 had zero reviews and zero unresolved threads and was merged with expected-head protection.

The new inspection exposes objective/version, operation/run scope, deterministic per-budget limit/used/remaining/exhausted state, and aggregate exhaustion. Returned strings/entries are defensive copies. It grants no effects and introduces no persistence or scheduler authority.

Hackpert objective-budget inspection merged via #112 at `e2b1b7e6ced734d7bbdb85e862ca83ad6ea60c28`. RED contract: `6072aa6d22bc907c301f070bda74f61bbec3aaa9` required a pure run-scoped budget inspection API before implementation. After database-only #111 advanced `master`, the Hackpert branch was reconciled forward without touching `source/hackmode-database/**`; exact head `9ec0bfe8f498df83fd3dca7d735e1b1292d2422a` passed fresh `core`, `monorepo`, and `agent-framework-boundary` twice (draft and non-draft PR runs). PR #112 had zero reviews and zero unresolved threads and was merged with expected-head protection. The new inspection exposes objective/version, operation/run scope, deterministic per-budget limit/used/remaining/exhausted state, and aggregate exhaustion. Returned strings/entries are defensive copies. It grants no effects and introduces no persistence or scheduler authority.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert bug-first inspection hardening merged via #118.

RED: 74900d58537ea798de9a1bbce28863c5c6449222 added a regression proving mutable string transition reasons could rewrite a supposedly side-effect-free expert-loop-transition-inspection; core failed while monorepo and boundary passed.

GREEN: e01da8f61ec2913ba86bdc91e3786a40ae879d40 snapshots mutable reason strings on construction and returns defensive copies. Fresh non-draft exact-head core, monorepo, and agent-framework-boundary all passed; zero reviews and zero unresolved threads; expected-head squash merge produced 6086587bfb3fe4e29f9b32c6450c15e994968e4a.

No database persistence internals or StarIntel product work touched.

Hackpert bug-first inspection hardening merged via #118. RED: `74900d58537ea798de9a1bbce28863c5c6449222` added a regression proving mutable string transition reasons could rewrite a supposedly side-effect-free `expert-loop-transition-inspection`; core failed while monorepo and boundary passed. GREEN: `e01da8f61ec2913ba86bdc91e3786a40ae879d40` snapshots mutable reason strings on construction and returns defensive copies. Fresh non-draft exact-head core, monorepo, and agent-framework-boundary all passed; zero reviews and zero unresolved threads; expected-head squash merge produced `6086587bfb3fe4e29f9b32c6450c15e994968e4a`. No database persistence internals or StarIntel product work touched.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert #29 progress merged via #120.

Added expert-objective-loop-step, a pure composition boundary that re-evaluates objective clauses and extension applicability on every loop iteration before delegating the next decision to the existing symbolic/direct loop. The step validates plan/objective identity, uses the current loop reasoning strategy for extension admission, derives fresh goal/no-viable-extension signals, and returns evaluation + selection + decision + next state without provider execution, canonical mutation, persistence ownership, or a second scheduler.

RED exact head 4d12338f76f6b33d8d8143058e8c530445b00a71: core failed exactly because HACKMODE:EXPERT-OBJECTIVE-LOOP-STEP was absent; monorepo and agent-framework-boundary passed.

GREEN exact head d0ff9b626391e6ada768d45c066a54f9765b84c5: core, monorepo, and agent-framework-boundary all passed twice across the identical-head draft/non-draft transition. PR #120 was mergeable with zero reviews and zero unresolved threads before expected-head squash merge. Merge SHA: 54e61994188ab99276a64dac7454cd9f01c8dc12.

No database-owned files or StarIntel product work were touched.

Hackpert #29 progress merged via #120. Added `expert-objective-loop-step`, a pure composition boundary that re-evaluates objective clauses and extension applicability on every loop iteration before delegating the next decision to the existing symbolic/direct loop. The step validates plan/objective identity, uses the current loop reasoning strategy for extension admission, derives fresh goal/no-viable-extension signals, and returns evaluation + selection + decision + next state without provider execution, canonical mutation, persistence ownership, or a second scheduler. RED exact head `4d12338f76f6b33d8d8143058e8c530445b00a71`: core failed exactly because `HACKMODE:EXPERT-OBJECTIVE-LOOP-STEP` was absent; monorepo and agent-framework-boundary passed. GREEN exact head `d0ff9b626391e6ada768d45c066a54f9765b84c5`: core, monorepo, and agent-framework-boundary all passed twice across the identical-head draft/non-draft transition. PR #120 was mergeable with zero reviews and zero unresolved threads before expected-head squash merge. Merge SHA: `54e61994188ab99276a64dac7454cd9f01c8dc12`. No database-owned files or StarIntel product work were touched.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert bug-first slice merged via #126.

RED exact head dbb1f7170cccca5794f1e88ab919f96f1387b10d: core failed the new regression because mutating expert-direct-candidate-operation changed the stored candidate ("op-a" -> "Xp-a"). The same regression also covers run ID, nested payload strings, and provenance strings.

GREEN exact implementation head 37dbcb78dabcea3d7bb2875d00386922e7ef59a7: direct candidates now use private raw struct accessors, while the public operation/run/payload/provenance accessors return defensive snapshots. Internal scope validation reads the private normalized snapshot. Constructor defensive-copy semantics remain intact.

Fresh non-draft #126 runs at the identical head passed core, monorepo, and agent-framework-boundary. Zero reviews and zero unresolved threads. Expected-head squash merge produced master 4dfed971f03f728eef1c935e5c5f7d86b3a36c68.

No database/persistence internals, provider execution authority, second scheduler, or StarIntel product work touched.

Hackpert bug-first slice merged via #126. RED exact head `dbb1f7170cccca5794f1e88ab919f96f1387b10d`: core failed the new regression because mutating `expert-direct-candidate-operation` changed the stored candidate (`"op-a"` -> `"Xp-a"`). The same regression also covers run ID, nested payload strings, and provenance strings. GREEN exact implementation head `37dbcb78dabcea3d7bb2875d00386922e7ef59a7`: direct candidates now use private raw struct accessors, while the public operation/run/payload/provenance accessors return defensive snapshots. Internal scope validation reads the private normalized snapshot. Constructor defensive-copy semantics remain intact. Fresh non-draft #126 runs at the identical head passed core, monorepo, and agent-framework-boundary. Zero reviews and zero unresolved threads. Expected-head squash merge produced master `4dfed971f03f728eef1c935e5c5f7d86b3a36c68`. No database/persistence internals, provider execution authority, second scheduler, or StarIntel product work touched.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert bug-first slice merged via #128.

RED: fcffc429a03ec2755fd5255695eaeb44b503e548 added constructor/accessor aliasing regressions for expert-loop-state; common-lisp-core failed while hygiene and the product-tree boundary remained green.

GREEN: a13e9cab27672b481b88073139daccb5dca7db0e makes operation/run scope strings owned defensive snapshots at constructor, copy, and public accessor boundaries. Fresh non-draft PR #128 reran the exact same head and passed common-lisp-core, hygiene, product-tree boundary, and one-open-PR lane; zero reviews and zero unresolved threads.

Merged with expected-head squash protection. master is now d9e358d97830018ffd0760c99fa4a67642e5272f.

No database internals, StarIntel product work, authority changes, provider execution changes, or second scheduler/storage boundary.

Hackpert bug-first slice merged via #128. RED: `fcffc429a03ec2755fd5255695eaeb44b503e548` added constructor/accessor aliasing regressions for `expert-loop-state`; `common-lisp-core` failed while hygiene and the product-tree boundary remained green. GREEN: `a13e9cab27672b481b88073139daccb5dca7db0e` makes operation/run scope strings owned defensive snapshots at constructor, copy, and public accessor boundaries. Fresh non-draft PR #128 reran the exact same head and passed common-lisp-core, hygiene, product-tree boundary, and one-open-PR lane; zero reviews and zero unresolved threads. Merged with expected-head squash protection. `master` is now `d9e358d97830018ffd0760c99fa4a67642e5272f`. No database internals, StarIntel product work, authority changes, provider execution changes, or second scheduler/storage boundary.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Hackpert bug-first slice merged via #131.

RED: test-only eeb953068ea0d3897714fe082bca77d364f423f4 mutated caller-owned and accessor-returned expert-loop-state last-reason strings; common-lisp-core failed while lane/boundary/hygiene checks stayed green.

GREEN: exact implementation head 471cde75f273982c5ef609c0bc67f2051a20ceb3 snapshots mutable reason text on construction/transition and public access. Fresh #131 runs passed common-lisp-core, hygiene, keep-agent-framework-out-of-product-tree, and one-open-pr-per-agent-lane; zero reviews/unresolved threads. Expected-head squash merged as d43cee30cdbc692b33d91448563bc49ca2d87909.

Ownership stayed inside Hackpert loop state/tests; no database internals or StarIntel product work.

Hackpert bug-first slice merged via #131. RED: test-only `eeb953068ea0d3897714fe082bca77d364f423f4` mutated caller-owned and accessor-returned `expert-loop-state` last-reason strings; `common-lisp-core` failed while lane/boundary/hygiene checks stayed green. GREEN: exact implementation head `471cde75f273982c5ef609c0bc67f2051a20ceb3` snapshots mutable reason text on construction/transition and public access. Fresh #131 runs passed `common-lisp-core`, `hygiene`, `keep-agent-framework-out-of-product-tree`, and `one-open-pr-per-agent-lane`; zero reviews/unresolved threads. Expected-head squash merged as `d43cee30cdbc692b33d91448563bc49ca2d87909`. Ownership stayed inside Hackpert loop state/tests; no database internals or StarIntel product work.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Merged #164 as 3ebcedf63b15ceafb7c620a083135bc00d6a6d0f.

Bug-first slice: expert-objective was documented immutable-by-interface, but caller-owned and returned mutable id/version strings could rewrite objective identity in place and poison objective/plan/extension matching without a canonical mutation.

RED: af3821c48c4f2cddd6698c56cf756927f72671a9 reached the ASDF test step and failed on the new aliasing regression.

GREEN: 1cdf5bd754e31319448a3fbd0838a2de39f3b8ff passed core, monorepo/hygiene, and product-tree boundary. The fix snapshots ID/version on construction and returns defensive public snapshots using private raw struct accessors.

Authority unchanged: no provider execution, DB/Tek9 mutation, scheduler change, Prolog effect path, or StarIntel product work.

Merged #164 as `3ebcedf63b15ceafb7c620a083135bc00d6a6d0f`. Bug-first slice: `expert-objective` was documented immutable-by-interface, but caller-owned and returned mutable `id`/`version` strings could rewrite objective identity in place and poison objective/plan/extension matching without a canonical mutation. RED: `af3821c48c4f2cddd6698c56cf756927f72671a9` reached the ASDF test step and failed on the new aliasing regression. GREEN: `1cdf5bd754e31319448a3fbd0838a2de39f3b8ff` passed core, monorepo/hygiene, and product-tree boundary. The fix snapshots ID/version on construction and returns defensive public snapshots using private raw struct accessors. Authority unchanged: no provider execution, DB/Tek9 mutation, scheduler change, Prolog effect path, or StarIntel product work.
nsaspy commented 2026-09-02 17:24:47 +00:00
Author
Owner
Copy link

Auto-RAGE Hackpert slice merged via #168 as f2d10dd17b07f7ad0fa69dbc9f84498432911324.

RED: test-only head c396578d7d81015f6f40b4ab35d438b06f727241 failed common-lisp-core exactly because mutating the caller-owned extension ID rewrote stable-extension to Xtable-extension; monorepo and agent-framework-boundary were green.

GREEN: implementation head ba0e4ae664705c7c108b30d5132e73e44854625c snapshots expert-extension ID/version strings at construction and returns defensive public identity copies using private struct accessors. common-lisp-core, monorepo, and agent-framework-boundary were all green twice on that exact head. Zero reviews/unresolved threads. No provider/effect/database/StarIntel authority change.

Auto-RAGE Hackpert slice merged via #168 as `f2d10dd17b07f7ad0fa69dbc9f84498432911324`. RED: test-only head `c396578d7d81015f6f40b4ab35d438b06f727241` failed `common-lisp-core` exactly because mutating the caller-owned extension ID rewrote `stable-extension` to `Xtable-extension`; monorepo and agent-framework-boundary were green. GREEN: implementation head `ba0e4ae664705c7c108b30d5132e73e44854625c` snapshots expert-extension ID/version strings at construction and returns defensive public identity copies using private struct accessors. `common-lisp-core`, `monorepo`, and `agent-framework-boundary` were all green twice on that exact head. Zero reviews/unresolved threads. No provider/effect/database/StarIntel authority change.
nsaspy commented 2026-09-05 07:54:04 +00:00
Author
Owner
Copy link

ZeroForge direction is now authorized

The earlier tentative ZeroForge language in this issue is superseded by the explicit public-port authorization in #190.

Current direction:

  • use the private ZeroForge implementation as authorized reference material;
  • port useful behavior into public Hackpert / Prolog-RLM symbolic experts, rules, plans, evidence requirements, verification and repair semantics;
  • do not preserve ZeroForge as a second scheduler/authority/runtime;
  • do not publish private source/history/secrets verbatim as the migration mechanism;
  • public implementation must stand alone without the private repo at runtime.

Reusable semantic-port machinery is tracked upstream in lost-rob0t/prolog-rlm#390; Hackmode product integration/public expert families are owned by #190.

The two-axis invariant in this issue remains authoritative: Hackmode passive|active authority is separate from Prolog-RLM reasoning strategy.

## ZeroForge direction is now authorized The earlier tentative ZeroForge language in this issue is superseded by the explicit public-port authorization in #190. Current direction: - use the private ZeroForge implementation as authorized reference material; - port useful behavior into public Hackpert / Prolog-RLM symbolic experts, rules, plans, evidence requirements, verification and repair semantics; - do not preserve ZeroForge as a second scheduler/authority/runtime; - do not publish private source/history/secrets verbatim as the migration mechanism; - public implementation must stand alone without the private repo at runtime. Reusable semantic-port machinery is tracked upstream in `lost-rob0t/prolog-rlm#390`; Hackmode product integration/public expert families are owned by #190. The two-axis invariant in this issue remains authoritative: Hackmode `passive|active` authority is separate from Prolog-RLM reasoning strategy.
Sign in to join this conversation.
No Branch/Tag specified
Branches Tags
master
feat/android-operation-bridge
feat/star-bbpd-hackmode-actor-port
starintel/actor-ontology
first-party/starintel-recon-fold
chatgpt/201-starintel-target-receivers-20260917
impl/202-proxy-config
feature/issue-201-tool-actors
fix/core-expert-inspection-duplicate-accessors
feat/hm-cli-entrypoints
ops/restore-hackmode-workers-20260904
gpt/hackpert-objective-value-freeze
feature/retire-rage-workers
hackmode-rage-database/26-ipx-replay-parser-run10
rage-hackpert/29-freeze-selection-identity
rage/29-freeze-selection-identity
rage/15-ingest-by-state
rage/15-ingest-by-state-red-proof
auto-rage-hackpert/29-extension-identity-snapshot
hackmode-db/15-investigation-asset-views
hackpert/issue-29-objective-identity-aliasing
issue-138-http-request-contract
hackmode-rage-hackpert/issue-138-http-requester
db/143-visual-outbox
hackmode-rage-hackpert/137-http-transport-profile-20260901
rage-db/142-visual-scope-order
hackmode-rage-hackpert/136-ipx-addon
hackmode-rage-hackpert/135-capture-supervisor
rage-db/142-visual-evidence
hackmode-rage-hackpert/inspection-last-reason-20260831
hackmode-rage-database/http-header-policy-20260831-1343
hackmode-rage-database/typed-global-fetch-20260831-1102
hackpert/loop-reason-copy
hackmode-rage-hackpert/29-loop-scope-defensive-copy
rage-db/typed-long-term-fetch-11
rage-hackpert/direct-candidate-defensive-access-11
hackmode-rage-hackpert/29-direct-candidate-normalization
hackmode-rage-database/typed-operational-kb-fetch-20260831
rage-hackpert-12-objective-loop-step
rage-db-11-atomic-seed-import
hackmode-rage-hackpert/transition-reason-copy
hackpert/inspection-defensive-string-copies
auto-rage-database/op-kb-retraction-target-run11
hackmode-rage-hackpert/budget-inspection-20260831
auto-rage-database/global-export-canonical-source-20260831
hackmode-rage-database/live-promotion-source-20260831
hackmode-rage-hackpert/29-loop-transition-inspection
rage-database/capture-rotation-fork-20260831
hackmode-rage-hackpert/objective-selection-inspection-forward
hackmode-rage-hackpert/fix-find-apis-core-gate
hackmode-rage-hackpert/objective-selection-inspection
hackmode-rage-database/capture-source-rotation-20260830
hackmode-rage-hackpert/27-action-admission-inspection
hackmode-rage-hackpert/27-action-inspection
hackmode-rage-database/capture-quarantine-20260830-r2
hackmode-rage-hackpert/27-plan-inspection
hackmode-rage-database/capture-quarantine-20260830
hackmode-rage-hackpert/27-run-inspection
hackmode-rage-database/26-capture-checkpoint-20260830-1600
hackmode-rage-hackpert/26-http-exchange-snapshot
hackmode-rage-database/http-exchange-graph-20260830
hackmode-rage-hackpert/29-budget-loop-admission
auto-rage-db-effective-kb-20260830-1357
hackmode-rage-hackpert/29-objective-budget
hackmode-rage-database/24-execution-outcome-kb-candidates-reconcile-3
hackmode-rage-hackpert/29-objective-selection
hackmode-rage-database/24-execution-outcome-kb-candidates-reconcile-2
hackmode-rage-hackpert/29-extension-registry
hackmode-rage-database/24-execution-outcome-kb-candidates-reconcile
hackmode-rage-hackpert/29-objective-spec
hackmode-rage-database/24-execution-outcome-kb-candidates
hackpert/27-loop-stop-escalation
hackmode-rage-database/24-kb-seed-import
hackmode-rage-hackpert/27-recon-expert
hackmode-rage-database/24-reusable-kb-reads
hackmode-rage-hackpert/27-canonical-snapshot-refresh
hackmode-rage-database/24-operation-snapshot-reads
hackmode-rage-hackpert/27-plan-playbook-primitives
hackmode-rage-database/24-replay-conflict
hackmode-hackpert/27-graph-kb-snapshot
hackmode-rage-database/24-global-kb-export-forward
hackmode-rage-hackpert/48-recon-providers-forward
hackmode-rage-database/24-global-kb-export
hackmode-rage-hackpert/27-provider-orchestration-v2
hackmode-rage-database/24-long-term-kb-promotion
feature/hackpert-recon-toolkit
hackmode-rage-hackpert/27-provider-orchestration
fix/forbid-agent-framework-leakage
hackmode-rage-database/24-operational-kb
hackmode-rage-hackpert/27-active-action-protocol
rage-database/24-execution-graph-foundation
fix/agent-zero-only-rage
ci/rage-pr-serialization
rage-hackpert/27-engine-authority-mode
feature/30-auto-rage-profiles
feature/31-rage-worker-scope
feature/24-hackpert-expert-layer
agent/provider-actor-dns-slice
agent/persistent-operation-outbox
agent/starintel-document-projection
agent/reproducible-core-ci
agent/curate-hackmode-scripts
agent/canonical-operation-asset-protocol
agent/hackmode-monorepo-foundation
No results found.
Labels
Clear labels   
bug
Something isn't working

  
documentation
Improvements or additions to documentation

  
duplicate
This issue or pull request already exists

  
enhancement
New feature or request

  
feature
New feature or capability

  
good first issue
Good for newcomers

  
help wanted
Extra attention is needed

  
invalid
This doesn't seem right

  
question
Further information is requested

  
refactor
Code cleanup without behavior change

  
wontfix
This will not be worked on

No labels
bug
documentation
duplicate
enhancement
feature
good first issue
help wanted
invalid
question
refactor
wontfix
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
nsaspy/hackmode#47
No description provided.