> ## Documentation Index
> Fetch the complete documentation index at: https://docs.erna.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Feedback

> Understand instruction-level schedule feedback, failures, and solver errors

dabke reports schedule quality through instruction-level `feedback`. Feedback is designed for API clients, MCP tools, and LLM consumption. It answers whether scheduling instructions were followed without exposing solver implementation details such as internal constraint buckets.

## Compilation feedback

`ModelBuilder.compile()` returns `feedback` alongside the solver request:

```typescript theme={null}
const { request, canSolve, feedback } = builder.compile();

if (!canSolve) {
  console.error(
    feedback.details
      .flatMap((detail) => detail.checks)
      .filter((check) => check.outcome === "error"),
  );
}
```

The `canSolve` flag is `false` when structural errors make solving impossible, for example coverage requirements that reference roles no team member has.

## Solve feedback

`schedule(...).solve(...)` returns the same feedback shape after analyzing the solver result:

```typescript theme={null}
const result = await schedule({
  // ...
}).solve(client, { dateRange: { start: "2026-02-02", end: "2026-02-08" } });

console.log(result.feedback.status);
console.log(result.feedback.details);
```

## Feedback structure

A `FeedbackReport` contains:

* `status`: `"pass"`, `"has_failures"`, or `"has_errors"`
* `summary`: check counts by `pass`, `fail`, and `error`
* `details`: grouped feedback for one instruction or report-level concern
* `checks`: factual checks inside each detail

```typescript theme={null}
for (const detail of result.feedback.details) {
  for (const check of detail.checks) {
    console.log(`${detail.title}: ${check.outcome}: ${check.message}`);
  }
}
```

## Outcomes

* `pass`: the instruction was followed
* `fail`: a soft instruction was evaluated and not fully followed
* `error`: compilation or solving found a blocking issue

When an instruction fully passes, dabke emits a concise check for the whole instruction:

```json theme={null}
{
  "id": "instr:1",
  "title": "1x staff during office_hours",
  "checks": [{ "outcome": "pass", "message": "Passed." }]
}
```

When an instruction has failures, dabke groups facts by outcome and merges adjacent dates and time ranges where possible:

```json theme={null}
{
  "id": "instr:2",
  "title": "Time off for alice on 2024-02-01, 2024-02-02",
  "checks": [
    {
      "outcome": "fail",
      "message": "Failed on 2024-02-01.",
      "data": {
        "dateRanges": [{ "start": "2024-02-01", "end": "2024-02-01" }],
        "memberIds": ["alice"],
        "overflow": { "min": 1, "max": 1 }
      }
    }
  ]
}
```

## Custom rule feedback

Custom rule descriptors should prefer solver artifacts with `context` for solve-time checks and compile findings for phase errors. Prefer factual messages that describe what happened. Do not include remediation instructions unless your API surface explicitly needs them.